🦀 Curso de Rust — Nivel 4: Manejo de errores y código seguro

Objetivo: que tus estudiantes escriban programas que no se caigan por sorpresa: que cada cosa que pueda fallar o faltar esté visible en el tipo, que sepan elegir entre devolver un error o hacer panic!, y que puedan diseñar sus propios errores de forma clara.

Requisitos: Niveles 1 a 3 (en particular match, enums, structs, traits básicos, ownership y referencias).

Idea central del nivel: En Rust, el fallo y la ausencia no son sorpresas invisibles: son valores que viajan en el tipo de retorno, y el compilador te obliga a decidir qué hacer con ellos.

Índice

1. Filosofía: los errores como valores
2. Option<T>: un valor puede existir o no
3. Result<T, E>: una operación puede fallar
4. Pattern matching, if let, let else y while let
5. El operador ?
6. panic! y cuándo evitarlo
7. unwrap() y expect() con criterio
8. Propagación de errores y errores personalizados
9. Código seguro: diseñar para que el error sea explícito o imposible
10. Proyecto integrador: conciliación segura de facturas
11. Ejercicios con soluciones
12. Hoja de referencia rápida
13. Errores frecuentes del compilador
14. Plan de clases sugerido

Leyenda:

• ✅ = se puede / es correcto
• ❌ = NO se puede / no compila
• ⚠️ = compila, pero cuidado (puede fallar al ejecutar o es mala práctica)

Nota sobre el orden: el temario menciona Some/None/Ok/Err como un punto aparte; aquí van dentro de los módulos de Option y Result. Además, pattern matching va antes del operador ?, porque es la herramienta básica para “abrir” estos valores.

Nota sobre el alcance: en este nivel no usamos closures (funciones anónimas |x| ...), que se ven más adelante. Por eso no aparecen métodos como map, and_then o unwrap_or_else; los mencionamos solo como “lo que viene”.

Módulo 1: Filosofía: los errores como valores

1.1 ¿Cómo fallan los programas en otros lenguajes?

1.2 La respuesta de Rust

Rust no tiene null ni excepciones. En su lugar:

Los dos primeros son recuperables (el programa puede continuar); el tercero es irrecuperable (el programa se detiene).

1.3 El compilador te obliga a decidir

fn main() {
    // ❌ E0308: mismatched types — parse() NO devuelve un i32, devuelve un Result
    // let n: i32 = "42".parse::<i32>();

    // ✅ Tienes que "abrir" el Result: decidir qué hacer si falla
    let n: i32 = "42".parse::<i32>().unwrap_or(0);
    println!("{n}");
}

Frase para clase: “En Rust, la firma de la función dice la verdad: si puede fallar, el tipo lo dice, y no puedes usar el valor hasta haber manejado esa posibilidad.”

1.4 Comparación

Python:   def parsear(t): return int(t)        → puede lanzar ValueError (no se ve en la firma)
Rust:     fn parsear(t: &str) -> Result<i32, ParseIntError>   → el fallo está en el tipo

Módulo 2: Option<T>: un valor puede existir o no

2.1 Definición

Option es un enum de la librería estándar (ya disponible sin importar nada):

enum Option<T> {
    Some(T),     // hay un valor de tipo T
    None,        // no hay valor
}

• Some(valor) → existe un valor.
• None → no existe.
• T es un genérico (Nivel 2): Option<i32>, Option<String>, Option<&str>…

fn main() {
    let a: Option<i32> = Some(5);
    let b: Option<i32> = None;
    let c = Some("hola");              // Option<&str> inferido
    let d: Option<String> = None;      // con None hay que indicar el tipo

    // let e = None;                   // ❌ E0282: type annotations needed (¿Option de qué?)

    println!("{:?} {:?} {:?} {:?}", a, b, c, d);   // Some(5) None Some("hola") None
}

2.2 Crear funciones que devuelven Option

fn dividir(a: i32, b: i32) -> Option<i32> {
    if b == 0 {
        None                 // no hay resultado válido
    } else {
        Some(a / b)
    }
}

fn buscar_usuario(id: u32) -> Option<&'static str> {
    match id {
        1 => Some("Ana"),
        2 => Some("Luis"),
        _ => None,
    }
}

fn main() {
    println!("{:?}", dividir(10, 2));        // Some(5)
    println!("{:?}", dividir(10, 0));        // None
    println!("{:?}", buscar_usuario(2));     // Some("Luis")
    println!("{:?}", buscar_usuario(99));    // None
}

Cuándo usar Option: cuando la ausencia es normal y esperable, y no necesitas explicar por qué falta (buscar en una lista, campo opcional, primer elemento de algo que puede estar vacío).

2.3 Funciones de la librería estándar que devuelven Option

Ya las usaste en niveles anteriores. Ahora sabemos qué significan:

use std::collections::HashMap;

fn main() {
    let v = vec![10, 20, 30];
    println!("{:?}", v.get(1));                  // Some(20)
    println!("{:?}", v.get(9));                  // None
    println!("{:?}", v.first());                 // Some(10)
    println!("{:?}", v.last());                  // Some(30)
    println!("{:?}", v.iter().max());            // Some(30)

    let mut pila = vec![1, 2];
    println!("{:?}", pila.pop());                // Some(2)

    println!("{:?}", "hola".find('l'));          // Some(2)   posición del carácter
    println!("{:?}", "hola".find('z'));          // None
    println!("{:?}", "clave=valor".split_once('='));   // Some(("clave", "valor"))
    println!("{:?}", "sin igual".split_once('='));     // None
    println!("{:?}", "prefijo_dato".strip_prefix("prefijo_"));   // Some("dato")

    println!("{:?}", "hola".chars().next());     // Some('h')
    println!("{:?}", "".chars().next());         // None
    println!("{:?}", '7'.to_digit(10));          // Some(7)
    println!("{:?}", 'x'.to_digit(10));          // None

    println!("{:?}", 10_i32.checked_div(0));     // None  (división segura)
    println!("{:?}", 250_u8.checked_add(10));    // None  (se desbordaría)

    let mut mapa = HashMap::new();
    mapa.insert("a", 1);
    println!("{:?}", mapa.get("a"));             // Some(1)
    println!("{:?}", mapa.get("b"));             // None
}

2.4 “Abrir” un Option: obtener el valor de adentro

No puedes usar un Option<i32> como si fuera un i32. Debes decidir qué hacer en ambos casos. Herramientas:

a) match (exhaustivo)

fn main() {
    let numero: Option<i32> = Some(7);

    match numero {
        Some(n) => println!("El número es {n}"),
        None => println!("No hay número"),
    }

    // Como expresión:
    let texto = match numero {
        Some(n) if n > 5 => "grande",
        Some(_) => "pequeño",
        None => "ninguno",
    };
    println!("{texto}");
}

b) if let: cuando solo te interesa el caso Some

fn main() {
    let numero: Option<i32> = Some(7);

    if let Some(n) = numero {
        println!("El número es {n}");
    }

    if let Some(n) = numero {
        println!("{n}");
    } else {
        println!("No hay número");
    }
}

