Jogo de RPG

Referências nulas

Se você já usou outra linguagem de programação (C/C++, Python, Java, Ruby, Lisp etc.), é provável que já tenha encontrado null ou nil antes. O uso de null ou nil é como essas linguagens indicam que uma determinada variável não tem valor. No entanto, isso faz com que usar sem querer uma variável que aponta para null seja um erro fácil (e frequente) de cometer. Como você pode imaginar, tentar chamar uma função que não existe ou acessar um valor que não existe pode levar a todo tipo de bug e travamento. O criador do null chegou a chamá-lo de seu 'erro de um bilhão de dólares'.

O tipo Option

Para evitar esses problemas, Rust não usa referências nulas. No entanto, ele ainda precisa de uma forma segura de indicar que uma determinada variável não tem valor. É aí que o Option entra. Em vez de ter uma variável sem valor, as variáveis de Rust podem usar o enum Option. Esse enum tem duas variantes: None, o equivalente ao null no Rust; e Some(T), onde T é um valor de qualquer tipo.

Ele se parece com isto:

enum Option<T> {
    None,
    Some(T),
}

Você pode pensar no Option como uma camada de segurança entre você e os problemas que as referências nulas podem causar, mantendo ainda assim a utilidade conceitual delas.

Usando Option

Definir uma variável como None é bem simples:

let nothing: Option<u32> = None;  // Variable nothing is set to None

No entanto, se você quiser que o tipo Option carregue um valor, não pode atribuir esse valor diretamente. Uma variável do tipo Option e, digamos, uma variável do tipo i32 não são equivalentes. Você vai precisar usar Some:

let wrong_way: Option<i32> = -4; // This will not work

let right_way: Option<i32> = Some(-4); // This will work
let another_right_way = Some(-4); // Compiler infers that this is Option<i32>

É também por esse motivo que o seguinte não vai funcionar:

let number = 47;
let option_number = Some(15);

let compile_error = number + option_number; // Cannot add an i32 and an Option<i32> - they are of different types

Se você quiser obter o valor contido em Some, primeiro vai precisar verificar se ele existe:

let mut some_words = Some("choose something to say"); // some_words set to something

match some_words {
    Some(str) => println!("Here, we will {}", str),
    None => println!("I've got nothing to say"),
} // Prints "Here, we will choose something to say"

some_words = None; // some_words now set to None

// exactly the same match block as above
match some_words {
    Some(str) => println!("Here, we will {}", str),
    None => println!("I've got nothing to say"),
} // Prints "I've got nothing to say"

Além do match, Rust tem outras ferramentas disponíveis para verificar e acessar valores contidos em um Option, mas o match já deve ser familiar para você a essa altura.

Além disso, encare isto como uma demonstração de por que Rust usa Option em vez de uma referência nula. O ponto é que você precisa verificar se a variável Option é Some (e nesse caso pode extrair e usar o valor contido nela) ou None. Qualquer outra coisa, e o seu programa não vai compilar; o compilador está te protegendo do null.