Add Option::merge under option_merge feature gate

[WaffleLapkin]

tl;dr: add the following method to Option<T> under option_merge feature gate:

pub fn merge<F>(self, other: Option<T>, f: F) -> Option<T>
where
    F: FnOnce(T, T) -> T;

---

The method returns

• Some(f(l, r)) if both options are Some(_)
• Some(x) if either of the options is Some(x) and the other is None
• None if both options are None

It is very similar to Option::zip_with (or Option::zip + Option::map) with the difference that it doesn't return None if only one of the inputs is None

This can be very handy when, for example, calculating a minimum of two options (without inflicting with None).

---

Some usage examples:

let x = Some(2);
let y = Some(4);

assert_eq!(x.merge(y, Add::add), Some(6));
assert_eq!(x.merge(y, min), Some(2));

assert_eq!(x.merge(None, Add::add), x);
assert_eq!(None.merge(y, min), y);

assert_eq!(None.merge(None, i32::add), None);

---

I'm not sure about the name, some other ideas:

• coalesce
• combine
• reduce (suggested in Add Option::merge under option_merge feature gate #84695 (comment))

[rust-highfive]

r? @yaahc

(rust-highfive has picked a reviewer for you, use r? to override)

[jyn514]

coalesce

coalesce has a different meaning in SQL, I don't think that's a great choice:

The COALESCE() function returns the first non-null value in a list.

[joshtriplett]

You can write this today by treating both options as iterators and using reduce, which returns an Option that's None if the iterator is empty. Or in the specific case of min or max, you could call .min() or .max() on the iterator, which also conveniently returns an Option.

fn f(x: Option<u32>, y: Option<u32>) -> Option<u32> {
    x.into_iter().chain(y.into_iter()).min()
}

fn main() {
    assert_eq!(f(None, None), None);
    assert_eq!(f(Some(10), None), Some(10));
    assert_eq!(f(None, Some(5)), Some(5));
    assert_eq!(f(Some(10), Some(5)), Some(5));
}

However, that's certainly not the most convenient approach.

Another option, which is reasonably clear: x.xor(y).or_else(|| x.min(y))

If we consider adding this function, I'd suggest calling it reduce, as it has exactly the semantic of reduce.

[optozorax]

Some potential example usage of this method can be found here: https://doc.rust-lang.org/src/core/iter/adapters/zip.rs.html#162

[Dylan-DPC-zz]

r? @m-ou-se

[m-ou-se]

Thanks for your PR.

I'm not convinced we should add this, though. I can't think of a lot of use cases that aren't already covered by Iterator::reduce, and I don't think it'd be clear to a reader what this function does, which I think is especially important for methods on commonly used types like Option.

Pinging @rust-lang/libs in case anyone feels like this would be an important addition. Otherwise I'll close this PR.

[joshtriplett]

I've wanted this function a few times, but I don't know if it's sufficiently common to justify a function in std.

[JohnTitor]

Triage: There's no comment to support this strongly since @m-ou-se left a comment, so I'm going to close. Thanks!

[WaffleLapkin]

I've made a micro crate that provides the function, in case anyone needs it too: opt_reduce.