c) let else: “o me salgo” (ideal al inicio de funciones)

fn describir_primero(v: &[i32]) -> String {
    let Some(primero) = v.first() else {
        return String::from("lista vacía");       // el bloque else DEBE salir (return, panic, continue...)
    };
    format!("el primero es {primero}")
}

fn main() {
    println!("{}", describir_primero(&[5, 6]));    // el primero es 5
    println!("{}", describir_primero(&[]));        // lista vacía
}

d) Valores por defecto: unwrap_or y unwrap_or_default

fn main() {
    let a: Option<i32> = Some(3);
    let b: Option<i32> = None;

    println!("{}", a.unwrap_or(0));          // 3
    println!("{}", b.unwrap_or(0));          // 0
    println!("{}", b.unwrap_or(-1));         // -1

    let nombre: Option<String> = None;
    println!("[{}]", nombre.unwrap_or_default());    // []  (String vacío: el valor por defecto de String)
    let n: Option<i32> = None;
    println!("{}", n.unwrap_or_default());           // 0   (valor por defecto de i32)
}

e) Consultas: is_some() e is_none()

fn main() {
    let a = Some(5);
    println!("{} {}", a.is_some(), a.is_none());     // true false
}

f) unwrap() y expect(): extraer o hacer panic (Módulo 7)

fn main() {
    let a = Some(5);
    println!("{}", a.unwrap());          // 5
    // let b: Option<i32> = None;
    // b.unwrap();                      // ⚠️ panic: called `Option::unwrap()` on a `None` value
}

g) Combinar dos Option: or

fn main() {
    let a: Option<i32> = None;
    let b: Option<i32> = Some(9);
    println!("{:?}", a.or(b));           // Some(9)   (si a tiene valor, devuelve a; si no, b)
    println!("{:?}", Some(1).or(b));     // Some(1)
}

2.5 Lo que NO se puede hacer con un Option

fn main() {
    let a: Option<i32> = Some(5);

    // let s = a + 1;                 // ❌ E0369: cannot add `{integer}` to `Option<i32>`
    // if a == 5 { }                  // ❌ E0308: mismatched types (Option<i32> vs entero)
    // println!("{}", a);             // ❌ E0277: `Option<i32>` no implementa Display (usa {:?})
    // let l = Some("hola").len();    // ❌ E0599: no existe `len` en Option (está en el &str de adentro)
    // let x: i32 = a;                // ❌ E0308

    println!("{}", a == Some(5));     // ✅ Option se compara con Option
    println!("{:?}", a);              // ✅ Debug sí funciona
}

Ventaja: el compilador te impide “olvidar” que el valor podía faltar. En otros lenguajes, esa omisión es un error en ejecución.

2.6 Option y propiedad (ownership)

Al “abrir” un Option<String> con match o if let, el String se mueve fuera:

fn main() {
    let apodo: Option<String> = Some(String::from("Ani"));

    // ❌ E0382: el String se movió dentro de `a`; apodo quedó parcialmente movido
    // if let Some(a) = apodo { println!("{a}"); }
    // println!("{:?}", apodo);

    // ✅ Opción 1: abrir una REFERENCIA al Option
    if let Some(a) = &apodo {
        println!("{a}");                       // a es &String
    }

    // ✅ Opción 2: as_ref() convierte &Option<T> en Option<&T>
    if let Some(a) = apodo.as_ref() {
        println!("{a}");
    }

    println!("{:?}", apodo);                   // ✅ apodo sigue siendo nuestro
}

De Option<&T> a Option<T>: copied() y cloned()

fn main() {
    let v = vec![1, 2, 3];
    let referencia: Option<&i32> = v.first();       // Some(&1)
    let valor: Option<i32> = v.first().copied();    // Some(1)   (para tipos Copy)

    let nombres = vec![String::from("Ana")];
    let propio: Option<String> = nombres.first().cloned();   // Some("Ana") (con clone)

    println!("{:?} {:?} {:?}", referencia, valor, propio);
}

Modificar el contenido: &mut

fn main() {
    let mut contador: Option<u32> = Some(1);

    if let Some(c) = &mut contador {
        *c += 1;
    }
    println!("{:?}", contador);                     // Some(2)
}

take(): sacar el valor y dejar None

fn main() {
    let mut turno: Option<String> = Some(String::from("Ana"));

    let anterior = turno.take();                    // se lleva el valor y deja None
    println!("{:?} {:?}", anterior, turno);         // Some("Ana") None
}

2.7 Option en structs: campos opcionales

#[derive(Debug)]
struct Perfil {
    nombre: String,
    apodo: Option<String>,       // puede no tener apodo
    edad: Option<u8>,            // puede no declarar su edad
}

impl Perfil {
    fn nombre_para_mostrar(&self) -> &str {
        match &self.apodo {
            Some(a) => a.as_str(),
            None => self.nombre.as_str(),
        }
    }
}

fn main() {
    let p1 = Perfil { nombre: String::from("Ana"), apodo: Some(String::from("Ani")), edad: None };
    let p2 = Perfil { nombre: String::from("Luis"), apodo: None, edad: Some(30) };

    println!("{} / {}", p1.nombre_para_mostrar(), p2.nombre_para_mostrar());   // Ani / Luis
    println!("{:?}", p2.edad);
}

2.8 Option vs. valores “centinela”

Otros lenguajes usan valores especiales para “no hay dato”: -1, 0, "", "N/A". Es una trampa, porque nada te obliga a revisarlos:

// ❌ Diseño frágil: ¿-1 significa "no encontrado" o es un índice válido en otro contexto?
fn buscar_malo(v: &[i32], objetivo: i32) -> i32 {
    for (i, x) in v.iter().enumerate() {
        if *x == objetivo {
            return i as i32;
        }
    }
    -1
}

// ✅ El tipo dice la verdad
fn buscar(v: &[i32], objetivo: i32) -> Option<usize> {
    for (i, x) in v.iter().enumerate() {
        if *x == objetivo {
            return Some(i);
        }
    }
    None
}

fn main() {
    let datos = [4, 8, 15];
    let idx = buscar_malo(&datos, 99);
    println!("{}", datos[(idx + 1) as usize]);      // ⚠️ se usó -1 "sin revisar" y salió un dato falso (4)

    match buscar(&datos, 99) {                      // ✅ aquí es imposible ignorar el None
        Some(i) => println!("en {i}"),
        None => println!("no está"),
    }
}

2.9 Aritmética segura con Option

Los métodos checked_* devuelven None si la operación se desbordaría o es inválida:

fn main() {
    let a: u32 = 5;
    let b: u32 = 10;

    println!("{:?}", a.checked_sub(b));        // None  (5 - 10 en u32 sería negativo)
    println!("{:?}", b.checked_sub(a));        // Some(5)
    println!("{:?}", a.checked_add(b));        // Some(15)
    println!("{:?}", u32::MAX.checked_add(1)); // None
    println!("{:?}", a.checked_mul(b));        // Some(50)
    println!("{:?}", 7_i32.checked_div(0));    // None
}

