Rust by Example

הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

To learn more about enums and type aliases, you can read the stabilization report from when this feature was stabilized into Rust.

See also:

match, fn, and String, "Type alias enum variants" RFC

use

The use declaration can be used so manual scoping isn't needed:

// An attribute to hide warnings for unused code.

#![allow(dead_code)]

enum Status {

Rich,

Poor,

}

enum Work {

Civilian,

Soldier,

}

fn main() {

// Explicitly `use` each name so they are available without

// manual scoping.

use crate::Status::{Poor, Rich};

// Automatically `use` each name inside `Work`.

use crate::Work::*;

// Equivalent to `Status::Poor`.

let status = Poor;

// Equivalent to `Work::Civilian`.

let work = Civilian;

match status {

// Note the lack of scoping because of the explicit `use` above.

Rich => println!("The rich have lots of money!"),

Poor => println!("The poor have no money..."),

}

match work {

// Note again the lack of scoping.

Civilian => println!("Civilians work!"),

Soldier => println!("Soldiers fight!"),

}

}

הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

See also:

match and use

C-like

enum can also be used as C-like enums.

// An attribute to hide warnings for unused code.

#![allow(dead_code)]

// enum with implicit discriminator (starts at 0)

enum Number {

Zero,

One,

Two,

}

// enum with explicit discriminator

enum Color {

Red = 0xff0000,

Green = 0x00ff00,

Blue = 0x0000ff,

}

fn main() {

// `enums` can be cast as integers.

println!("zero is {}", Number::Zero as i32);

println!("one is {}", Number::One as i32);

println!("roses are #{:06x}", Color::Red as i32);

println!("violets are #{:06x}", Color::Blue as i32);

}