Rust - Handling Results In A Map Closure

Problem

Consider the following Rust code where we have two functions, both returning Result types. The first function prefixes a line (a string slice), and the second function takes a list of lines and prefixes each using the first function.

use std::error::Error;
 
fn prefix_line(line: &str) -> Result<String, Box<dyn Error>> {
    Ok(format!("PREFIX: {}", line))
}
 
fn prefix_each(lines: &[&str]) -> Result<Vec<String>, Box<dyn Error>> {
    let result = lines
        .iter()
        .map(|line| prefix_line(line)?)
        .collect::<Vec<_>>();
 
    Ok(result)
}

Attempting to compile this code results in an error on line 10:

the '?' operator can only be used in a closure that returns 'Result' or 'Option' (or another type that implements 'FromResidual') [E0277] Help: the trait 'FromResidual<Result<Infallible, Box<dyn StdError>>>' is not implemented for 'std::string::String'

Breaking down the error:

• The map function takes a closure as it's argument
• The ? operator inside the .map() closure is problematic
• This is because the ? operator expects the closure to return a Result or Option
• Instead, the closure's return type is inferred to match the expected output type of map, which is String
• Since String doesn't implement FromResidual, you get the error

Solutions

Collect the results

The simplest way I've found to solve this issue:

• Call prefix_line(line) without the ? operator which outputs Vec<Result<...>>
• Use collect::<Result<Vec<_>, _>>()? to correctly infer types, collect the Results and propagate errors if any
• Leaving us with our desired output Vec<String>

fn prefix_each(lines: &[&str]) -> Result<Vec<String>, Box<dyn Error>> {
    let result = lines
        .iter()
        .map(|line| prefix_line(line))
        .collect::<Result<Vec<_>, _>>()?;
 
    Ok(result)
}

Using a loop

The obvious initial solution but it has drawbacks such as:

• It breaks the functional style
• It requires a mutable variable

fn prefix_each(lines: &[&str]) -> Result<Vec<String>, Box<dyn Error>> {
    let mut result = Vec::new();
 
    for line in lines {
        result.push(prefix_line(line)?);
    }
 
    Ok(result)
}

Using filter_map

• filter_map discards Err values collecting only successful Ok values
• Useful if you want to ignore errors and only care about the successful results

fn prefix_each(lines: &[&str]) -> Result<Vec<String>, Box<dyn Error>> {
    let result = lines
        .iter()
        .filter_map(|line| prefix_line(line).ok())
        .collect::<Vec<_>>();
 
    Ok(result)
}

Using try_fold

• Use try_fold to aggregate results and handle errors gracefully
• It allows you to return a Result type directly

fn prefix_each(lines: &[&str]) -> Result<String, Box<dyn Error>> {
    let result = lines.iter().try_fold(String::new(), |mut acc, line| {
        prefix_line(line).map(|prefixed_line| {
            acc.push_str(&prefixed_line);
            acc.push_str("\n");
            acc
        })
    })?;
 
    Ok(result)
}