2.10 Resumen del módulo

Módulo 3: Result<T, E>: una operación puede fallar

3.1 Definición

Result es otro enum de la librería estándar, con dos tipos genéricos:

enum Result<T, E> {
    Ok(T),       // éxito, con el valor de tipo T
    Err(E),      // fallo, con el error de tipo E
}

• Ok(valor) → la operación salió bien.
• Err(error) → falló, y el error explica por qué.

Option vs Result:

3.2 Crear funciones que devuelven Result

fn dividir(a: f64, b: f64) -> Result<f64, String> {
    if b == 0.0 {
        Err(String::from("no se puede dividir entre cero"))
    } else {
        Ok(a / b)
    }
}

fn validar_edad(edad: i32) -> Result<u8, String> {
    if edad < 0 {
        Err(format!("la edad no puede ser negativa ({edad})"))
    } else if edad > 120 {
        Err(format!("la edad {edad} es demasiado alta"))
    } else {
        Ok(edad as u8)
    }
}

fn main() {
    println!("{:?}", dividir(10.0, 4.0));     // Ok(2.5)
    println!("{:?}", dividir(1.0, 0.0));      // Err("no se puede dividir entre cero")
    println!("{:?}", validar_edad(30));       // Ok(30)
    println!("{:?}", validar_edad(-5));       // Err("la edad no puede ser negativa (-5)")
}

Regla de oro: el último valor de la función debe estar envuelto: Ok(...) si salió bien, Err(...) si no. Olvidar el Ok(...) es el error más común:

// ❌ E0308: expected `Result<i32, String>`, found `i32`
// fn doble(n: i32) -> Result<i32, String> {
//     n * 2
// }

fn doble(n: i32) -> Result<i32, String> {
    Ok(n * 2)                                 // ✅
}

fn main() {
    println!("{:?}", doble(4));
}

3.3 Errores de la librería estándar

Muchas funciones que ya usaste devuelven Result:

fn main() {
    println!("{:?}", "42".parse::<i32>());        // Ok(42)
    println!("{:?}", "abc".parse::<i32>());       // Err(ParseIntError { kind: InvalidDigit })
    println!("{:?}", "3.14".parse::<f64>());      // Ok(3.14)
    println!("{:?}", "x".parse::<f64>());         // Err(ParseFloatError { kind: Invalid })
    println!("{:?}", "true".parse::<bool>());     // Ok(true)
    println!("{:?}", "a".parse::<char>());        // Ok('a')
    println!("{:?}", u8::try_from(300_i32));      // Err(TryFromIntError(()))
}

3.4 “Abrir” un Result

a) match

fn main() {
    let entrada = "42";

    match entrada.parse::<i32>() {
        Ok(n) => println!("Número válido: {n}"),
        Err(e) => println!("Error al convertir '{entrada}': {e}"),
    }
    // Para "abc" imprimiría: Error al convertir 'abc': invalid digit found in string
}

Los errores implementan Display, así que {e} muestra un mensaje legible; con {e:?} ves la versión técnica (Debug).

b) if let

fn main() {
    if let Ok(n) = "42".parse::<i32>() {
        println!("Es {n}");
    }

    if let Err(e) = "abc".parse::<i32>() {
        println!("Falló: {e}");
    }
}

c) Valores por defecto

fn main() {
    let a = "12x".parse::<i32>().unwrap_or(0);          // 0
    let b = "12x".parse::<i32>().unwrap_or(-1);         // -1
    let c = "12x".parse::<i32>().unwrap_or_default();   // 0
    println!("{a} {b} {c}");
}

⚠️ Usar un valor por defecto descarta el error en silencio. Está bien cuando de verdad da lo mismo (un valor opcional de configuración); es peligroso cuando el error importa (dinero, datos de usuario).

d) Consultas y conversión a Option

fn main() {
    let r: Result<i32, _> = "12".parse::<i32>();
    println!("{} {}", r.is_ok(), r.is_err());          // true false

    let valor: Option<i32> = "12".parse::<i32>().ok();    // Ok(12) → Some(12)
    let falla: Option<i32> = "zz".parse::<i32>().ok();    // Err(_) → None  (se pierde el motivo)
    let motivo = "zz".parse::<i32>().err();               // Some(ParseIntError)
    println!("{:?} {:?} {}", valor, falla, motivo.is_some());
}

3.5 Distinguir qué error ocurrió

El error es un valor: puedes inspeccionarlo con match.

use std::num::IntErrorKind;

fn explicar(texto: &str) {
    match texto.parse::<u8>() {
        Ok(n) => println!("'{texto}' → {n}"),
        Err(e) => match e.kind() {
            IntErrorKind::Empty => println!("'{texto}': está vacío"),
            IntErrorKind::InvalidDigit => println!("'{texto}': tiene caracteres no numéricos"),
            IntErrorKind::PosOverflow => println!("'{texto}': es demasiado grande para u8"),
            _ => println!("'{texto}': otro problema ({e})"),
        },
    }
}

fn main() {
    explicar("42");
    explicar("");
    explicar("4x");
    explicar("300");
    explicar("-1");
}

Salida:

'42' → 42
'': está vacío
'4x': tiene caracteres no numéricos
'300': es demasiado grande para u8
'-1': tiene caracteres no numéricos

(El _ final es obligatorio: IntErrorKind puede ganar variantes en el futuro.)

⚠️ parse no ignora espacios: " 42".parse::<i32>() falla. Usa .trim() antes.

3.6 Errores de entrada/salida (std::io::Error)

Leer un archivo puede fallar por muchas razones (no existe, sin permisos…). El tipo de error permite distinguirlas:

use std::fs;
use std::io::ErrorKind;

fn main() {
    match fs::read_to_string("no_existe.txt") {
        Ok(contenido) => println!("{} bytes leídos", contenido.len()),
        Err(e) if e.kind() == ErrorKind::NotFound => println!("el archivo no existe"),
        Err(e) => println!("otro error de E/S: {e}"),
    }
}

Leer una línea del teclado también devuelve Result:

use std::io;

fn main() {
    println!("Escribe tu edad:");
    let mut entrada = String::new();

    match io::stdin().read_line(&mut entrada) {
        Ok(_) => match entrada.trim().parse::<u8>() {
            Ok(edad) => println!("Tienes {edad} años"),
            Err(_) => println!("Eso no es una edad válida"),
        },
        Err(e) => println!("No pude leer la entrada: {e}"),
    }
}

3.7 Result no se puede ignorar sin que Rust avise

Result está marcado como #[must_use]: si lo descartas, el compilador emite una advertencia.

fn main() {
    // "abc".parse::<i32>();            // ⚠️ warning: unused `Result` that must be used
    let _ = "abc".parse::<i32>();       // ✅ ignorar A PROPÓSITO (se nota en el código)
}

3.8 Result<(), E>: acciones que no devuelven nada útil

