How to do error handling of nested `.iter()`s? - rust

Question

I am trying to do error handling when using .iter() in combination with .flat_map, which has an .iter().map() within it.
The scenario is getting all the Events that belong to a set of organisations, where the nested .iter().map() is used to get the participants of each event, combine that with the event and return an EventResponse stuct.
A non-specific-scenario way of describing the issue would be 'How to get Result<Vec<T>, err> from nested flat_map of Result<Vec<T>, err>, which has nested map of Result<T, err>'
Below is an abstracted/simplified version of the code I'm using, that gives me the same errors as my actual code.
struct Event {
id: usize,
}
#[derive(Debug)]
struct EventResponse {
id: usize,
participants: Vec<i32>,
}
fn main() {
let orgs = vec![1, 3, 14, 12];
let events: Result<Vec<EventResponse>, &str> = orgs
.iter()
.flat_map::<Result<Vec<EventResponse>, &str>, _>(|org_id| {
get_events_for(*org_id)
.map_err(|_| "That Org id does not exist")
.map(|events| {
events
.iter()
.map::<Result<EventResponse, &str>, _>(|event| {
get_event_with_participants(event)
.map(|event_response| event_response)
.map_err(|_| "Participants for that event were not found")
})
.collect()
})
})
.collect();
}
fn get_events_for(id: usize) -> Result<Vec<Event>, ()> {
// pretend we are checking against a database of existing org ids, if the org id does not exist, then return an error
if id == 3 {
Ok(vec![Event { id }])
} else {
Err(())
}
}
fn get_event_with_participants(event: &Event) -> Result<EventResponse, ()> {
//pretend the participants are fetched from a database
let foundParticipants = true;
if foundParticipants {
Ok(EventResponse {
id: event.id,
participants: vec![1, 2, 5],
})
} else {
Err(())
}
}
Playground
The type annotations are to show what is expected to be returned at each stage. I expect events to be of type Result<Vec<EventResponse>, &str> but I am getting 2 errors:
error[E0277]: a collection of type `std::vec::Vec<EventResponse>` cannot be built from an iterator over elements of type `std::result::Result<EventResponse, &str>`
--> example.rs:27:26
|
27 | .collect()
| ^^^^^^^ a collection of type `std::vec::Vec<EventResponse>` cannot be built from `std::iter::Iterator<Item=std::result::Result<EventResponse, &str>>`
|
= help: the trait `std::iter::FromIterator<std::result::Result<EventResponse, &str>>` is not implemented for `std::vec::Vec<EventResponse>`
error[E0277]: a collection of type `std::result::Result<std::vec::Vec<EventResponse>, &str>` cannot be built from an iterator over elements of type `std::vec::Vec<EventResponse>`
--> example.rs:30:10
|
30 | .collect();
| ^^^^^^^ a collection of type `std::result::Result<std::vec::Vec<EventResponse>, &str>` cannot be built from `std::iter::Iterator<Item=std::vec::Vec<EventResponse>>`
|
= help: the trait `std::iter::FromIterator<std::vec::Vec<EventResponse>>` is not implemented for `std::result::Result<std::vec::Vec<EventResponse>, &str>`
EDIT: The get_events_for function cannot be modified, however, the get_event_with_participants function can be modified, if that helps.

Answer 1

Being interested in the problem, I tried to implement this with map and try_fold. Using flat_map directly didn't work for me, as I couldn't get around the fact that the first inner loop has to produce a Result. I moved the error messages into the functions, but that could easily be undone if you explicitly wanted to avoid it.
struct Event {
id: usize,
}
#[derive(Debug)]
struct EventResponse {
id: usize,
participants: Vec<i32>,
}
fn main() {
let orgs = vec![1, 3, 14, 12];
let events: Result<Vec<EventResponse>, &str> = orgs
.iter()
.map(|org_id| {
get_events_for(*org_id)?
.iter()
.map(get_event_with_participants)
.collect::<Result<Vec<_>, _>>()
})
.collect::<Result<Vec<_>, _>>()
.map(|org_responses| org_responses.into_iter().flatten().collect());
}
fn get_events_for(id: usize) -> Result<Vec<Event>, &'static str> {
// pretend we are checking against a database of existing org ids, if the org id does not exist, then return an error
if id == 3 {
Ok(vec![Event { id }])
} else {
Err("That Org id does not exist")
}
}
fn get_event_with_participants(event: &Event) -> Result<EventResponse, &'static str> {
//pretend the participants are fetched from a database
let foundParticipants = true;
if foundParticipants {
Ok(EventResponse {
id: event.id,
participants: vec![1, 2, 5],
})
} else {
Err("Participants for that event were not found")
}
}
For try_fold, the main function would become:
fn main() {
let orgs = vec![1, 3, 14, 12];
let events: Result<Vec<EventResponse>, &str> =
orgs.iter().try_fold(Vec::new(), |mut responses, &org| {
responses = get_events_for(org)?
.into_iter()
.try_fold(responses, |mut responses, event| {
let response = get_event_with_participants(&event)?;
responses.push(response);
Ok(responses)
})?;
Ok(responses)
});
}
Personally I'm a fan of the map version, as modifying a Vec using try_fold feels awkward since you have to return the accumulator despite modifying the Vec directly.
Another version to consider is to just use loops, which appears to be far simpler in this situation since you can use the ? operator for errors:
fn main() {
let orgs = vec![1, 3, 14, 12];
let events = get_all_responses(orgs);
}
fn get_all_responses(
orgs: impl IntoIterator<Item = usize>,
) -> Result<Vec<EventResponse>, &'static str> {
let mut responses = Vec::new();
for org in orgs.into_iter() {
for event in get_events_for(org)? {
responses.push(get_event_with_participants(&event)?)
}
}
Ok(responses)
}