Caso de Teste: Lista Ligada

Um maneira comum de implementar uma lista ligada é através de enums:

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
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
use crate::List::*;
enum List {
    // Cons: estrutura de tipo que envolve um elemento e 
    // um ponteiro para o próximo nó.
    Cons(u32, Box<List>),
    // Nil: Um nó que significa o fim da lista ligada
    Nil,
}
// Os métodos podem ser anexados à numa enumeração
impl List {
    // Criar uma lista vazia
    fn new() -> List {
        // `Nil` tem o tipo `List`
        Nil
    }
    // Consumir uma lista, e retornar a mesma lista com
    // um novo elemento na sua frente
    fn prepend(self, elem: u32) -> List {
        // `Cons` também tem o tipo `List`
        Cons(elem, Box::new(self))
    }
    // Retornar o comprimento da lista
    fn len(&self) -> u32 {
        // `self` precisa ser correspondido, porque o comportamento deste método
        // depende da variante do `self`.
        // `self` tem o tipo `&List`, e `*self` tem o tipo `List`,
        // correspondência dum tipo concreto `T` é preferida sobre 
        // uma correspondência numa referência `&T`, depois da Rust 2018 
        // podes usar `self` aqui e também perseguir (sem referência) abaixo,
        // Rust inferirá `&s` e referenciará a cauda.
        // See https://doc.rust-lang.org/edition-guide/rust-2018/ownership-and-lifetimes/default-match-bindings.html
        match *self {
            // Não possível tomar posse da cauda, porque `self` é emprestado;
            // ao invés disto recebe uma referência à cauda
            Cons(_, ref tail) => 1 + tail.len(),
            // Caso de Base: Uma lista vaziam tem comprimento zero
            Nil => 0
        }
    }
    // Retornar a representação da lista como uma
    // sequência de caracteres (monte alocado)
    fn stringify(&self) -> String {
        match *self {
            Cons(head, ref tail) => {
                // `format!` é semelhante à `print!`, mas retorna uma
                // sequência de caracteres de monte alocado de impressão
                // para a consola.
                format!("{}, {}", head, tail.stringify())
            },
            Nil => {
                format!("Nil")
            },
        }
    }
}
fn main() {
    // Criar uma lista ligada vazia
    let mut list = List::new();
    // Adicionar ao começo da lista alguns elementos
    list = list.prepend(1);
    list = list.prepend(2);
    list = list.prepend(3);
    // Mostrar o estado final da lista
    println!("linked list has length: {}", list.len());
    println!("{}", list.stringify());
}
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Consulte também:

Box e métodos