fn guardar_nombre(nombre: &str) -> Result<(), String> {
    if nombre.is_empty() {
        return Err(String::from("el nombre no puede estar vacío"));
    }
    println!("Guardado: {nombre}");
    Ok(())                              // éxito sin valor: `()`
}

fn main() {
    match guardar_nombre("Ana") {
        Ok(()) => println!("todo bien"),
        Err(e) => println!("error: {e}"),
    }
    if let Err(e) = guardar_nombre("") {
        println!("error: {e}");
    }
}

3.9 Convertir entre Option y Result

fn buscar(id: u32) -> Option<&'static str> {
    match id {
        1 => Some("Ana"),
        _ => None,
    }
}

fn main() {
    // Option → Result: ok_or(error)   (le das el error para el caso None)
    let r1: Result<&str, String> = buscar(1).ok_or(String::from("usuario no encontrado"));
    let r2: Result<&str, String> = buscar(9).ok_or(String::from("usuario no encontrado"));
    println!("{:?} {:?}", r1, r2);       // Ok("Ana") Err("usuario no encontrado")

    // Result → Option: ok()   (se descarta el motivo del error)
    let o: Option<i32> = "5".parse::<i32>().ok();
    println!("{:?}", o);                 // Some(5)
}

3.10 Recolectar resultados: estricto vs. tolerante

Con varios elementos, hay dos filosofías:

// ESTRICTO: se detiene en el primer error
fn parsear_todos_estricto(textos: &[&str]) -> Result<Vec<i32>, String> {
    let mut numeros = Vec::new();
    for t in textos {
        match t.trim().parse::<i32>() {
            Ok(n) => numeros.push(n),
            Err(_) => return Err(format!("'{t}' no es un número")),
        }
    }
    Ok(numeros)
}

// TOLERANTE: recoge lo bueno y lo malo por separado
fn parsear_todos_tolerante(textos: &[&str]) -> (Vec<i32>, Vec<String>) {
    let mut buenos = Vec::new();
    let mut malos = Vec::new();
    for t in textos {
        match t.trim().parse::<i32>() {
            Ok(n) => buenos.push(n),
            Err(_) => malos.push(format!("'{t}' no es un número")),
        }
    }
    (buenos, malos)
}

fn main() {
    let datos = ["1", "2", "x", "4"];
    println!("{:?}", parsear_todos_estricto(&datos));      // Err("'x' no es un número")
    println!("{:?}", parsear_todos_tolerante(&datos));     // ([1, 2, 4], ["'x' no es un número"])
}

Cuándo cada uno: estricto para datos que deben ser todos correctos (una transacción); tolerante para importaciones o lecturas donde conviene reportar los problemas y seguir.

3.11 Lo que NO se puede hacer con un Result

fn main() {
    let r: Result<i32, String> = Ok(5);

    // let s = r + 1;                    // ❌ E0369: no se suma un Result
    // let x: i32 = r;                   // ❌ E0308: mismatched types
    // println!("{}", r);                // ❌ E0277: Result no implementa Display
    // let l = "5".parse::<i32>().abs(); // ❌ E0599: `abs` no existe en Result

    println!("{:?}", r);                 // ✅ con {:?}
}

3.12 Resumen del módulo

Módulo 4: Pattern matching, if let, let else y while let

El pattern matching (coincidencia de patrones) es la herramienta con la que “desarmas” valores como Option, Result, enums, structs, tuplas y slices. Ya usaste match; aquí ves todas sus formas.

4.1 Refutable vs. irrefutable

• Un patrón irrefutable siempre coincide (let (a, b) = (1, 2);).
• Un patrón refutable puede no coincidir (Some(x), Ok(n), 3).

fn main() {
    let (a, b) = (1, 2);                  // ✅ irrefutable: siempre coincide
    println!("{a} {b}");

    let opcion = Some(5);
    // let Some(x) = opcion;              // ❌ E0005: refutable pattern in local binding
    //                                    //   (¿y si fuera None?)
    let Some(x) = opcion else { return; };    // ✅ let else: define qué pasa si NO coincide
    println!("{x}");
}

4.2 Catálogo de patrones

fn main() {
    let n = 7;

    // 1) Literales, múltiples valores y rangos
    match n {
        0 => println!("cero"),
        1 | 2 | 3 => println!("pequeño"),
        4..=9 => println!("un dígito"),
        _ => println!("grande"),
    }

    // 2) Guardas (if dentro de la rama)
    match n {
        x if x % 2 == 0 => println!("{x} es par"),
        x => println!("{x} es impar"),
    }

    // 3) Capturar con @ (comprobar un rango Y guardar el valor)
    match n {
        edad @ 0..=17 => println!("menor: {edad}"),
        edad @ 18..=64 => println!("adulto: {edad}"),
        edad => println!("mayor: {edad}"),
    }

    // 4) Tuplas
    let par = (3, -3);
    match par {
        (0, 0) => println!("origen"),
        (x, 0) | (0, x) => println!("sobre un eje: {x}"),
        (x, y) if x == -y => println!("opuestos"),
        _ => println!("otro"),
    }
}

4.3 Desestructurar structs y enums

#[derive(Debug)]
struct Punto {
    x: i32,
    y: i32,
}

enum Figura {
    Circulo { centro: Punto, radio: u32 },
    Rectangulo(Punto, Punto),
    Vacia,
}

fn describir(f: &Figura) -> String {
    match f {
        Figura::Circulo { centro: Punto { x: 0, y: 0 }, radio } => {
            format!("círculo en el origen, radio {radio}")
        }
        Figura::Circulo { centro, radio } => {
            format!("círculo en ({}, {}), radio {radio}", centro.x, centro.y)
        }
        Figura::Rectangulo(a, b) => format!("rectángulo de {:?} a {:?}", a, b),
        Figura::Vacia => String::from("figura vacía"),
    }
}

fn main() {
    let c = Figura::Circulo { centro: Punto { x: 0, y: 0 }, radio: 5 };
    let r = Figura::Rectangulo(Punto { x: 1, y: 1 }, Punto { x: 4, y: 3 });
    println!("{}", describir(&c));
    println!("{}", describir(&r));
    println!("{}", describir(&Figura::Vacia));

    // Desestructurar un struct en un let (irrefutable):
    let Punto { x, y } = Punto { x: 7, y: 9 };
    println!("{x} {y}");
}

4.4 Patrones anidados: Option y Result combinados

fn clasificar(r: Result<Option<i32>, String>) -> String {
    match r {
        Ok(Some(n)) if n < 0 => format!("negativo: {n}"),
        Ok(Some(n)) => format!("valor: {n}"),
        Ok(None) => String::from("sin valor"),
        Err(e) => format!("error: {e}"),
    }
}

fn main() {
    println!("{}", clasificar(Ok(Some(-3))));         // negativo: -3
    println!("{}", clasificar(Ok(Some(8))));          // valor: 8
    println!("{}", clasificar(Ok(None)));             // sin valor
    println!("{}", clasificar(Err(String::from("x")))); // error: x
}

Combinando dos Option a la vez:

