Enumerações

A palavra-chave enum permite a criação dum tipo que pode ser um das poucas variantes diferentes. Qualquer que é válido como uma struct é também válido numa enum.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
// Criar uma `enum` para classificar um evento de Web.
// Nota como nomes e o tipo da informação juntos especificam a variante:
// `PageLoad != PageUnload` e `KeyPress(char) != Paste(String)`.
// Cada um é diferente e independente.
enum WebEvent {
    // Uma variante `enum` pode ser qualquer`unit-like`,
    PageLoad,
    PageUnload,
    // como estruturas de tupla,
    KeyPress(char),
    Paste(String),
    // ou estruturas parecidas de C.
    Click { x: i64, y: i64 },
}
// Uma função que recebe uma enumeração `WebEvent` como
// um argumento e não retorna nada.
fn inspect(event: WebEvent) {
    match event {
        WebEvent::PageLoad => println!("page loaded"),
        WebEvent::PageUnload => println!("page unloaded"),
        // Desestruturar `c` a partir duma variante `enum`.
        WebEvent::KeyPress(c) => println!("pressed '{}'.", c),
        WebEvent::Paste(s) => println!("pasted \"{}\".", s),
        // Desestruturar `Click` para `x` e `y`.
        WebEvent::Click { x, y } => {
            println!("clicked at x={}, y={}.", x, y);
        },
    }
}
fn main() {
    let pressed = WebEvent::KeyPress('x');
    // `to_owned()` cria uma `String` própria a partir
    // dum pedaço de sequência de caracteres.
    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

Pseudónimos de Tipo

Se usas um pseudónimo de tipo, podes fazer referência a cada variante de enumeração através do pseudónimo. Isto pode ser útil se o nome da enumeração for muito longo ou muito genérico, e queres renomeá-lo.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
enum VeryVerboseEnumOfThingsToDoWithNumbers {
    Add,
    Subtract,
}
// Creates a type alias
// Cria um pseudónimo de tipo
type Operations = VeryVerboseEnumOfThingsToDoWithNumbers;
fn main() {
    // Nós podemos fazer referência a cada variante através do pseudónimo,
    // e não seu nome longo e inconveniente.
    let x = Operations::Add;
}
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

O lugar mais comum que verás isto é em blocos impl usando o pseudónimo Self.

1
2
3
4
5
6
7
8
9
10
11
12
13
enum VeryVerboseEnumOfThingsToDoWithNumbers {
    Add,
    Subtract,
}
impl VeryVerboseEnumOfThingsToDoWithNumbers {
    fn run(&self, x: i32, y: i32) -> i32 {
        match self {
            Self::Add => x + y,
            Self::Subtract => x - y,
        }
    }
}
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Para saberes mais sobre as enumerações e pseudónimos de tipo, podes ler o relatório de estabilização a partir de quando esta funcionalidade foi estabilizada para Rust.

Consulte também:

match, fn, e String, RFC dos "Pseudónimos de tipo e variantes de enumeração" RFC