Question

How to use enum in Rust

Answer 1

#[derive(Debug)]
#[allow(dead_code)]

enum ProgrammingLanguages {
    Rust,
    Java,
    C,
}

struct Language {
    name: ProgrammingLanguages
}


fn main() {
    let language1 = Language {
        name: ProgrammingLanguages::Rust
    };

    println!("{:#?}", language1.name);
    
    
    let language2 = Language {
        name: ProgrammingLanguages::C
    };

    println!("{:#?}", language2.name);
}






/*
run:

Rust
C

*/

 

70+ SQL courses for beginners and professionals

Answer 2

#[derive(Debug)]

enum Color {
    Red,
    Green,
    Blue
}

fn main() {
    let red = Color::Red;
    let green = Color::Green;
    let blue = Color::Blue;

    println!("{:?}", red);
    println!("{:?}", green);
    println!("{:?}", blue);
}





/*
run:

Red
Green
Blue

*/

 

70+ SQL courses for beginners and professionals

Answer 3

#[derive(Debug)]

 enum Math {
    PI(f64),
    Valid(bool),
}

fn main() {
    let pi = Math::PI(3.14);
    let bool = Math::Valid(true);

    println!("pi = {:?}", pi);
    println!("bool = {:?}", bool);
}





/*
run:

pi = PI(3.14)
bool = Valid(true)

*/

 

70+ SQL courses for beginners and professionals

Answer 4

#[allow(dead_code)]
#[derive(Debug)]

enum Game {
    Exit,
    Print(String),
    Position { x: i32, y: i32 },
    SetColor(i32, i32, i32),
}
    
fn main() {

    let exit = Game::Exit;
    let print = Game::Print(String::from("Game Start"));
    let position = Game::Position { x: 420, y: 540 };
    let color = Game::SetColor(255, 80, 121);

    println!("exit = {:?}", exit);
    println!("print = {:?}", print);
    println!("position = {:?}", position);
    println!("color = {:?}", color);
}




/*
run:

exit = Exit
print = Print("Game Start")
position = Position { x: 420, y: 540 }
color = SetColor(255, 80, 121)

*/

 

70+ SQL courses for beginners and professionals

Answer 5

#[allow(dead_code)]
#[derive(Debug)]

enum Animal {
    Cat(String, f64),
    Dog(String, f64),
}
    
fn main() {

    let cat = Animal::Cat("Luna".to_string(), 8.5);

    println!("{:?}", cat);
}




/*
run:

Cat("Luna", 8.5)

*/

 

70+ SQL courses for beginners and professionals

Answer 6

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
}

impl Message {
    // A method to process each message variant using pattern matching
    fn process(&self) {
        match self {
            Message::Quit => {
                println!("-> Quit variant received. Exiting...");
            }
            Message::Move { x, y } => {
                println!("-> Moving to coordinates: x = {}, y = {}", x, y);
            }
            Message::Write(text) => {
                println!("-> Text message content: \"{}\"", text);
            }
        }
    }
}

fn main() {
    // 1. Instantiate the variants of the Message enum
    let msg1 = Message::Quit;
    let msg2 = Message::Move { x: 15, y: 30 };
    let msg3 = Message::Write(String::from("Hello, Rust!"));

    // 2. Put them in a collection or process them individually
    let messages = [msg1, msg2, msg3];

    println!("Processing messages...\n");

    for message in &messages {
        message.process();
    }
}


/*
run:

Processing messages...

-> Quit variant received. Exiting...
-> Moving to coordinates: x = 15, y = 30
-> Text message content: "Hello, Rust!"

*/

 

70+ SQL courses for beginners and professionals