expected.h

#pragma once
// This class is a temporary version of std::expected, to be used
//   until C++23 support is available.
 
#include <variant>
 
template <class E>
class unexpected {
public:
    constexpr unexpected(const unexpected<E> &) = default;
    constexpr unexpected(unexpected<E> &&) = default;
    constexpr const E &error() const & noexcept { return e_; }
    constexpr const E &error() & noexcept { return e_; }
    constexpr const E &&error() const && noexcept { return e_; }
    constexpr E &&error() const && noexcept { return e_; }
    template <class E2>
    friend constexpr bool operator==(const unexpected<E> &x,const unexpected<E2> &y) { return x.error()==y.error(); }
private:
    E e_;
};
 
struct unexpect_t {};
 
template <class T,class E>
class expected {
public:
    using value_type = T;
    using error_type = E;
    using unexpected_type = std::unexpected<E>;
    constexpr expected() = default;
    constexpr expected(const expected<T,E> &other) = default;
    constexpr expected(expected<T,E> &&other) = default;
    template <class U=T>
    constexpr expected(const U &v) : v_(v) { }
    template <class U=T>
    constexpr expected(U &&v) : v_(std::move(v)) { }
    template <class U=E>
    constexpr explicit expected(const unexpected<U> &e) : v_(e.error()) { }
    template <class U=E>
    constexpr explicit expected(unexpected<U> &&e) : v_(std::move(e.error())) { }
    template <class ... Args>
    constexpr explicit expected(unexpect_t,Args &&...args) : v_(std::in_place_t<E>,args...) { }
 
    constexpr const T *operator->() const { return &std::get<0>(v_); }
    constexpr       T *operator->() { return &std::get<0>(v_); }
    constexpr const T &operator*() const { return std::get<0>(v_); }
    constexpr       T &operator*() { return std::get<0>(v_); }
    constexpr bool     has_value() const { return v_.index()==0; }
    constexpr operator bool() const { return has_value(); }
    constexpr const T &value() const { return std::get<0>(v_); }
    constexpr T &&     value() { return std::get<0>(v_); }
    constexpr const E &error() const { return std::get<1>(v_); }
    constexpr E &&     error() { return std::get<1>(v_); }
    constexpr T        value_or(T &&default_value) const { return has_value() ? value() : default_value; }
 
    template <class F>
    constexpr auto and_then(F &&f) { if (has_value()) return std::invoke(std::forward<F>(f),**this); else return *this; }
 
    template <class F>
    constexpr auto or_else(F &&f) { if (has_value()) return *this; else return std::invoke(std::forward<F>(f),error()); }
 
private:
    std::variant<T,E> v_;
};
 
// EoF