`Infallible` în Rust

Erori, panică și ieșire din program Rust 1.34

Tipul de eroare pentru operații care nu pot eșua niciodată: un enum fără variante, deci fără nicio valoare posibilă.

Sintaxă

use std::convert::Infallible;

pub enum Infallible {}

Ce face `Infallible`

Infallible este un enum gol: nu poți crea nicio valoare de acest tip. Un Result<T, Infallible> este deci mereu Ok. Îl întâlnești când un trait cere un tip de eroare, dar implementarea concretă nu poate eșua.

Exemple din std: String::from_str (orice text devine String) are Err = Infallible, iar TryFrom implementat automat pe baza lui From are tot Infallible. Pentru că nu există variantă Err, poți scoate valoarea cu un match care tratează doar Ok, fără unwrap.

Ce returnează

Este un tip, nu o funcție.

Exemple

Exemplul 1: Conversii care nu pot eșua

let Ok(x) = ...; compilează fără else, pentru că varianta Err(Infallible) nu poate exista.

use std::convert::Infallible;
use std::str::FromStr;

fn main() {
    let r: Result<String, Infallible> = String::from_str("Iași");
    let Ok(oras) = r;
    println!("oraș: {oras}");

    let r2: Result<i64, Infallible> = i64::try_from(42_i32);
    let Ok(mare) = r2;
    println!("i64: {mare}");

    let r3 = i8::try_from(300_i32);
    println!("i8 din 300: {r3:?}");
}

Rezultat

oraș: Iași
i64: 42
i8 din 300: Err(TryFromIntError(PosOverflow))

Exemplul 2: Infallible într-un trait propriu

Un parser care acceptă orice text folosește Infallible ca tip de eroare.

use std::convert::Infallible;

trait Parser {
    type Eroare;
    fn parseaza(&self, text: &str) -> Result<String, Self::Eroare>;
}

struct Majuscule;

impl Parser for Majuscule {
    type Eroare = Infallible;
    fn parseaza(&self, text: &str) -> Result<String, Infallible> {
        Ok(text.to_uppercase())
    }
}

fn main() {
    let Ok(rezultat) = Majuscule.parseaza("dexblog");
    println!("{rezultat}");
}