fn sumar_opcionales(a: Option<i32>, b: Option<i32>) -> i32 {
    match (a, b) {
        (Some(x), Some(y)) => x + y,
        (Some(x), None) | (None, Some(x)) => x,
        (None, None) => 0,
    }
}

fn main() {
    println!("{}", sumar_opcionales(Some(2), Some(3)));   // 5
    println!("{}", sumar_opcionales(None, Some(7)));      // 7
    println!("{}", sumar_opcionales(None, None));         // 0
}

4.5 Patrones sobre referencias y &

fn main() {
    let v = vec![5, 6, 7];

    // v.first() es Option<&i32>. Con `&x` en el patrón obtienes el i32 directamente:
    if let Some(&primero) = v.first() {
        println!("{}", primero + 1);                  // 6
    }

    // Al hacer match sobre una referencia, los bindings pasan a ser referencias:
    let opcion: Option<String> = Some(String::from("hola"));
    match &opcion {
        Some(texto) => println!("{texto} ({} letras)", texto.len()),   // texto: &String
        None => println!("nada"),
    }
    println!("{:?}", opcion);                         // ✅ no se movió nada
}

4.6 Patrones sobre slices (secuencias)

fn describir(v: &[i32]) -> String {
    match v {
        [] => String::from("vacía"),
        [x] => format!("un solo elemento: {x}"),
        [primero, .., ultimo] => format!("de {primero} a {ultimo}"),
    }
}

fn suma(v: &[i32]) -> i32 {
    match v {
        [] => 0,
        [cabeza, resto @ ..] => cabeza + suma(resto),    // `resto` es el slice con lo que queda
    }
}

fn main() {
    println!("{}", describir(&[]));                // vacía
    println!("{}", describir(&[7]));               // un solo elemento: 7
    println!("{}", describir(&[1, 2, 3, 4]));      // de 1 a 4
    println!("{}", suma(&[1, 2, 3, 4]));           // 10
}

Es una forma segura de acceder a los extremos de una lista: sin índices, sin panic.

4.7 if let y else if let

fn main() {
    let a: Option<i32> = None;
    let b: Result<i32, String> = Ok(3);

    if let Some(n) = a {
        println!("a = {n}");
    } else if let Ok(m) = b {
        println!("b = {m}");
    } else {
        println!("nada de nada");
    }
}

if let vs match

⚠️ if let no verifica exhaustividad: si luego agregas una variante nueva a un enum, un if let seguirá compilando sin avisarte, mientras que un match te marcaría el error. Para enums propios que van a crecer, prefiere match.

4.8 let else: el “guard clause” de Rust

Ideal para validar al inicio de una función y mantener el camino feliz sin anidar:

fn parsear_par(texto: &str) -> Option<(i32, i32)> {
    let Some((izq, der)) = texto.split_once(',') else {
        return None;
    };
    let Ok(a) = izq.trim().parse::<i32>() else {
        return None;
    };
    let Ok(b) = der.trim().parse::<i32>() else {
        return None;
    };
    Some((a, b))
}

fn main() {
    println!("{:?}", parsear_par("3, 4"));       // Some((3, 4))
    println!("{:?}", parsear_par("3-4"));        // None
    println!("{:?}", parsear_par("3, x"));       // None
}

Reglas del let else: el bloque else debe divergir (terminar con return, continue, break o panic!); las variables del patrón quedan disponibles después.

4.9 while let: repetir mientras haya valor

fn main() {
    let mut pila = vec![1, 2, 3];

    while let Some(tope) = pila.pop() {      // pop() devuelve None cuando se vacía
        println!("sacando {tope}");
    }
    println!("pila vacía: {}", pila.is_empty());
}

Salida: sacando 3, sacando 2, sacando 1, pila vacía: true.

4.10 matches!: “¿coincide con este patrón?” → bool

fn main() {
    let r: Result<i32, String> = Err(String::from("x"));

    println!("{}", matches!(r, Err(_)));                  // true
    println!("{}", matches!(Some(5), Some(n) if n > 3));  // true (admite guardas)
    println!("{}", matches!('k', 'a'..='z'));             // true
}

4.11 Exhaustividad: el compilador es tu red de seguridad

// ❌ E0004: non-exhaustive patterns: `None` not covered
// fn f(o: Option<i32>) -> i32 {
//     match o {
//         Some(n) => n,
//     }
// }

Es imposible olvidar el caso None o el caso Err. Esa es la garantía más importante de este nivel.

Módulo 5: El operador ?

5.1 El problema: demasiados match anidados

use std::num::ParseIntError;

fn sumar_textos(a: &str, b: &str) -> Result<i32, ParseIntError> {
    let x = match a.trim().parse::<i32>() {
        Ok(v) => v,
        Err(e) => return Err(e),
    };
    let y = match b.trim().parse::<i32>() {
        Ok(v) => v,
        Err(e) => return Err(e),
    };
    Ok(x + y)
}

Funciona, pero es repetitivo. El operador ? hace exactamente lo mismo en un carácter.

5.2 ? con Result

use std::num::ParseIntError;

fn sumar_textos(a: &str, b: &str) -> Result<i32, ParseIntError> {
    let x = a.trim().parse::<i32>()?;
    let y = b.trim().parse::<i32>()?;
    Ok(x + y)
}

fn main() {
    println!("{:?}", sumar_textos("2", "3"));        // Ok(5)
    println!("{:?}", sumar_textos("2", "tres"));     // Err(ParseIntError { kind: InvalidDigit })
}

Qué hace expresión?:

• Si es Ok(valor) → extrae valor y la ejecución sigue.
• Si es Err(e) → sale de la función inmediatamente devolviendo Err(e) (convirtiéndolo con From si hace falta, ver 5.6).

Equivale a:

let x = match a.trim().parse::<i32>() {
    Ok(valor) => valor,
    Err(e) => return Err(From::from(e)),
};

5.3 Encadenar con ?

use std::num::ParseIntError;

fn promedio_de_tres(a: &str, b: &str, c: &str) -> Result<f64, ParseIntError> {
    let x: i32 = a.trim().parse()?;
    let y: i32 = b.trim().parse()?;
    let z: i32 = c.trim().parse()?;
    Ok((x + y + z) as f64 / 3.0)
}

fn main() {
    println!("{:?}", promedio_de_tres("3", "6", "9"));       // Ok(6.0)
    println!("{:?}", promedio_de_tres("3", "?", "9"));       // Err(...) en la segunda
}

Si cualquier paso falla, la función termina ahí y entrega ese error a quien la llamó: eso es propagar el error.

5.4 ? con Option

En una función que devuelve Option, ? sale con None si encuentra None:

fn inicial_y_final(texto: &str) -> Option<(char, char)> {
    let inicial = texto.chars().next()?;      // si el texto está vacío → return None
    let final_ = texto.chars().last()?;
    Some((inicial, final_))
}

fn primera_palabra_mayuscula(texto: &str) -> Option<String> {
    let palabra = texto.split_whitespace().next()?;
    Some(palabra.to_uppercase())
}

