expected.h

Go to the documentation of this file.

#ifndef FUSED_EXPECTED_H
#define FUSED_EXPECTED_H
 
#include "simple_type_traits.h" // move, forward, is_trivially_destructible, is_nothrow_move_constructible
 
template <typename E>
struct Unexpected
{
    E error; 
};
 
template <typename E>
Unexpected(E) -> Unexpected<E>;
 
template <typename T, typename E>
class [[nodiscard]] Expected
{
    union
    {
        T val_;
        E err_;
    };
    bool has_value_;
 
    void destroy() noexcept
    {
        if (has_value_)
        {
            if constexpr (!is_trivially_destructible_v<T>)
            {
                val_.~T();
            }
        }
    }
 
public:
    using value_type = T;
    using error_type = E;
 
    // -- Construction -------------------------------------------------------
 
    Expected(T &&v) noexcept(is_nothrow_move_constructible_v<T>)
        : val_(move(v)), has_value_(true)
    {
    }
 
    Expected(Unexpected<E> u) noexcept
        : err_(u.error), has_value_(false)
    {
    }
 
    // -- Move semantics (no copy) ------------------------------------------
 
    Expected(Expected &&other) noexcept(is_nothrow_move_constructible_v<T>)
        : has_value_(other.has_value_)
    {
        if (has_value_)
            new (&val_) T(move(other.val_));
        else
            err_ = other.err_;
    }
 
    Expected &operator=(Expected &&other) noexcept(is_nothrow_move_constructible_v<T>)
    {
        if (this != &other)
        {
            destroy();
            has_value_ = other.has_value_;
            if (has_value_)
                new (&val_) T(move(other.val_));
            else
                err_ = other.err_;
        }
        return *this;
    }
 
    Expected(const Expected &) = delete;
 
    Expected &operator=(const Expected &) = delete;
 
    ~Expected() noexcept { destroy(); }
 
    // -- Observers ----------------------------------------------------------
 
    explicit operator bool() const noexcept { return has_value_; }
 
    bool has_value() const noexcept { return has_value_; }
 
    // -- Value access -------------------------------------------------------
 
    T &value() noexcept { return val_; }
 
    const T &value() const noexcept { return val_; }
 
    T &operator*() noexcept { return val_; }
 
    const T &operator*() const noexcept { return val_; }
 
    T *operator->() noexcept { return &val_; }
 
    const T *operator->() const noexcept { return &val_; }
 
    // -- Error access -------------------------------------------------------
 
    E error() const noexcept { return err_; }
 
    // -- Monadic operations (future) ----------------------------------------
    // template <typename F> auto and_then(F&& f) -> Expected<...>;
    // template <typename F> auto transform(F&& f) -> Expected<...>;
    // template <typename F> auto or_else(F&& f) -> Expected<...>;
};
 
#endif // FUSED_EXPECTED_H