Option y Result: errores sin excepciones ni null

Rust no tiene null ni excepciones. Usa dos tipos que obligan a considerar el caso negativo.

Option: puede que no haya valor

fn buscar(ids: &[u32], id: u32) -> Option<usize> {
    ids.iter().position(|&x| x == id)
}

fn main() {
    match buscar(&[1, 2, 3], 2) {
        Some(i) => println!("Posición {i}"),
        None => println!("No existe"),
    }
}

La firma ya avisa que el valor puede faltar, y no puedes usarlo sin comprobarlo. Desaparece así el clásico error de referencia nula.

Result: puede fallar

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

fn leer_config(ruta: &str) -> Result<String, io::Error> {
    let texto = fs::read_to_string(ruta)?;
    Ok(texto.trim().to_string())
}

fn main() {
    match leer_config("app.toml") {
        Ok(t) => println!("{t}"),
        Err(e) => eprintln!("No pude leerla: {e}"),
    }
}

El operador ?

El ? significa: si esto falló, devuelve el error a quien me llamó; si no, dame el valor. Mantiene el código corto sin ocultar que puede fallar.

Cuidado con unwrap

.unwrap() extrae el valor y detiene el programa si no existe. Sirve en ejemplos y pruebas, pero en producción convierte un error manejable en una caída del servicio.

Prefiere ?, match, o métodos como .unwrap_or() y .unwrap_or_default().