fn main() {
    println!("{:?}", inicial_y_final("rust"));            // Some(('r', 't'))
    println!("{:?}", inicial_y_final(""));                // None
    println!("{:?}", primera_palabra_mayuscula("hola mundo"));   // Some("HOLA")
    println!("{:?}", primera_palabra_mayuscula("   "));          // None
}

5.5 Dónde SÍ y dónde NO se puede usar ?

// ❌ E0277: the `?` operator can only be used in a function that returns `Result` or `Option`
// fn main() {
//     let n: i32 = "5".parse()?;
// }

// ✅ main puede devolver Result:
use std::num::ParseIntError;

fn main() -> Result<(), ParseIntError> {
    let n: i32 = "42".parse()?;
    println!("{n}");

    let m: i32 = "x".parse()?;      // falla: main devuelve el Err
    println!("{m}");                // (no se llega aquí)

    Ok(())
}

Cuando main devuelve Err(e), el programa imprime Error: seguido del Debug del error y termina con código de salida 1. Para main, el tipo de error debe implementar Debug.

5.6 Mezclar Option y Result

? no mezcla los dos mundos automáticamente: hay que convertir.

// ❌ E0277: `?` aplicado a un Option dentro de una función que devuelve Result
// fn primera_letra(texto: &str) -> Result<char, String> {
//     let c = texto.chars().next()?;
//     Ok(c)
// }

// ✅ Option → Result con ok_or
fn primera_letra(texto: &str) -> Result<char, String> {
    let c = texto.chars().next().ok_or(String::from("el texto está vacío"))?;
    Ok(c)
}

// ✅ Result → Option con ok()
fn doble(texto: &str) -> Option<i32> {
    let n = texto.trim().parse::<i32>().ok()?;
    Some(n * 2)
}

fn main() {
    println!("{:?}", primera_letra("hola"));    // Ok('h')
    println!("{:?}", primera_letra(""));        // Err("el texto está vacío")
    println!("{:?}", doble("21"));              // Some(42)
    println!("{:?}", doble("x"));               // None
}

5.7 ? y la conversión de errores (From)

Cuando el error que produce la expresión no es del mismo tipo que el error que devuelve tu función, ? intenta convertirlo con el trait From. Si no existe esa conversión, no compila:

// ❌ E0277: `?` couldn't convert the error to `String`
//    (no existe From<ParseIntError> para String)
// fn leer(texto: &str) -> Result<i32, String> {
//     let n: i32 = texto.parse()?;
//     Ok(n)
// }

Soluciones: manejar con match (Módulo 3), o definir tu propio tipo de error con From (Módulo 8), que es la forma recomendada.

5.8 Errores frecuentes con ?

5.9 Resumen del módulo

1. ? = “si va bien, sigue; si va mal, sal de aquí y devuelve el error”.
2. Funciona con Result (en funciones que devuelven Result) y con Option (en funciones que devuelven Option).
3. Convierte el error con From si hace falta.
4. Es la forma estándar de propagar errores hacia quien sabe qué hacer con ellos.

Módulo 6: panic! y cuándo evitarlo

6.1 Qué es un panic

Un panic es un error irrecuperable: el programa se detiene (el hilo actual termina), imprime un mensaje y sale con código 101.

fn main() {
    println!("antes");
    panic!("algo salió muy mal: código {}", 42);
    // println!("después");        // ⚠️ nunca se ejecuta (el compilador avisa: unreachable)
}

Salida (por stderr):

antes
thread 'main' panicked at src/main.rs:3:5:
algo salió muy mal: código 42
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

• El mensaje indica archivo, línea y columna.
• RUST_BACKTRACE=1 cargo run muestra la pila de llamadas que llevó al fallo.

Los valores se liberan al “desenrollar”

Cuando hay un panic, Rust desenrolla la pila y ejecuta los drop de las variables vivas (lo que vimos en el Nivel 3):

struct Aviso(String);

impl Drop for Aviso {
    fn drop(&mut self) {
        println!("   [drop] liberando {}", self.0);
    }
}

fn main() {
    let _a = Aviso(String::from("A"));
    panic!("boom");
}
// Salida: el mensaje de panic y luego "[drop] liberando A"

6.2 ¿Qué provoca un panic?

6.3 Macros relacionadas

fn main() {
    let x = 5;

    // assert!: verifica una condición; si es falsa, panic (útil para invariantes)
    assert!(x > 0);
    assert!(x > 0, "x debe ser positivo, llegó {x}");

    // assert_eq! / assert_ne!: comparan y muestran ambos valores si fallan
    assert_eq!(x, 5);
    assert_ne!(x, 6);

    // debug_assert!: igual que assert!, pero SOLO en modo debug (no en release)
    debug_assert!(x < 1000);
}

// todo!() y unimplemented!(): marcan código pendiente y compilan
fn funcion_pendiente() -> i32 {
    todo!("falta implementar el cálculo")
}

// unreachable!(): "este camino no puede ocurrir" (si ocurre, hay un bug)
fn nombre_de_dia(n: u8) -> &'static str {
    match n {
        1 => "lunes",
        2 => "martes",
        3 => "miércoles",
        _ => unreachable!("n ya fue validado antes: {n}"),
    }
}

6.4 La pregunta clave: ¿Result o panic!?

Si el fallo puede ocurrir en un programa correcto → devuelve Result u Option. Si el fallo solo puede ocurrir por un bug del programador → panic! es aceptable.

✅ Cuándo panic! es razonable

1. Bugs: se violó una condición interna que “nunca debería pasar”. Continuar con datos corruptos sería peor.
2. Tests: un assert! que falla es la forma de reportar un fallo.
3. Prototipos y ejemplos: se simplifica el código; luego se reemplaza.
4. Estado imposible de recuperar (el programa no puede funcionar sin ese recurso y no hay alternativa razonable).

❌ Cuándo evitarlo

1. Cualquier dato que venga de fuera del programa: teclado, archivos, red, variables de entorno, argumentos.
2. Código de biblioteca (el que otros usan): quien llama debe decidir cómo reaccionar, no tú.
3. Operaciones que fallan “normalmente” (parseos, búsquedas, validaciones).
4. Programas de larga ejecución (servidores): un panic por una entrada mala tumba el servicio.

6.5 Panics ocultos y su alternativa segura

Muchos panics vienen de operaciones que parecen inocentes:

fn main() {
    let v = vec![10, 20, 30];
    let i = 7;

    // ⚠️ let x = v[i];                       // panic
    match v.get(i) {
        Some(x) => println!("{x}"),
        None => println!("posición {i} inexistente"),
    }

    let a: u32 = 5;
    let b: u32 = 10;
    // ⚠️ let r = a - b;                      // panic en debug (overflow)
    println!("{:?}", a.checked_sub(b));       // None
    println!("{}", a.saturating_sub(b));      // 0   (se queda en el mínimo)
    println!("{}", a.wrapping_sub(b));        // 4294967291 (da la vuelta)
}

6.6 Documentar los panics

Si una función puede hacer panic por contrato, dilo en su documentación con la sección # Panics:

