Обхождане на Result-ати

Действието Iter::map може да не успее. Например:

fn main() {
    let strings = vec!["tofu", "93", "18"];
    let numbers: Vec<_> = strings
        .into_iter()
        .map(|s| s.parse::<i32>())
        .collect();
    println!("Резултати: {:?}", numbers);
}

Да видим как може да се подходи.

Да пропускаме неуспешно обработените единици с помощта на filter_map()

filter_map извиква функция и филтрира резултатите, които са None.

fn main() {
    let strings = vec!["tofu", "93", "18"];
    let numbers: Vec<_> = strings
        .into_iter()
        .filter_map(|s| s.parse::<i32>().ok())
        .collect();
    println!("Резултати: {:?}", numbers);
}

Да съберем провалите с помощта на map_err() и filter_map()

map_err извиква функция , като ѝ подава грешката. Ако добавим това към предното решение с filter_map, можем да съберем грешките, докато обхождаме.

fn main() {
    let strings = vec!["42", "tofu", "93", "999", "18"];
    let mut errors = vec![];
    let numbers: Vec<_> = strings
        .into_iter()
        .map(|s| s.parse::<u8>())
        .filter_map(|r| r.map_err(|e| errors.push(e)).ok())
        .collect();
    println!("Числа: {:?}", numbers);
    println!("Грешки: {:?}", errors);
}

Да предизвикаме неуспех на цялото действие чрез collect()

Result въплъщава FromIterator, така че един вектор, съдържащ резултати (Vec<Result<T, E>>), може да бъде превърнат в резултат, съдържащ вектор (Result<Vec<T>, E>). Щом се натъкнем на Result::Err, обхождането се прекратява.

fn main() {
    let strings = vec!["tofu", "93", "18"];
    let numbers: Result<Vec<_>, _> = strings
        .into_iter()
        .map(|s| s.parse::<i32>())
        .collect();
    println!("Резултати: {:?}", numbers);
}

Същата техника може да бъде приложена с Option.

Събираме всички действителни стойности и грешки с помощта на partition()

fn main() {
    let strings = vec!["tofu", "93", "18"];
    let (numbers, errors): (Vec<_>, Vec<_>) = strings
        .into_iter()
        .map(|s| s.parse::<i32>())
        .partition(Result::is_ok);
    println!("Числа: {:?}", numbers);
    println!("Грешки: {:?}", errors);
}

Ако погледнем резултатите, ще забележим, че всичко е все още обгърнато с Result. За да разгърнем стойностите, трябва да напишем още малко код.

fn main() {
    let strings = vec!["tofu", "93", "18"];
    let (numbers, errors): (Vec<_>, Vec<_>) = strings
        .into_iter()
        .map(|s| s.parse::<i32>())
        .partition(Result::is_ok);
    let numbers: Vec<_> = numbers.into_iter().map(Result::unwrap).collect();
    let errors: Vec<_> = errors.into_iter().map(Result::unwrap_err).collect();
    println!("Числа: {:?}", numbers);
    println!("Грешки: {:?}", errors);
}