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