Replace self-calling closures with try blocks (once stabilized)

What it does

In one of my codebases, I regularly used lambdas and immediately called them, to handle nested optional types:

let nested_property: Option<C> = (|| Some(object.a?.b?.c?))();

Once try blocks are stabilized, this can be done much cleaner and more idiomatically:

let nested_property: Option<C> = try { object.a?.b?.c? };

Another example:

let property = (|| Some(string.get(5..10)?.parse().ok()?))(); // old

let property = try { string.get(5..10)?.parse().ok()? }; // new

Categories

• Kind: clippy::style or clippy::complexity

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

More idiomatic via usage of the intended language feature instead of abusing closures.

Drawbacks

None.

Example

let nested_property: Option<C> = (|| Some(object.a?.b?.c?))();

Could be written as:

let nested_property: Option<C> = try { object.a?.b?.c? };

Review Rust's try-blocks language-feature documentation and compare it with the self-calling closure examples in the issue. Determine whether try blocks are stabilized and whether Clippy can recognize this pattern safely. Done means the proposed style or complexity lint is implemented with coverage for the shown nested-optional and parsing examples.