/// Devuelve el elemento del medio.
///
/// # Panics
/// Hace panic si `datos` está vacío.
fn medio(datos: &[i32]) -> i32 {
    assert!(!datos.is_empty(), "medio() exige una lista no vacía");
    datos[datos.len() / 2]
}

// Versión sin panic:
fn medio_seguro(datos: &[i32]) -> Option<i32> {
    datos.get(datos.len() / 2).copied()
}

fn main() {
    println!("{}", medio(&[1, 2, 3]));
    println!("{:?}", medio_seguro(&[]));      // None
}

6.7 Probar que algo hace panic

fn dividir(a: i32, b: i32) -> i32 {
    a / b                                  // ⚠️ hace panic si b == 0
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    #[should_panic(expected = "divide by zero")]
    fn dividir_entre_cero_hace_panic() {
        dividir(10, 0);
    }
}

6.8 Otras opciones de configuración (solo referencia)

• Por defecto, un panic desenrolla la pila (limpia los valores).
• En Cargo.toml puedes pedir que aborte directamente (binario más pequeño, sin limpieza):

[profile.release]
panic = "abort"

6.9 Resumen del módulo

1. panic! = fallo irrecuperable: el programa se detiene.
2. Reserva el panic para bugs (violaciones de invariantes), tests y prototipos.
3. Para todo lo que pueda pasar con entradas reales: Result / Option.
4. Aprende los panics ocultos (v[i], /, unwrap, desbordamientos) y sus alternativas seguras.

Módulo 7: unwrap() y expect() con criterio

7.1 Qué hacen

Ambos extraen el valor de un Option o Result y, si no hay valor (o es Err), hacen panic!.

fn main() {
    let a: Option<i32> = Some(5);
    let b: Result<i32, String> = Ok(7);

    println!("{}", a.unwrap());                    // 5
    println!("{}", b.unwrap());                    // 7
    println!("{}", a.expect("a debería tener valor"));   // 5
}

fn main() {
    // let n: Option<i32> = None;
    // n.unwrap();                // panic: called `Option::unwrap()` on a `None` value
    // n.expect("falta el valor de n");     // panic: falta el valor de n

    // let r: Result<i32, _> = "x".parse::<i32>();
    // r.unwrap();                // panic: called `Result::unwrap()` on an `Err` value: ParseIntError { kind: InvalidDigit }
    // r.expect("no era número"); // panic: no era número: ParseIntError { kind: InvalidDigit }
}

expect es casi siempre mejor que unwrap: el mensaje deja pistas de qué suposición falló.

7.2 ¿Cuándo es aceptable usarlos?

✅ 1. En tests, ejemplos y prototipos

#[cfg(test)]
mod tests {
    #[test]
    fn parsea_bien() {
        let n: i32 = "42".parse().unwrap();
        assert_eq!(n, 42);
    }
}

✅ 2. Cuando el fallo es imposible por construcción (con expect que explique por qué)

fn main() {
    // Literal escrito por nosotros: es un número válido SIEMPRE
    let iva: f64 = "0.19".parse().expect("IVA es un literal numérico válido");

    // 5 siempre cabe en u32
    let n = u32::try_from(5_usize).expect("5 cabe en u32");

    println!("{iva} {n}");
}

✅ 3. Cuando una condición garantiza el valor y no hay mejor forma

Y aun así, normalmente hay una forma mejor (ver 7.4).

7.3 ¿Cuándo NO usarlos?

❌ Con datos externos (siempre pueden fallar)

use std::fs;
use std::io;

fn main() {
    let mut entrada = String::new();
    io::stdin().read_line(&mut entrada).unwrap();         // ❌ ¿y si falla la lectura?
    let n: i32 = entrada.trim().parse().unwrap();         // ❌ el usuario puede escribir "hola"
    let datos = fs::read_to_string("datos.txt").unwrap(); // ❌ el archivo puede no existir
    println!("{n} {datos}");
}

❌ En código de biblioteca, en servidores, o donde “se cae” no es opción

7.4 Las alternativas, en orden de preferencia

7.5 Refactorizar: de unwrap a código robusto

use std::num::ParseIntError;

// ❌ Versión frágil: un texto malo tumba todo el programa
fn suma_fragil(a: &str, b: &str) -> i32 {
    a.parse::<i32>().unwrap() + b.parse::<i32>().unwrap()
}

// ✅ Versión robusta: el error viaja hacia quien llama
fn suma_robusta(a: &str, b: &str) -> Result<i32, ParseIntError> {
    let x = a.trim().parse::<i32>()?;
    let y = b.trim().parse::<i32>()?;
    Ok(x + y)
}

fn main() {
    println!("{}", suma_fragil("2", "3"));                 // 5
    // println!("{}", suma_fragil("2", "x"));              // ⚠️ panic

    match suma_robusta("2", "x") {
        Ok(n) => println!("{n}"),
        Err(e) => println!("entrada inválida: {e}"),
    }
}

7.6 Antipatrones

fn main() {
    let v = vec![1, 2, 3];

    // ❌ Comprobar y luego unwrap (hace el trabajo dos veces y es frágil si cambia el código)
    if v.first().is_some() {
        println!("{}", v.first().unwrap());
    }
    // ✅ if let
    if let Some(primero) = v.first() {
        println!("{primero}");
    }

    // ❌ expect con mensaje inútil
    // let n: i32 = "x".parse().expect("");
    // ❌ expect que describe el síntoma, no la suposición
    // let n: i32 = "x".parse().expect("falló");
    // ✅ expect que explica la SUPOSICIÓN
    let n: i32 = "5".parse().expect("la constante '5' siempre es un entero válido");
    println!("{n}");
}

Estilo de los mensajes de expect: describe por qué crees que no puede fallar, no solo que falló.

7.7 Una nota sobre unwrap_or(...) y valores costosos

unwrap_or(valor) evalúa valor siempre, aunque no haga falta. Si calcular ese valor por defecto es costoso, existe unwrap_or_else, que usa una función y se aprende junto con los closures (siguiente nivel de la ruta).

7.8 Herramienta: Clippy puede vigilar

// Al inicio de main.rs, para recibir advertencias de `cargo clippy`:
#![warn(clippy::unwrap_used)]
#![warn(clippy::expect_used)]

Útil en proyectos donde quieres controlar que no queden unwrap olvidados.

7.9 Diagrama de decisión

Tengo un Option/Result y necesito el valor
          │
          ▼
¿Estoy en un test, ejemplo o prototipo?
   ├─ Sí → unwrap() / expect()
   └─ No
       ▼
¿El dato viene de fuera (usuario, archivo, red...)?
   ├─ Sí → NO unwrap. Usa  ?  /  match  /  if let  /  let else
   └─ No
       ▼
¿Puedo DEMOSTRAR que nunca falla?
   ├─ Sí → expect("por qué no puede fallar")
   └─ No → trátalo como "puede fallar": ?  /  match  /  unwrap_or

Módulo 8: Propagación de errores y errores personalizados

8.1 Del String al error propio: una escalera

