Referencias nulas
Si alguna vez has usado otro lenguaje de programación (C/C++, Python, Java, Ruby, Lisp, etc.), es probable que ya te hayas encontrado con null o nil.
El uso de null o nil es la forma en que estos lenguajes indican que una variable concreta no tiene valor.
Sin embargo, esto hace que usar por accidente una variable que apunta a null sea un error fácil (y frecuente) de cometer.
Como puedes imaginar, intentar llamar a una función que no está ahí, o acceder a un valor que no existe, puede provocar todo tipo de bugs y fallos.
El creador de null llegó a llamarlo su «error de mil millones de dólares».
El tipo Option
Para evitar estos problemas, Rust no usa referencias nulas.
Sin embargo, sigue necesitando una forma segura de indicar que una variable concreta no tiene valor.
Aquí es donde entra en juego Option.
En lugar de tener una variable a la que le falta un valor, las variables de Rust pueden usar la enumeración Option.
Esta enumeración tiene dos variantes: None, el equivalente de Rust a null; y Some(T), donde T es un valor de cualquier tipo.
Tiene este aspecto:
enum Option<T> {
None,
Some(T),
}
Puedes pensar en Option como una capa de seguridad entre tú y los problemas que pueden causar las referencias nulas, sin perder por ello su utilidad conceptual.
Cómo usar Option
Asignar None a una variable es bastante sencillo:
let nothing: Option<u32> = None; // Variable nothing is set to None
Sin embargo, si quieres que el tipo Option contenga un valor, no puedes asignar ese valor directamente.
Una variable de tipo Option y, por ejemplo, una variable de tipo i32 no son equivalentes.
Tendrás que 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>
También por este motivo no funcionará lo siguiente:
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
Si quieres obtener el valor que contiene Some, primero tendrás que comprobar que 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"
Además de match, Rust tiene otras herramientas para comprobar y acceder a los valores que contiene Option, pero a estas alturas match ya debería resultarte familiar.
Además, considera esto una demostración de por qué Rust usa Option en lugar de una referencia nula.
La cuestión es que tienes que comprobar si la variable Option es Some (en cuyo caso puedes extraer y usar el valor que contiene) o None.
En cualquier otro caso, tu programa no compilará; el compilador te protege de null.
Ejercicio de aprendizaje
