hxexpected.hpp

Go to the documentation of this file.

#pragma once
// SPDX-FileCopyrightText: © 2017-2026 Adrian Johnston.
// SPDX-License-Identifier: MIT
// This file is licensed under the MIT license found in the LICENSE.md file.

 
#include "libhatchet.h"
 
static_assert(HX_CPLUSPLUS >= 202302L, "hxexpected.hpp requires C++23");
 
// HX_USE_MACROS_WITH_MODULE allows including macros alongside the module.
#if HX_USE_MACROS_WITH_MODULE
#error Header does not provide macros alone.
#endif
 
#include "hxallocator.hpp"
#include "hxkey.hpp"
 
HX_NS_BEGIN_

template<typename T_>
concept hxexpected_concept_ = requires(T_& x_, const T_& y_) {
    sizeof(T_);
    T_();
    T_(y_);
    T_(hxmove(x_));
    x_ = y_;
    x_ = hxmove(x_);
    x_.~T_();
    { x_ == y_ } -> hxsame_as<bool>;
};
 
template<typename E_>
concept hxunexpected_concept_ = requires(E_& x_, const E_& y_) {
    sizeof(E_);
    E_(true);
    E_(false);
    E_(y_);
    E_(hxmove(x_));
    x_ = y_;
    x_ = hxmove(x_);
    x_.~E_();
    { static_cast<bool>(y_) };
    { x_ == y_ } -> hxsame_as<bool>;
};
 
template<hxexpected_concept_ T_, hxunexpected_concept_ E_=bool> class hxexpected;
 
// Used to prevent forwarding constructors from hijacking converting-copy
// construction paths.
template<typename> class hxis_hxexpected_ : public hxfalse_t { };
template<typename T_, typename E_>
class hxis_hxexpected_<hxexpected<T_, E_>> : public hxtrue_t { };

template<hxexpected_concept_ T_, hxunexpected_concept_ E_>
class hxexpected : private hxallocator<T_, 1> {
public:
    // These are for safety. Use hxref for pointer and reference types.
    static_assert(!hxis_reference<T_>(), "hxexpected does not support reference types");
    static_assert(!hxis_pointer<T_>(), "hxexpected does not support pointer types");

    using error_t = E_;

    using value_t = T_;

    hxexpected(void) : m_error_(true) { }

    hxexpected(hxnil_t) : m_error_(true) { }

    hxexpected(const hxexpected& x_) noexcept;

    hxexpected(hxexpected&& x_) noexcept;

    template<typename error_t_=E_, typename... args_t_, hxenable_if_t<
        !hxis_hxexpected_<hxremove_cvref_t<error_t_>>::value, bool> = true>
    explicit hxexpected(error_t_&& error_, args_t_&&... args_) noexcept;

    ~hxexpected(void);

    hxattr_nodiscard const T_& operator*(void) const;
 
    hxattr_nodiscard T_& operator*(void);

    hxattr_nodiscard const T_* operator->(void) const;
 
    hxattr_nodiscard T_* operator->(void);

    hxattr_nodiscard explicit operator bool(void) const { return !static_cast<bool>(m_error_); }

    hxexpected& operator=(const hxexpected& x_) noexcept;

    hxexpected& operator=(hxexpected&& x_) noexcept;

    hxexpected& operator=(hxnil_t) { this->reset(); return *this; }

    template<typename U_=T_, hxenable_if_t<
        !hxis_hxexpected_<hxremove_cvref_t<U_>>::value &&
        !hxis_same<hxremove_cvref_t<U_>, E_>(), bool> = true>
    hxexpected& operator=(U_&& value_) noexcept;

    hxattr_nodiscard bool operator==(const hxexpected& x_) const { return this->equal(x_); }

    hxattr_nodiscard bool operator==(hxnil_t) const { return static_cast<bool>(m_error_); }

    hxattr_nodiscard bool operator==(const T_& value_) const;

    template<typename self_t_, typename callable_t_>
    hxattr_nodiscard auto and_then(this self_t_&& self_, callable_t_&& callable_)
        -> hxremove_cvref_t<decltype(hxforward<callable_t_>(callable_)(
            hxforward_like<self_t_>(hxdeclval<T_&>())))>;

    template<typename... args_t_>
    T_& emplace(args_t_&&... args_) noexcept;

    hxattr_nodiscard bool equal(const hxexpected& x_) const;

    template<typename self_t_>
    hxattr_nodiscard auto error(this self_t_&& self_)
        -> decltype(hxforward_like<self_t_>(hxdeclval<E_&>()));

    hxattr_nodiscard bool has_value(void) const { return !static_cast<bool>(m_error_); }

    hxattr_nodiscard hxhash_t hash(void) const;

    template<typename self_t_, typename callable_t_>
    hxattr_nodiscard hxexpected or_else(this self_t_&& self_, callable_t_&& callable_);

    void reset(void) noexcept;

    void reset(const E_& error_) noexcept;

    void swap(hxexpected& x_) noexcept;

    template<typename self_t_>
    hxattr_nodiscard auto value(this self_t_&& self_)
        -> decltype(hxforward_like<self_t_>(hxdeclval<T_&>()));

    template<typename self_t_, typename... args_t_>
    hxattr_nodiscard T_ value_or(this self_t_&& self_, args_t_&&... args_);
 
private:
    E_ m_error_;
};

template<typename T_>
hxattr_nodiscard hxexpected<T_> hxmake_expected(const T_& value_) {
    return hxexpected<T_>(false, value_);
}

template<typename T_, typename E_, typename... args_t_>
hxattr_nodiscard hxexpected<T_, E_> hxmake_expected(args_t_&&... args_) {
    hxexpected<T_, E_> result_;
    result_.emplace(hxforward<args_t_>(args_)...);
    return result_;
}

template<typename T_, typename E_>
class hxkey_equal_t<hxexpected<T_, E_> > {
public:
    hxattr_nodiscard hxinline hxattr_flatten
    bool operator()(
            const hxexpected<T_, E_>& x_, const hxexpected<T_, E_>& y_) const {
        return x_.equal(y_);
    }
};

template<typename T_, typename E_>
class hxkey_hash_t<hxexpected<T_, E_> > {
public:
    hxattr_nodiscard hxinline hxattr_flatten
    hxhash_t operator()(const hxexpected<T_, E_>& expected_) const {
        return expected_.hash();
    }
};
 
#include "detail/hxexpected.inl"
HX_NS_END_