Hi everyone,

While working with std::optional in production code, I found out that one usually needs to do something additional when the optional returned from some API has no value (e.g. to throw an exception, to log an error, to log that we're going to use a default).
While or_else looks like an ideal candidate to put those actions into, it can be quite verbose because the callable must return the same optional type - so you must mention the whole type either as a trailing return type of the lambda, or in the return statement itself.

Assuming we have a function
std::optional<std::string> loadString();

we need to write either explicit trailing return type:

std::optional<std::string> f_throw() {
    return loadString().or_else([]() -> std::optional<std::string> {
        throw std::runtime_error("[FATAL] Failed to get value");
    });
}

std::optional<std::string> f_log() {
    return loadString().or_else([]() -> std::optional<std::string> {
        std::cout << "[ERROR] Failed to get value";
        return std::nullopt;
    });
}

std::optional<std::string> f_default() {
    return loadString().or_else([]() -> std::optional<std::string> {
        std::cout << "[WARN] Failed to get value, using default";
        return "default";
    });
}

or explicit type in the return statement:

std::optional<std::string> f_throw() {
    return loadString().or_else([] {
        throw std::runtime_error("[FATAL] Failed to get value");
        return std::optional<std::string>{};
    });
}

std::optional<std::string> f_log() {
    return loadString().or_else([] {
        std::cout << "[ERROR] Failed to get value";
        return std::optional<std::string>{};
    });
}

std::optional<std::string> f_default() {
    return loadString().or_else([] {
        std::cout << "[WARN] Failed to get value, using default";
        return std::optional<std::string>{"default"};
    });
}

I believe it would improve the usability of or_else if we allow the function to return void (treated as nullopt) or a type that can be used to construct the value type of the optional.
This would allow us to write these 3 functions shorter and cleaner, with all the noise in bold removed:
std::optional<std::string> f_throw() {
    return loadString().or_else([] {
        throw std::runtime_error("[FATAL] Failed to get value");
    });
}

std::optional<std::string> f_log() {
    return loadString().or_else([] {
        std::cout << "[ERROR] Failed to get value";
    });
}

std::optional<std::string> f_default() {
    return loadString().or_else([] {
        std::cout << "[WARN] Failed to get value, using default";
        return "default";
    });
}

The implementation can be like this:
template <class T>
class std::optional<T> {
...
    template <class F>
    optional or_else(F&& f) {
        using R = std::remove_cvref_t<std::invoke_result_t<F>>;
        if constexpr (std::is_same_v<R, optional>) { // the current API
            return std::invoke(std::forward<F>(f));
        } else if constexpr (std::is_same_v<R, void>) { // void: return std::nullopt;
            std::invoke(std::forward<F>(f));
            return std::nullopt;
        } else if constexpr (std::is_constructible_v<T, R>) { // direct-construct
            return optional{std::invoke(std::forward<F>(f))};
        } else {
            static_assert(!std::is_same_v<F, F>, "Wrong return type");
        }
    }
};

Proof of concept: https://godbolt.org/z/W51bWbKo3

Would there be any interest in putting this into a proposal? Was something like this discussed already at the committee meetings related to std::optional?
Please let me know what you think.

Thanks,
Maxim