Nivel 1 · Fundamentos· Lección 7 de 10 · 25 min
Enums y coincidencia de patrones
Tipos que tienen una de varias formas, Option en lugar de null, y match como análisis exhaustivo de casos.
Los enums llevan datos
Un enum es un tipo cuyo valor es exactamente una de varias variantes. A diferencia de los enums de C, cada variante puede llevar sus propios datos.
#[derive(Debug)]
enum Shape {
Circle { radius: f64 },
Rectangle { width: f64, height: f64 },
Triangle(f64, f64, f64),
Point,
}
fn area(shape: &Shape) -> f64 {
match shape {
Shape::Circle { radius } => std::f64::consts::PI * radius * radius,
Shape::Rectangle { width, height } => width * height,
Shape::Triangle(a, b, c) => {
let s = (a + b + c) / 2.0;
(s * (s - a) * (s - b) * (s - c)).sqrt()
}
Shape::Point => 0.0,
}
}
fn main() {
let shapes = [
Shape::Circle { radius: 1.0 },
Shape::Rectangle { width: 2.0, height: 3.0 },
Shape::Triangle(3.0, 4.0, 5.0),
Shape::Point,
];
for s in &shapes {
println!("{s:?} has area {:.2}", area(s));
}
}
Los structs son «esto y esto y esto». Los enums son «esto o esto o esto». Juntos se llaman tipos de datos algebraicos, y modelar tu dominio con ellos —de modo que los estados inválidos sencillamente no se puedan construir— es el hábito de diseño más valioso en Rust.
match es exhaustivo
Añade una variante Square(f64) al Shape de arriba y ejecútalo. El compilador se niega hasta que area la trate. Cada match de tu programa que necesite actualizarse se convierte en un error de compilación que se señala a sí mismo. Precisamente por eso conviene evitar el comodín _ en tus propios enums.
Los patrones pueden hacer más que nombrar variantes:
fn classify(n: i32) -> &'static str {
match n {
0 => "zero",
1 | 2 | 3 => "small",
4..=99 => "medium",
x if x < 0 => "negative", // una guarda
_ => "large",
}
}
fn main() {
for n in [0, 2, 50, -7, 1000] {
println!("{n}: {}", classify(n));
}
let point = (0, -3);
match point {
(0, 0) => println!("origin"),
(x, 0) => println!("on the x axis at {x}"),
(0, y) => println!("on the y axis at {y}"),
(x, y) => println!("at ({x}, {y})"),
}
}
Option: no existe null
Tony Hoare llamó a las referencias nulas su «error de los mil millones de dólares»: cualquier referencia podría ser en secreto nada, y el sistema de tipos no dice cuál. Rust no tiene null. Un valor que puede faltar tiene un tipo distinto:
enum Option<T> {
Some(T),
None,
}
Option<T> y sus variantes están siempre en ámbito. Un Option<i32> no es un i32: no puedes sumarle nada ni imprimirlo como número hasta haber tratado el caso None.
fn divide(a: i32, b: i32) -> Option<i32> {
if b == 0 { None } else { Some(a / b) }
}
fn main() {
match divide(10, 2) {
Some(q) => println!("quotient {q}"),
None => println!("cannot divide by zero"),
}
// Métodos útiles para no necesitar siempre un match:
println!("{}", divide(1, 0).unwrap_or(0));
println!("{:?}", divide(9, 3).map(|q| q * 100));
println!("{}", divide(1, 0).is_none());
}
unwrap() extrae el valor o entra en pánico si es None. Es aceptable en ejemplos y pruebas, o donde None es realmente imposible; en código real prefiere match, unwrap_or, ? (próximas lecciones) o expect("por qué esto no puede fallar").
if let, let else y while let
Cuando solo importa un patrón:
fn parse_port(s: &str) -> u16 {
// let-else: enlaza si tiene éxito, o sale (return/break/panic) si falla.
let Ok(port) = s.parse::<u16>() else {
return 8080;
};
port
}
fn main() {
let favourite: Option<&str> = Some("teal");
if let Some(colour) = favourite {
println!("favourite colour: {colour}");
} else {
println!("no favourite");
}
println!("{} {}", parse_port("3000"), parse_port("not a number"));
let mut stack = vec![1, 2, 3];
while let Some(top) = stack.pop() {
println!("popped {top}");
}
}
Los enums también tienen métodos
#[derive(Debug, Clone, Copy, PartialEq)]
enum Light {
Red,
Green,
Amber,
}
impl Light {
fn next(self) -> Light {
match self {
Light::Red => Light::Green,
Light::Green => Light::Amber,
Light::Amber => Light::Red,
}
}
}
fn main() {
let mut light = Light::Red;
for _ in 0..4 {
print!("{light:?} → ");
light = light.next();
}
println!("{light:?}");
}
Ejercicios
- Define
enum Coin { Penny, Nickel, Dime, Quarter }yfn cents(c: Coin) -> u32. - Escribe
fn first_even(xs: &[i32]) -> Option<i32>. - Modela una orden de un editor de texto:
Insert(char),Delete,MoveTo { line: usize, col: usize },Quit. Escribefn describe(c: &Command) -> String.
Solución del 2
fn first_even(xs: &[i32]) -> Option<i32> {
for &x in xs {
if x % 2 == 0 {
return Some(x);
}
}
None
}
fn main() {
println!("{:?} {:?}", first_even(&[1, 3, 4, 6]), first_even(&[1, 3]));
}
Más adelante lo escribirás como xs.iter().copied().find(|x| x % 2 == 0).
Comprueba lo que has entendido
Elige una respuesta para ver la explicación.
1.¿Cómo representa Rust un valor que puede faltar?
2.¿Qué ocurre si un
matchsobre un enum omite una variante y no tiene un brazo comodín?3.¿Cuándo es preferible
if letamatch?