8.2 Propagar: decidir dónde manejar el error

Principio: los niveles bajos propagan (?); el nivel alto (quien tiene contexto) decide qué hacer: mostrar un mensaje, reintentar, usar un valor por defecto, terminar.

use std::num::ParseIntError;

// Nivel bajo: solo parsea. No decide nada: propaga.
fn leer_numero(texto: &str) -> Result<i32, ParseIntError> {
    texto.trim().parse::<i32>()
}

// Nivel medio: usa leer_numero y propaga.
fn calcular_doble(texto: &str) -> Result<i32, ParseIntError> {
    let n = leer_numero(texto)?;
    Ok(n * 2)
}

// Nivel alto: aquí sí se decide qué hacer.
fn main() {
    for entrada in ["21", "abc"] {
        match calcular_doble(entrada) {
            Ok(r) => println!("El doble de '{entrada}' es {r}"),
            Err(e) => println!("No pude calcular con '{entrada}': {e}"),
        }
    }
}

8.3 Crear un error propio: el enum

use std::num::ParseIntError;

#[derive(Debug)]
enum ErrorConfig {
    Vacio,
    PuertoInvalido(ParseIntError),     // guarda el error original
    PuertoReservado(u16),              // guarda el valor problemático
}

Cada variante es un modo distinto de fallar, con los datos que ayudan a entender el problema.

8.4 Implementar Display: el mensaje para humanos

use std::fmt;

impl fmt::Display for ErrorConfig {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            ErrorConfig::Vacio => write!(f, "el puerto no puede estar vacío"),
            ErrorConfig::PuertoInvalido(e) => write!(f, "puerto inválido: {e}"),
            ErrorConfig::PuertoReservado(p) => write!(f, "el puerto {p} está reservado (< 1024)"),
        }
    }
}

Con esto, println!("{error}") imprime un mensaje claro. (Debug, con #[derive(Debug)], sigue sirviendo para depurar.)

8.5 Implementar Error: el “sello” de error

impl std::error::Error for ErrorConfig {}

Una línea vacía basta: exige que el tipo ya tenga Debug y Display. Convierte tu tipo en un error “oficial” que otras herramientas del ecosistema reconocen.

8.6 Implementar From: para que ? convierta solo

impl From<ParseIntError> for ErrorConfig {
    fn from(e: ParseIntError) -> Self {
        ErrorConfig::PuertoInvalido(e)
    }
}

Ahora, en una función que devuelve Result<_, ErrorConfig>, un ? sobre un Result<_, ParseIntError> se convierte automáticamente en ErrorConfig::PuertoInvalido(...).

8.7 Todo junto

use std::fmt;
use std::num::ParseIntError;

#[derive(Debug)]
enum ErrorConfig {
    Vacio,
    PuertoInvalido(ParseIntError),
    PuertoReservado(u16),
}

impl fmt::Display for ErrorConfig {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            ErrorConfig::Vacio => write!(f, "el puerto no puede estar vacío"),
            ErrorConfig::PuertoInvalido(e) => write!(f, "puerto inválido: {e}"),
            ErrorConfig::PuertoReservado(p) => write!(f, "el puerto {p} está reservado (< 1024)"),
        }
    }
}

impl std::error::Error for ErrorConfig {}

impl From<ParseIntError> for ErrorConfig {
    fn from(e: ParseIntError) -> Self {
        ErrorConfig::PuertoInvalido(e)
    }
}

fn leer_puerto(texto: &str) -> Result<u16, ErrorConfig> {
    let texto = texto.trim();
    if texto.is_empty() {
        return Err(ErrorConfig::Vacio);
    }
    let puerto: u16 = texto.parse()?;                 // ParseIntError → ErrorConfig (con From)
    if puerto < 1024 {
        return Err(ErrorConfig::PuertoReservado(puerto));
    }
    Ok(puerto)
}

fn main() {
    for entrada in ["8080", "", "abc", "80", "70000"] {
        match leer_puerto(entrada) {
            Ok(p) => println!("'{entrada}' → puerto {p}"),
            Err(e) => println!("'{entrada}' → error: {e}"),
        }
    }
}

Salida:

'8080' → puerto 8080
'' → error: el puerto no puede estar vacío
'abc' → error: puerto inválido: invalid digit found in string
'80' → error: el puerto 80 está reservado (< 1024)
'70000' → error: puerto inválido: number too large to fit in target type

Reaccionar distinto según el tipo de error

Esta es la gran ventaja del enum sobre un String:

fn main() {
    match leer_puerto("80") {
        Ok(p) => println!("usando {p}"),
        Err(ErrorConfig::Vacio) => println!("usando el puerto por defecto 8080"),
        Err(ErrorConfig::PuertoReservado(p)) => println!("el {p} requiere permisos; probando 8080"),
        Err(e) => println!("configuración inválida: {e}"),
    }
}

8.8 Conversión sin From: map_err con una variante

Si no quieres (o no puedes) implementar From, map_err convierte el error a mano. Una variante con datos funciona como función:

fn leer_puerto_v2(texto: &str) -> Result<u16, ErrorConfig> {
    let puerto = texto.trim().parse::<u16>().map_err(ErrorConfig::PuertoInvalido)?;
    Ok(puerto)
}

Es útil cuando el mismo tipo de error (por ejemplo ParseIntError) puede significar cosas distintas según el campo que se leía. Con From solo puede haber una conversión por tipo de origen.

8.9 Un error que reúne varias fuentes

use std::fmt;
use std::fs;
use std::io;
use std::num::ParseIntError;

#[derive(Debug)]
enum ErrorDatos {
    Io(io::Error),
    Parseo(ParseIntError),
}

impl fmt::Display for ErrorDatos {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            ErrorDatos::Io(e) => write!(f, "error de lectura: {e}"),
            ErrorDatos::Parseo(e) => write!(f, "dato inválido: {e}"),
        }
    }
}

impl std::error::Error for ErrorDatos {}

impl From<io::Error> for ErrorDatos {
    fn from(e: io::Error) -> Self {
        ErrorDatos::Io(e)
    }
}

impl From<ParseIntError> for ErrorDatos {
    fn from(e: ParseIntError) -> Self {
        ErrorDatos::Parseo(e)
    }
}

/// Suma los números de un archivo (uno por línea).
fn sumar_archivo(ruta: &str) -> Result<i32, ErrorDatos> {
    let contenido = fs::read_to_string(ruta)?;          // io::Error → ErrorDatos::Io
    let mut total = 0;
    for linea in contenido.lines() {
        if linea.trim().is_empty() {
            continue;
        }
        let n: i32 = linea.trim().parse()?;             // ParseIntError → ErrorDatos::Parseo
        total += n;
    }
    Ok(total)
}

fn main() {
    match sumar_archivo("no_existe.txt") {
        Ok(t) => println!("Total: {t}"),
        Err(e) => println!("{e}"),
        // En Linux/macOS: error de lectura: No such file or directory (os error 2)
        // (el texto exacto depende del sistema operativo)
    }
}