Proposal for a macro like `matches!()` that maps extracted value to `Option`

After the inclusion of the matches macro into std, there are still a lot of similar use cases that it can't be used with:
Those that require extracting a value like this:

    match param {
        ParamSelector::Int(_, TrackParam::Ext(name)) => Some(name),
        _ => None,
    }

These patterns occur frequently (or variations with if-let).
There is currently no concise one-line way to write this.
So I adapted the matches macro to work for these use cases:

#[macro_export]
macro_rules! match_map {
    ($expression:expr, $( $pattern:pat )|+ $( if $guard: expr )? => $ret:expr) => {
        match $expression {
            $( $pattern )|+ $( if $guard )? => Some($ret),
            _ => None
        }
    }
}

enum E { A(i32), B(i32), C }

fn main() {
    assert_eq!(match_map!(E::A(21), E::A(x) | E::B(x) => x * 2), Some(42));
}

https://play.rust-lang.org/?version=nightly&mode=debug&edition=2018&gist=a3df83eee3d96f05233d78d00f7bc801

I use this macro as often as matches and think it would be useful to have it in std.

Compared to using the more verbose match/if-let way, this macro also has the benefit of readability, when the value is post-processed using .map(..)/.and_then(..)/.ok_or_else(..) or similar Option methods.

Compare:

    (match param {
        TrackParam::Ext(name) => Some(name),
        _ => None,
    }).and_then(|name| func(name))

and:

    match_map!(param, TrackParam::Ext(name) => name).and_then(|name| func(name))

Start by reviewing the proposed match_map! macro, its matches! comparison, and the linked Rust Playground examples. Determine whether the proposed extraction and Option mapping belong in std, and what design or RFC decisions are required. Done means the proposal has a settled design and an accepted path forward.