Juego de rol

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 en particular 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 cierres inesperados. El creador de null llegó incluso a llamarlo su 'error de mil millones de dólares'.

El tipo Option

Para evitar estos problemas, Rust no usa referencias nulas. Sin embargo, aún necesita una forma segura de indicar que una variable en particular no tiene valor. Aquí es donde entra Option. En lugar de tener una variable que carece de valor, las variables de Rust pueden usar el enum Option. Este enum tiene dos variantes: None, el equivalente a null en Rust; y Some(T), donde T es un valor de cualquier tipo.

Se ve así:

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. Necesitarás 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>

Es también por esta razón que lo siguiente no 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

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 disponibles para comprobar y acceder a los valores contenidos en 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. El punto es que tú debes comprobar si la variable Option es Some (y en ese caso puedes extraer y usar el valor que contiene) o None. Cualquier otra cosa, y tu programa no compilará; el compilador te mantiene a salvo de null.