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