maybe.hpp

#ifndef LIVE_CELLS_MAYBE_HPP
#define LIVE_CELLS_MAYBE_HPP
 
#include <concepts>
#include <exception>
#include <optional>
 
#include "util.hpp"
#include "exceptions.hpp"
 
namespace live_cells {
    template <typename T>
    class maybe {
    public:
        maybe() {
            try {
                throw uninitialized_cell_error();
            }
            catch (...) {
                error_ = std::current_exception();
            }
        }
 
        maybe(const T &val) : value_(val) {}
 
        maybe(std::exception_ptr error) : error_(error) {}
 
        static maybe<T> error(const auto &error) {
            try {
                throw error;
            }
            catch (...) {
                return maybe(std::current_exception());
            }
        }
 
        static maybe<T> wrap(const std::invocable auto &f) {
            try {
                return maybe(f());
            }
            catch (...) {
                return maybe(std::current_exception());
            }
        }
 
        T unwrap() const {
            if (value_) {
                return value_.value();
            }
 
            std::rethrow_exception(error_);
        }
 
        std::optional<T> value() const {
            return value_;
        }
 
        std::exception_ptr error() const {
            return error_;
        }
 
    private:
        std::optional<T> value_;
 
        std::exception_ptr error_;
    };
 
    auto maybe_wrap(const std::invocable auto &f) {
        return maybe<decltype(f())>::wrap(f);
    }
 
    template <typename A, typename B>
    bool operator==(const maybe<A> &a, const maybe<B> &b) {
        return a.value() == b.value() && a.error() == b.error();
    }
 
}  // live_cells
 
template<typename T>
struct std::hash<live_cells::maybe<T>> {
    std::size_t operator()(const live_cells::maybe<T> &m) {
        return live_cells::internal::hash_combine(0, m.value(), m.error());
    }
};
 
#endif /* LIVE_CELLS_MAYBE_HPP */