rust - resfriada - remedios caseros para la alergia nasal

¿Cómo detengo la iteración y devuelvo un error cuando Iterator:: map devuelve un Result:: Err?

Question

Tengo una función que devuelve un Result :

fn find(id: &Id) -> Result<Item, ItemError> {
// ...
}

Luego otro usándolo así:

let parent_items: Vec<Item> = parent_ids.iter()
.map(|id| find(id).unwrap())
.collect();

¿Cómo manejo el caso de falla dentro de cualquiera de las iteraciones del map ?

Sé que podría usar flat_map y en este caso los resultados del error serían ignorados :

let parent_items: Vec<Item> = parent_ids.iter()
.flat_map(|id| find(id).into_iter())
.collect();

El iterador del resultado tiene 0 o 1 elementos dependiendo del estado de éxito, y flat_map lo filtrará si es 0.

Sin embargo, no quiero ignorar los errores. En su lugar, quiero hacer que todo el bloque de código se detenga y devuelva un nuevo error (basado en el error que apareció en el mapa, o simplemente reenviar el error existente).

¿Cómo manejo esto en Rust?

Answer 1

Esta respuesta se refiere a una versión anterior a la versión 1.0 de Rust y se eliminaron las funciones necesarias

Puede usar la función std::result::fold para esto. Deja de iterar después de encontrar el primer Err .

Un programa de ejemplo que acabo de escribir:

fn main() {
println!("{}", go([1, 2, 3]));
println!("{}", go([1, -2, 3]));
}
fn go(v: &[int]) -> Result<Vec<int>, String> {
std::result::fold(
v.iter().map(|&n| is_positive(n)),
vec![],
|mut v, e| {
v.push(e);
v
})
}
fn is_positive(n: int) -> Result<int, String> {
if n > 0 {
Ok(n)
} else {
Err(format!("{} is not positive!", n))
}
}

Salida:

Ok([1, 2, 3])
Err(-2 is not positive!)

Demo

Answer 2

Result implementa FromIterator , por lo que puede mover el Result exterior y los iteradores se encargarán del resto (incluida la detención de la iteración si se encuentra un error).

#[derive(Debug)]
struct Item;
type Id = String;
fn find(id: &Id) -> Result<Item, String> {
Err(format!("Not found: {:?}", id))
}
fn main() {
let s = |s: &str| s.to_string();
let ids = vec![s("1"), s("2"), s("3")];
let items: Result<Vec<_>, _> = ids.iter().map(find).collect();
println!("Result: {:?}", items);
}

Playground