remove nesting for `if let else None`

What it does

I see myself often writing something like this:

fn some_function<T>(some_option: Option<T>) -> Option<T> {
     if let Some(value) = some_option {
         // some code
     } else {
          None
     }
}

this could be written as:

fn some_function<T>(some_option: Option<T>) -> Option<T> {
     let value = some_option?;
     // some code
}

which is a lot cleaner to read and removes one layer of nesting. I think clippy currently suggests calling Option::map:

fn some_function<T>(some_option: Option<T>) -> Option<T> {
     some_option.map(|value| {
          // some code
     })
}

This is fine, but it has some disadvantages:

• it is harder to understand for newcomers
• and it introduces a new layer of nesting

Categories (optional)

• Kind: clippy::style

What is the advantage of the recommended code over the original code

• less noise in the code

Drawbacks

Might conflict with existing lints.

Example

fn some_function<T: fmt::Display>(some_option: Option<T>) -> Option<String> {
    if let Some(value) = some_option {
        println!("{}", &value);
        Some(value.to_string())
    } else {
        None
    }
}

Could be written as:

fn some_function<T: fmt::Display>(some_option: Option<T>) -> Option<String> {
    let value = some_option?;

    println!("{}", &value);
    Some(value.to_string())
}

(this is kind of a bad example, but I can not think of a better one at the moment)

Start by reviewing Clippy's existing clippy::style lints and the current guidance around Option::map. Compare the proposed if-let/else pattern with the Option examples in the issue, including possible conflicts with existing lints. Done means the intended pattern and exclusions are defined and covered by appropriate lint tests.