Las conversiones From impulsan ? en Rust

Implementa From para cada error subyacente y ? convierte por su cuenta.

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

#[derive(Debug)]
enum LoadError {
    BadNumber(ParseIntError),
    Empty,
}

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

impl fmt::Display for LoadError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            LoadError::BadNumber(e) => write!(f, "not a number: {e}"),
            LoadError::Empty => write!(f, "nothing to load"),
        }
    }
}

fn total(raw: &str) -> Result<i32, LoadError> {
    if raw.trim().is_empty() {
        return Err(LoadError::Empty);
    }
    let mut sum = 0;
    for part in raw.split(',') {
        sum += part.trim().parse::<i32>()?;
    }
    Ok(sum)
}

fn main() {
    println!("{:?}", total("1, 2, 3"));
    println!("{}", total("1, x").unwrap_err());
    println!("{}", total("  ").unwrap_err());
}

Cómo funciona

1. ? llama a From::from sobre el error que retorna.
2. Basta un impl de From por cada tipo de error ajeno.
3. La función entonces mezcla fuentes de error con libertad.

Palabras clave y builtins usados aquí

• Err
• From
• Ok
• Result
• enum
• fn
• for
• i32
• if
• impl
• in
• let
• match
• mut
• return
• self
• str
• use

El intento, en números

Líneas

40

Caracteres a escribir

775

Tokens

247

Ritmo de tres estrellas

105 tpm

Al ritmo de tres estrellas de 105 tokens por minuto, este intento toma unos 141 segundos.

Escribe este fragmento

Paso 3 de 5 en Tus propios tipos de error; paso 10 de 15 en Manejo de errores.

← Anterior Siguiente →