Enums

The enum keyword allows the creation of a type which may be one of a few different variants. Any variant which is valid as a struct is also valid as an enum.

1. // An attribute to hide warnings for unused code.
2. #![allow(dead_code)]

4. // Create an `enum` to classify a web event. Note how both
5. // names and type information together specify the variant:
6. // `PageLoad != PageUnload` and `KeyPress(char) != Paste(String)`.
7. // Each is different and independent.
8. enum WebEvent {
9. // An `enum` may either be `unit-like`,
10. PageLoad,
11. PageUnload,
12. // like tuple structs,
13. KeyPress(char),
14. Paste(String),
15. // or like structures.
16. Click { x: i64, y: i64 },
17. }

19. // A function which takes a `WebEvent` enum as an argument and
20. // returns nothing.
21. fn inspect(event: WebEvent) {
22. match event {
23. WebEvent::PageLoad => println!("page loaded"),
24. WebEvent::PageUnload => println!("page unloaded"),
25. // Destructure `c` from inside the `enum`.
26. WebEvent::KeyPress(c) => println!("pressed '{}'.", c),
27. WebEvent::Paste(s) => println!("pasted \"{}\".", s),
28. // Destructure `Click` into `x` and `y`.
29. WebEvent::Click { x, y } => {
30. println!("clicked at x={}, y={}.", x, y);
31. },
32. }
33. }

35. fn main() {
36. let pressed = WebEvent::KeyPress('x');
37. // `to_owned()` creates an owned `String` from a string slice.
38. let pasted  = WebEvent::Paste("my text".to_owned());
39. let click   = WebEvent::Click { x: 20, y: 80 };
40. let load    = WebEvent::PageLoad;
41. let unload  = WebEvent::PageUnload;

43. inspect(pressed);
44. inspect(pasted);
45. inspect(click);
46. inspect(load);
47. inspect(unload);
48. }

See also:

attributes, match, fn, and String