Rust by Example

WebEvent::PageLoad => println!("page loaded"),

WebEvent::PageUnload => println!("page unloaded"),

// Destructure `c` from inside the `enum`.

WebEvent::KeyPress(c) => println!("pressed '{}'.", c),

WebEvent::Paste(s) => println!("pasted \"{}\".", s),

// Destructure `Click` into `x` and `y`.

WebEvent::Click { x, y } => {

println!("clicked at x={}, y={}.", x, y);

},

}

}

fn main() {

let pressed = WebEvent::KeyPress('x');

// `to_owned()` creates an owned `String` from a string slice.

let pasted = WebEvent::Paste("my text".to_owned());

let click = WebEvent::Click { x: 20, y: 80 };

let load = WebEvent::PageLoad;

let unload = WebEvent::PageUnload;

inspect(pressed);

inspect(pasted);

inspect(click);

inspect(load);

inspect(unload);

}

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

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Type aliases

If you use a type alias, you can refer to each enum variant via its alias. This might be useful if the enum's name is too long or too generic, and you want to rename it.

enum VeryVerboseEnumOfThingsToDoWithNumbers {

Add,

Subtract,

}

// Creates a type alias

type Operations = VeryVerboseEnumOfThingsToDoWithNumbers;

fn main() {

// We can refer to each variant via its alias, not its long and inconvenient

// name.

let x = Operations::Add;

}

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

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

The most common place you'll see this is in impl blocks using the Self alias.

enum VeryVerboseEnumOfThingsToDoWithNumbers {

Add,

Subtract,

}

impl VeryVerboseEnumOfThingsToDoWithNumbers {

fn run(&self, x: i32, y: i32) -> i32 {

match self {

Self::Add => x + y,

Self::Subtract => x - y,

}

}

}