Coalescing lvalue references to std-optionals

Question

I want to coalesce (lvalue references to) optionals of the same type, in C++17:

#include <optional>

template <typename... Ts>
constexpr auto coalesce(std::optional<Ts>&... optionals );

template <typename T>
constexpr std::optional<T>& coalesce(std::optional<T>& x, std::optional<T>& y)
{
    return x.has_value() ? x : y;
}

template <typename T>
constexpr std::optional<T> coalesce(std::optional<T>& x)
{
    return x;
}

template <typename T, typename... Ts>
constexpr std::optional<T> coalesce(std::optional<T>& x, std::optional<Ts>&... xs )
{
    return coalesce(x, coalesce(std::forward<std::optional<T>&>(xs)...));
}

This is sub-optimal, as it uses recursive templated function calls, rather than ellipsis-based expansion in a single body. What would you suggest?

Notes:

• C++17 and no fancy libraries please.
• This can be seen as a specific case of the "return first parameter in a pack satisfying a predicate", with the predicate being [](auto x) { return x.has_value(); }
• If possible, let's not copy any T's.

Answer 1

So ideally you want to write something like:

template <typename... Ts>
constepxr auto coalesce(std::optional<Ts>&... xs)
{
   return (xs || ...);
}

But the issue here is of course that it will convert the optionals to bool before applying the boolean or-operator. You could however cast it to a type that does provide the right semantics for the boolean or-operator to do the thing you want:

template <typename T>
struct coalescable {
    T &x;
    coalescable(T &x_): x(x_) {}
    constexpr const coalescable &operator||(const coalescable &other) {
        return x.has_value() ? *this : other;
    }
};

And then use that in the fold expression:

template <typename... Ts>
constepxr auto coalesce(std::optional<Ts>&... xs)
{
   return (coalescable(xs) || ...).x;
}

Answer 2

Folding? Bah. New-fangled nonsense. Real programmers use for loops for for looping.

#include <optional>
#include <functional>

template<class T, class... Ts>
std::optional<T> coalesce(std::optional<Ts>&... xs)
{
    for (auto const& x : { std::reference_wrapper<std::optional<T>>(xs)... })
        if (x.get().has_value())
            return x;

    return {};
}

(Yeah, G. Sliepen's is better, and I still don't understand that other one).

Answer 3

Well, if you don't want recursion, you have to fold instead.

template <class... Ts>
constexpr auto coalesce(std::optional<Ts>&... xs) {
    std::optional<std::common_type_t<Ts...>> r;
    ((xs && (r = xs, true)) || ...);
    return r;
}

If you want to avoid even the single copy to the result, you need to change the result-type by using an optional std::reference_wrapper or going with a potentially null pointer.

template <class... Ts>
constexpr auto coalesce(std::optional<Ts>&... xs) noexcept {
    std::common_type_t<Ts...>* r = nullptr;
    ((xs && (r = &*xs, true)) || ...);
    if (r)
        return std::optional(std::ref(*r));
    return {};
}