Referências nulas
Se já alguma vez usaste outra linguagem de programação (C/C++, Python, Java, Ruby, Lisp, etc.), é provável que já tenhas encontrado null ou nil.
É através de null ou nil que essas linguagens indicam que uma determinada variável não tem valor.
No entanto, isso torna o uso acidental de uma variável que aponta para null um erro fácil (e frequente) de cometer.
Como podes imaginar, tentar chamar uma função que não existe, ou aceder a um valor que não existe, pode dar origem a todo o tipo de bugs e falhas.
O criador do null chegou ao ponto de o chamar o seu 'erro de mil milhões de dólares'.
O tipo Option
Para evitar estes problemas, o Rust não usa referências nulas.
No entanto, continua a precisar de uma forma segura de indicar que uma determinada variável não tem valor.
É aqui que entra o Option.
Em vez de teres uma variável sem valor, as variáveis do Rust podem usar o enum Option.
Este enum tem duas variantes: None, o equivalente a null no Rust; e Some(T), em que T é um valor de qualquer tipo.
Tem este aspeto:
enum Option<T> {
None,
Some(T),
}
Podes pensar no Option como uma camada de segurança entre ti e os problemas que as referências nulas podem causar, mantendo ainda assim a sua utilidade conceptual.
Usar Option
Definir uma variável como None é bastante simples:
let nothing: Option<u32> = None; // Variable nothing is set to None
No entanto, se quiseres que o tipo Option transporte um valor, não podes atribuir esse valor diretamente.
Uma variável do tipo Option e, digamos, uma variável do tipo i32 não são equivalentes.
Vais precisar de 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 esta razão que o seguinte não funciona:
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 quiseres obter o valor contido em Some, primeiro tens de verificar que 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, o Rust tem outras ferramentas para verificar e aceder aos valores contidos no Option, mas o match já te deve ser familiar a esta altura.
Além disso, encara isto como uma demonstração da razão pela qual o Rust usa Option em vez de uma referência nula.
O ponto principal é que tens mesmo de verificar se a variável Option é Some (caso em que podes avançar, extrair e usar o valor que está lá dentro) ou None.
Qualquer outra coisa, e o teu programa não compila; o compilador está a proteger-te do null.
Exercício de aprendizagem
