FerrousPath

Nivel 1 · Fundamentos· Lección 9 de 10 · 20 min

Manejo de errores

Pánicos para los bugs, Result para los fallos que esperas, y el operador de interrogación que hace indolora la propagación.

Dos clases de fallo

Rust no tiene excepciones. Separa los fallos en dos clases y da a cada una su propio mecanismo.

  • Bugs: un índice fuera de los límites, un invariante roto, «esto no puede pasar». Estos entran en pánico (panic): el hilo deshace la pila y, en un programa típico, el proceso termina con un mensaje.
  • Fallos esperados: falta un archivo, la entrada está mal formada, se cae una conexión. Estos son valores normales de tipo Result, y el sistema de tipos obliga a quien llama a ocuparse de ellos.

Pánicos

fn main() {
    let v = vec![1, 2, 3];
    let index = v.len() + 2;
    println!("about to fail");
    println!("{}", v[index]); // entra en pánico: índice fuera de los límites
}

Puedes provocar un pánico a propósito con panic!("mensaje"), y varias macros lo hacen por ti: assert!, assert_eq!, unreachable!, todo!. Un pánico no es comportamiento indefinido: es una parada controlada.

Result<T, E>

enum Result<T, E> {
    Ok(T),
    Err(E),
}

Toda operación que puede fallar devuelve uno:

fn main() {
    let good: Result<i32, _> = "42".parse::<i32>();
    let bad = "forty-two".parse::<i32>();
    println!("{good:?}\n{bad:?}");

    match "17".parse::<u8>() {
        Ok(n) => println!("parsed {n}"),
        Err(e) => println!("failed: {e}"),
    }
}

El compilador avisa si ignoras un Result, así que los fallos no pueden colarse sin que nadie los vea.

Propagar con ?

La mayoría de las funciones no pueden hacer nada útil con un error salvo pasarlo hacia arriba. El operador ? hace exactamente eso:

use std::num::ParseIntError;

fn parse_pair(s: &str) -> Result<(i32, i32), ParseIntError> {
    let (a, b) = s.split_once(',').unwrap_or((s, "0"));
    let a = a.trim().parse::<i32>()?; // si es Err, lo devuelve desde parse_pair
    let b = b.trim().parse::<i32>()?;
    Ok((a, b))
}

fn main() {
    println!("{:?}", parse_pair("3, 4"));
    println!("{:?}", parse_pair("3, four"));
}

expr? significa: si es Ok(v), se evalúa a v; si es Err(e), devuelve Err(e.into()) ahora mismo. Es una marca visible, de un solo carácter, en cada punto donde la función puede salir antes de tiempo.

? también funciona con Option en las funciones que devuelven Option.

Definir tu propio tipo de error

Cuando una función puede fallar de varias formas, descríbelas con un enum:

use std::fmt;

#[derive(Debug)]
enum ConfigError {
    Missing(String),
    Invalid { key: String, value: String },
}

impl fmt::Display for ConfigError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            ConfigError::Missing(k) => write!(f, "missing key `{k}`"),
            ConfigError::Invalid { key, value } => write!(f, "`{value}` is not valid for `{key}`"),
        }
    }
}

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

fn port(line: &str) -> Result<u16, ConfigError> {
    let value = line
        .strip_prefix("port=")
        .ok_or_else(|| ConfigError::Missing("port".into()))?;
    value.parse().map_err(|_| ConfigError::Invalid {
        key: "port".into(),
        value: value.into(),
    })
}

fn main() {
    for line in ["port=8080", "host=x", "port=eighty"] {
        match port(line) {
            Ok(p) => println!("port {p}"),
            Err(e) => println!("error: {e}"),
        }
    }
}

ok_or_else convierte un Option en un Result; map_err convierte un tipo de error en otro. El nivel 2 muestra cómo el trait From y los crates thiserror y anyhow eliminan la mayor parte de este código repetitivo.

main puede devolver un Result

use std::error::Error;
use std::fs;

fn main() -> Result<(), Box<dyn Error>> {
    let text = fs::read_to_string("definitely-missing.txt")?;
    println!("{} bytes", text.len());
    Ok(())
}

Box<dyn Error> significa «cualquier tipo de error». Es una buena elección para programas pequeños. Si main devuelve Err, el programa imprime el error y termina con un código de salida distinto de cero.

unwrap y expect

Los dos extraen el valor de éxito o entran en pánico. Úsalos cuando el fallo sería un bug, y prefiere expect con un mensaje que explique por qué no puede fallar:

fn main() {
    let ip: std::net::IpAddr = "127.0.0.1"
        .parse()
        .expect("hard-coded address is valid");
    println!("{ip}");
}

Una regla práctica: las bibliotecas devuelven Result y dejan que decida quien llama; las aplicaciones deciden en el nivel más alto; unwrap es para prototipos, pruebas e imposibilidades demostrables.

Ejercicios

  1. Escribe fn safe_div(a: f64, b: f64) -> Result<f64, String> que falle al dividir por cero.
  2. Escribe fn sum_numbers(s: &str) -> Result<i32, std::num::ParseIntError> que sume enteros separados por espacios, usando ? dentro de un bucle for.
  3. Amplía ConfigError con una variante OutOfRange(u32) y haz que port la devuelva para valores superiores a 65535.
Solución del 2
fn sum_numbers(s: &str) -> Result<i32, std::num::ParseIntError> {
    let mut total = 0;
    for word in s.split_whitespace() {
        total += word.parse::<i32>()?;
    }
    Ok(total)
}

fn main() {
    println!("{:?}", sum_numbers("1 2 3"));
    println!("{:?}", sum_numbers("1 two 3"));
}

Comprueba lo que has entendido

Elige una respuesta para ver la explicación.

  1. 1.¿Qué hace el operador ? cuando se aplica a un Err(e)?

  2. 2.¿Cuándo es panic! la herramienta adecuada?

  3. 3.¿Qué debe cumplirse para usar ? sobre un Result dentro de una función?

Términos clave de esta lección

¿Has terminado la lección y los ejercicios?