error_set.hpp

/* Copyright 2024 Jack A Bernard Jr.
 *
 * Licensed under the Apache License, Version 2.0 (the License);
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an AS IS BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#ifndef SUMTY_ERROR_SET_HPP
#define SUMTY_ERROR_SET_HPP
 
#include "sumty/detail/fwd.hpp"    // IWYU pragma: export
#include "sumty/detail/traits.hpp" // IWYU pragma: export
#include "sumty/detail/utils.hpp"
#include "sumty/utils.hpp"
#include "sumty/variant.hpp"
 
#include <cstddef>
#include <initializer_list>
#include <type_traits>
#include <utility>
 
namespace sumty {
 
/// @class error_set error_set.hpp <sumty/error_set.hpp>
/// @brief A discriminated union of unique error types
///
/// @details
/// @ref error_set is very similar to @ref variant in term of API. The key
/// difference from @ref variant is that @ref error_set requires all its
/// alternatives to be unique, and @ref error_set allows direct conversions
/// between different, but compatible, @ref error_set instantiations.
///
/// Given distinct types `A`, `B`, and `C`, @ref error_set allows the
/// following implicit conversions (this is not exhaustive):
/// * `A -> error_set<A, B, C>`
/// * `B -> error_set<A, B, C>`
/// * `C -> error_set<A, B, C>`
/// * `error_set<B> -> error_set<A, B, C>`
/// * `error_set<C, A> -> error_set<A, B, C>`
/// * `error_set<C, A, B> -> error_set<A, B, C>`
///
/// Generally, an @ref error_set can convert into a different error set as long
/// as each of its alternatives unambiguously map to an alternative in the
/// destination @ref error_set. Additionally, any bare type can convert into an
/// @ref error_set if it can unambiguously convert into one of the destination
/// alternatives.
///
/// The primary purpose of @ref error_set is to improve the convenience of
/// error propagation with @ref result. The conversions shown above also apply
/// to an @ref error_set nested as the error type of a @ref result. Below is a
/// listing of the previous conversions examples, but now wrapped in @ref
/// result, which is equally valid.
/// * `result<T, A> -> result<T, error_set<A, B, C>>`
/// * `result<T, B> -> result<T, error_set<A, B, C>>`
/// * `result<T, C> -> result<T, error_set<A, B, C>>`
/// * `result<T, error_set<B>> -> result<T, error_set<A, B, C>>`
/// * `result<T, error_set<C, A>> -> result<T, error_set<A, B, C>>`
/// * `result<T, error_set<C, A, B>> -> result<T, error_set<A, B, C>>`
///
/// Below is an example of how @ref error_set might be used in practice.
/// ```
/// // specific error types
/// struct neg_int_error {};
/// struct int_parse_error {};
/// struct int_overflow_error {};
///
/// // union of the above error types
/// using my_errors = error_set<
///     neg_int_error,
///     int_parse_error,
///     int_overflow_error
/// >;
///
/// // parse an integer from a string
/// result<int, int_parse_error> parse_int(std::string_view str);
///
/// // calculate the absolute value of an integer
/// result<int, int_overflow_error> abs_value(int x);
///
/// // calculate the integer square root
/// result<int, neg_int_error> isqrt(int x);
///
/// result<int, my_errors> my_algorithm(std::string_view str) {
///     auto parsed = parse_int(str);
///     if (parsed.is_error()) { return parsed; }
///
///     auto positive = abs_value(*parsed);
///     if (positive.is_error()) { return positive; }
///
///     return isqrt(*positive);
/// }
/// ```
///
/// One possible pattern when using @ref error_set is to define all errors as
/// empty types. Like all other sum types in sumty, an @ref error_set of all
/// empty types only needs to actually store the discriminant. In this case,
/// @ref error_set behaves like a flexible enum partially mapped into the type
/// system. That is, a specific (empty) error type uniquely identifies an
/// alternative in any @ref error_set that contains that error type, similar to
/// how an enum value name identifies a value of that enum. So it is possible
/// to create a set of error codes as types without giving them specific values
/// and define subsets of those error codes for different use cases. A function
/// might emit some, but not all, of the errors in your set of error codes, so
/// that function need only declare that it can return those specific errors
/// instead of all codes in the set.
///
/// That said, it is also perfectly valid for each error type to contain
/// additional error information as needed.
template <typename... T>
class error_set : variant<T...> {
  private:
    static_assert(detail::all_unique_v<T...>,
                  "All error types in an error_set must be unqiue");
 
    [[nodiscard]] constexpr variant<T...>& set_() & noexcept {
        return *static_cast<variant<T...>*>(this);
    }
 
    [[nodiscard]] constexpr const variant<T...>& set_() const& noexcept {
        return *static_cast<const variant<T...>*>(this);
    }
 
    [[nodiscard]] constexpr variant<T...>&& set_() && {
        return std::move(*static_cast<variant<T...>*>(this));
    }
 
    [[nodiscard]] constexpr const variant<T...>&& set_() const&& {
        return std::move(*static_cast<const variant<T...>*>(this));
    }
 
    template <typename...>
    friend class error_set;
 
  public:
    /// @brief Default constructor
    ///
    /// @details
    /// Initializes the @ref error_set such that it contains a default
    /// constructed value of the first (index 0) alternative.
    ///
    /// The first alternative *must* be default constructible for this
    /// constructor to participate in overload resoltuion, but no other
    /// alternatives need be default constructible.
    ///
    /// ## Example
    /// ```cpp
    /// error_set<error1, error2> set;
    ///
    /// assert(holds_alternative<error1>(set));
    ///
    /// assert(set.index() == 0);
    /// ```
    constexpr error_set()
#ifndef DOXYGEN
        noexcept(std::is_nothrow_default_constructible_v<variant<T...>>)
        requires(std::is_default_constructible_v<variant<T...>>)
    = default;
#else
        CONDITIONALLY_NOEXCEPT;
#endif
 
    /// @brief Copy constructor
    ///
    /// @details
    /// A new @ref error_set is initialized such that it contains a copy
    /// constructed instance of the alternative contained in the source @ref
    /// error_set. If the source @ref error_set has more than one alternative of
    /// the same type, the new @ref error_set will contain the alternative of the
    /// same index.
    ///
    /// All alternative types *must* be copy constructible for this constructor
    /// to participate in overload resolution.
    ///
    /// ## Example
    /// ```cpp
    /// error_set<error1, error2> e1{std::in_place_index<1>};
    ///
    /// error_set<error1, error2> e2{e1};
    ///
    /// assert(holds_alternative<error2>(e2));
    ///
    /// assert(e2.index() == 1);
    /// ```
    constexpr error_set(const error_set&)
#ifndef DOXYGEN
        noexcept(std::is_nothrow_copy_constructible_v<variant<T...>>)
        requires(std::is_copy_constructible_v<variant<T...>>)
    = default;
#else
        CONDITIONALLY_NOEXCEPT;
#endif
 
    /// @brief Move constructor
    ///
    /// @details
    /// A new @ref error_set is initialized such that it contains a move
    /// constructed instance of the alternative contained in the source @ref
    /// error_set. If the source @ref error_set has more than one alternative of
    /// the same type, the new @ref error_set will contain the alternative of the
    /// same index.
    ///
    /// All alternative types *must* be move constructible for this constructor
    /// to participate in overload resolution.
    ///
    /// The source @ref error_set will continue to contain an instance of the same
    /// alternative, but the value of the alternative after being moved depends
    /// on the move constructor of the type. In general, moved values are said
    /// to be in a valid, but unspecified, state.
    ///
    /// ## Example
    /// ```cpp
    /// error_set<error1, error2> e1{std::in_place_index<1>};
    ///
    /// error_set<error1, error2> e2{std::move(e1)};
    ///
    /// assert(holds_alternative<error2>(e2));
    ///
    /// assert(e2.index() == 1);
    /// ```
    constexpr error_set(error_set&&)
#ifndef DOXYGEN
        noexcept(std::is_nothrow_move_constructible_v<variant<T...>>)
        requires(std::is_move_constructible_v<variant<T...>>)
    = default;
#else
        CONDITIONALLY_NOEXCEPT;
#endif
 
    /// @brief Index emplacement constructor
    ///
    /// @details
    /// A new @ref error_set is initialized such that it contains a newly
    /// constructed instance of the alternative with the specified index.
    /// The arguments following `inplace` are forwarded directly to the
    /// constructor of the alternative type.
    ///
    /// Given that `U` is the type of the alternative at the specified index,
    /// this constructor is always valid as long as `U` is constructible with
    /// the arguments, `std::forward<Args>(args)...`.
    ///
    /// ## Example
    /// ```cpp
    /// error_set<error, std::string> e{std::in_place_index<1>, 5, 'a'};
    ///
    /// assert(holds_alternative<std::string>(e));
    ///
    /// assert(e.index() == 1);
    ///
    /// assert(get<1>(e) == "aaaaa");
    /// ```
    ///
    /// @param inplace Constructor tag that specifies the alternative index.
    /// @param args Arguments used to construct the alternative.
    template <size_t IDX, typename... Args>
#ifndef DOXYGEN
    explicit(sizeof...(Args) == 0)
#else
    CONDITIONALLY_EXPLICIT
#endif
        // NOLINTNEXTLINE(hicpp-explicit-conversions)
        constexpr error_set(std::in_place_index_t<IDX> inplace, Args&&... args)
        : variant<T...>(inplace, std::forward<Args>(args)...) {
    }
 
    /// @brief Index emplacement constructor with `std::initializer_list`
    ///
    /// @details
    /// A new @ref error_set is initialized such that it contains a newly
    /// constructed instance of the alternative with the specified index.
    /// The arguments following `inplace` are forwarded directly to the
    /// constructor of the alternative type.
    ///
    /// Given that `U` is the type of the alternative at the specified index,
    /// this constructor is always valid as long as `U` is constructible with
    /// the arguments, `init, std::forward<Args>(args)...`.
    ///
    /// ## Example
    /// ```cpp
    /// error_set<error, std::vector<int>> e{
    ///         std::in_place_index<1>,
    ///         {1, 2, 3, 4, 5}};
    ///
    /// assert(holds_alternative<std::vector<int>>(e));
    ///
    /// assert(e.index() == 1);
    ///
    /// assert(get<1>(e).size() == 5);
    /// ```
    ///
    /// @param inplace Constructor tag that specifies the alternative index.
    /// @param init Initializer list forwarded to the alternative constructor
    /// @param args Additional arguments used to construct the alternative.
    template <size_t IDX, typename U, typename... Args>
    constexpr error_set(std::in_place_index_t<IDX> inplace,
                        std::initializer_list<U> init,
                        Args&&... args)
        : variant<T...>(inplace, init, std::forward<Args>(args)...) {}
 
    /// @brief Type emplacement constructor
    ///
    /// @details
    /// A new @ref error_set is initialized such that it contains a newly
    /// constructed instance of the alternative with the specified type.
    /// The arguments following `inplace` are forwarded directory to the
    /// constructor of the alternative type.
    ///
    /// ## Example
    /// ```cpp
    /// error_set<error, std::string> e{
    ///         std::in_place_type<std::string>,
    ///         5, 'a'};
    ///
    /// assert(holds_alternative<std::string>(e));
    ///
    /// assert(e.index() == 1);
    ///
    /// assert(get<1>(e) == "aaaaa");
    /// ```
    template <typename U, typename... Args>
#ifndef DOXYGEN
    explicit(sizeof...(Args) == 0)
#else
    CONDITIONALLY_EXPLICIT
#endif
        // NOLINTNEXTLINE(hicpp-explicit-conversions)
        constexpr error_set([[maybe_unused]] std::in_place_type_t<U> inplace,
                            Args&&... args)
        : variant<T...>(inplace, std::forward<Args>(args)...) {
    }
 
    /// @brief Type emplacement constructor with `std::initializer_list`
    ///
    /// @details
    /// A new @ref error_set is initialized such that it contains a newly
    /// constructed instance of the alternative with the specified type.
    /// The arguments following `inplace` are forwarded directory to the
    /// constructor of the alternative type.
    ///
    /// ## Example
    /// ```cpp
    /// error_set<error, std::vector<int>> e{
    ///         std::in_place_type<std::vector<int>>,
    ///         {1, 2, 3, 4, 5}};
    ///
    /// assert(holds_alternative<std::vector<int>>(e));
    ///
    /// assert(e.index() == 1);
    ///
    /// assert(get<1>(e).size() == 5);
    /// ```
    template <typename U, typename V, typename... Args>
    constexpr error_set([[maybe_unused]] std::in_place_type_t<U> inplace,
                        std::initializer_list<V> init,
                        Args&&... args)
        : variant<T...>(inplace, init, std::forward<Args>(args)...) {}
 
    /// @brief Forwarding constructor
    ///
    /// @details
    /// A new @ref error_set is initialized such that an alternative is
    /// constructed in place with the provided value as the constructor
    /// argument.
    ///
    /// To avoid ambiguity to the reader, this constructor only participates
    /// in overload resolution when there is only one alternative that could
    /// possibly be constructed from the value.
    ///
    /// This constructor is `explicit` if the value is not implicitly
    /// convertible to the target alternative type.
    ///
    /// ## Example
    /// ```cpp
    /// error_set<error, std::string> e{"oh no"};
    ///
    /// assert(e.index() == 1);
    ///
    /// assert(get<1>(e) == "oh no");
    /// ```
    ///
    /// @param value The value that is used to construct the alternative
    template <typename U>
#ifndef DOXYGEN
        requires(!detail::is_error_set_v<std::remove_cvref_t<U>> &&
                 detail::is_uniquely_constructible_v<U, T...>)
    explicit(detail::is_uniquely_explicitly_constructible_v<U, T...>)
#else
    CONDITIONALLY_EXPLICIT
#endif
        // NOLINTNEXTLINE(hicpp-explicit-conversions)
        constexpr error_set(U&& value)
        : variant<T...>(std::forward<U>(value)) {
    }
 
    /// @brief Forwarding constructor with initializer list
    ///
    /// @details
    /// A new @ref error_set is initialized such that an alternative is
    /// constructed in place with the provided `std::initializer_list`
    /// as the constructor argument.
    ///
    /// To avoid ambiguity to the reader, this constructor only participates
    /// in overload resulotion when there is only one alternative that could
    /// possible be constructed from the initializer list.
    ///
    /// This constructor is `explicit` if the `std::initializer_list` is not
    /// implicitly convertible to the target alternative type.
    ///
    /// ## Example
    /// ```cpp
    /// error_set<error, std::vector<int>> e({1, 2, 3, 4, 5});
    ///
    /// assert(e.index() == 1);
    ///
    /// assert(get<1>(e).size() == 5);
    /// ```
    ///
    /// @param init The `std::initializer_list` that is used to construct the
    /// alternative
    template <typename U>
#ifndef DOXYGEN
        requires(detail::is_uniquely_constructible_v<std::initializer_list<U>, T...>)
    explicit(detail::is_uniquely_explicitly_constructible_v<std::initializer_list<U>, T...>)
#else
    CONDITIONALLY_EXPLICIT
#endif
        constexpr error_set(std::initializer_list<U> init)
        : variant<T...>(init) {
    }
 
    /// @brief Copy conversion constructor
    ///
    /// @details
    /// A new @ref error_set is initialized from the value contained in another
    /// @ref error_set that is a non-strict subset of the destination @ref
    /// error_set. Each of the alternative types in the source @ref error_set
    /// must also be an alternative type in the destination @ref error_set, but
    /// they need not have the same index.
    ///
    /// This constructor allows for values of @ref error_set to be easily
    /// propagated, whether returned directly, or as an alternative of any
    /// other sum type. Most commonly, this will be used to implicitly convert
    /// from a @ref result to another result with a superset of the errors as
    /// the source, such as when returning from a function.
    ///
    /// ## Example
    /// ```
    /// const error_set<error1, error2> e1{std::in_place_index<1>};
    ///
    /// const error_set<error2, error3, error1> e2{e1};
    ///
    /// assert(holds_alternative<error2>(e2));
    ///
    /// assert(e2.index() == 0);
    /// ```
    template <typename... U>
#ifndef DOXYGEN
        requires(!std::is_same_v<error_set<U...>, error_set<T...>> &&
                 detail::is_subset_of_impl_v<error_set<U...>, error_set<T...>>)
#endif
    // NOLINTNEXTLINE(hicpp-explicit-conversions)
    constexpr error_set(const error_set<U...>& other) : variant<T...>(detail::uninit) {
        other.set_().visit_informed([this](const auto& value, auto info) {
            set_()
                .template uninit_emplace<
                    detail::index_of_v<typename decltype(info)::type, T...>>(value);
        });
    }
 
    /// @brief Move conversion constructor
    ///
    /// @details
    /// A new @ref error_set is initialized from the value contained in another
    /// @ref error_set that is a non-strict subset of the destination @ref
    /// error_set. Each of the alternative types in the source @ref error_set
    /// must also be an alternative type in the destination @ref error_set, but
    /// they need not have the same index.
    ///
    /// This constructor allows for values of @ref error_set to be easily
    /// propagated, whether returned directly, or as an alternative of any
    /// other sum type. Most commonly, this will be used to implicitly convert
    /// from a @ref result to another result with a superset of the errors as
    /// the source, such as when returning from a function.
    ///
    /// ## Example
    /// ```
    /// error_set<error1, error2> e1{std::in_place_index<1>};
    ///
    /// error_set<error2, error3, error1> e2{std::move(e1)};
    ///
    /// assert(holds_alternative<error2>(e2));
    ///
    /// assert(e2.index() == 0);
    /// ```
    template <typename... U>
#ifndef DOXYGEN
        requires(!std::is_same_v<error_set<U...>, error_set<T...>> &&
                 detail::is_subset_of_impl_v<error_set<U...>, error_set<T...>>)
#endif
    // clang-format off
    // NOLINTNEXTLINE(hicpp-explicit-conversions,cppcoreguidelines-rvalue-reference-param-not-moved)
    constexpr error_set(error_set<U...>&& other) : variant<T...>(detail::uninit) {
        // clang-format on
        std::move(other.set_()).visit_informed([this](auto&& value, auto info) {
            set_()
                .template uninit_emplace<
                    detail::index_of_v<typename decltype(info)::type, T...>>(
                    info.forward(value));
        });
    }
 
    /// @brief Destructor
    ///
    /// @details
    /// The contained alternative of the @ref error_set will is destroyed in
    /// place.
    ///
    /// The destructor is `noexcept` if all alternative types are nothrow
    /// destructible.
    constexpr ~error_set()
#ifndef DOXYGEN
        noexcept(std::is_nothrow_destructible_v<variant<T...>>) = default;
#else
        CONDITIONALLY_NOEXCEPT;
#endif
 
    /// @brief Copy assignment operator
    ///
    /// @details
    /// Copy assignment of an @ref error_set can take one of two possible code
    /// paths.
    ///
    /// If the source and destination @ref error_set hold the same alternative
    /// (same index), the alternative value is copied via copy assignment.
    ///
    /// Otherwise, if the source and destination hold different alternatives
    /// (different indices, but possibly the same type), the alternative of
    /// the destination @ref error_set is destroyed in place, and the new
    /// alternative is copy constructed.
    ///
    /// All alternatives *must* be both copy assignable and copy constructible
    /// for this function to participate in overload resolution.
    ///
    /// ## Example
    /// ```cpp
    /// error_set<error1, error2> e1{std::in_place_index<0>};
    ///
    /// variant<error2, error2> e2{std::in_place_index<1>};
    ///
    /// e1 = e2;
    ///
    /// assert(holds_alternative<error2>(e1));
    ///
    /// assert(e1.index() == 1);
    /// ```
    constexpr error_set& operator=(const error_set&)
#ifndef DOXYGEN
        noexcept(std::is_nothrow_copy_assignable_v<variant<T...>>)
        requires(std::is_copy_assignable_v<variant<T...>>)
    = default;
#else
        CONDITIONALLY_NOEXCEPT;
#endif
 
    /// @brief Move assignment operator
    ///
    /// @details
    /// Move assignment of an @ref error_set can take one of two possible code
    /// paths.
    ///
    /// If the source and destination @ref error_set hold the same alternative
    /// (same index), the alternative value is moved from the source to the
    /// destination via move assignment.
    ///
    /// Otherwise, if the source and destination hold different alternatives
    /// (different indices, but possibly the same type), the alternative of the
    /// destination @ref error_set is destroyed in place, and the new alternative
    /// is move constructed.
    ///
    /// The source @ref error_set will still contain the same alternative, but
    /// the value of the alternative depends on the move assignment or move
    /// constructor of the alternative's type. In general, moved values are
    /// said to be in a valid, but unspecified, state.
    ///
    /// All alternatives *must* be both move assignable and move constructible
    /// for this function to participate in overload resolution.
    ///
    /// ## Example
    /// ```cpp
    /// error_set<error1, error2> e1{std::in_place_index<0>};
    ///
    /// error_set<error1, error2> e2{std::in_place_index<1>};
    ///
    /// e1 = std::move(e2);
    ///
    /// assert(holds_alternative<error2>(e1));
    ///
    /// assert(e1.index() == 1);
    /// ```
    constexpr error_set& operator=(error_set&&)
#ifndef DOXYGEN
        noexcept(std::is_nothrow_move_assignable_v<variant<T...>>)
        requires(std::is_move_assignable_v<variant<T...>>)
    = default;
#else
        CONDITIONALLY_NOEXCEPT;
#endif
 
    /// @brief Forwarding assignment operator
    ///
    /// @details
    /// This function assigns a value directly to an alternative. If the @ref
    /// error_set already contains the target alternative, the value is assigned
    /// using the alternative type's assignemnt operator. Otherwise, the target
    /// alternative is constructed with the value.
    ///
    /// To avoid ambiguity to the reader, this function only participates in
    /// overload resolution when there is only one alternative that could
    /// possibly be assigned from the value.
    ///
    /// ## Example
    /// ```cpp
    /// error_set<error1, error2> e{};
    ///
    /// e = error2{};
    ///
    /// assert(holds_alternative<error2>(e));
    ///
    /// assert(e.index() == 1);
    /// ```
    ///
    /// @param rhs The value to be assigned to the alternative
    template <typename U>
#ifndef DOXYGEN
        requires(!detail::is_error_set_v<std::remove_cvref_t<U>> &&
                 detail::is_uniquely_assignable_v<U, T...>)
#endif
    constexpr error_set& operator=(U&& rhs) {
        set_() = std::forward<U>(rhs);
        return *this;
    }
 
    /// @brief Forwarding assignment operator with initializer list
    ///
    /// @details
    /// This function assigns a `std::initializer_list` directoy to an
    /// alternative. If the @ref error_set already contains the target
    /// alternative, the `std::initializer_list` is assigned uting the
    /// alternative type's assignment operator. Otherwise, the target
    /// alternative is constructed with the `std::initializer_list`.
    ///
    /// To avoid ambiguity to the reader, this function only participates in
    /// overload resolution when there is only one alternative that could
    /// possibly be assigned from the `std::initializer_list`.
    ///
    /// ## Example
    /// ```cpp
    /// variant<error, std::vector<int>> e{};
    ///
    /// e = {1, 2, 3, 4, 5};
    ///
    /// assert(holds_alternative<std::vector<int>>(e));
    ///
    /// assert(e.index() == 1);
    /// ```
    ///
    /// @param rhs The `std::initializer_list` to be assigned to the
    /// alternative
    template <typename U>
#ifndef DOXYGEN
        requires(detail::is_uniquely_assignable_v<std::initializer_list<U>, T...>)
#endif
    constexpr error_set& operator=(std::initializer_list<U> rhs) {
        set_() = rhs;
        return *this;
    }
 
    /// @brief Copy conversion assignment operator
    ///
    /// @details
    /// This function assigns the value contained in another
    /// @ref error_set that is a non-strict subset of the destination @ref
    /// error_set. Each of the alternative types in the source @ref error_set
    /// must also be an alternative type in the destination @ref error_set, but
    /// they need not have the same index.
    ///
    /// ## Example
    /// ```
    /// const error_set<error1, error2> e1{std::in_place_index<1>};
    ///
    /// error_set<error2, error3, error1> e2{};
    ///
    /// e2 = e1;
    ///
    /// assert(holds_alternative<error2>(e2));
    ///
    /// assert(e2.index() == 0);
    /// ```
    template <typename... U>
#ifndef DOXYGEN
        requires(!std::is_same_v<error_set<U...>, error_set<T...>> &&
                 detail::is_subset_of_impl_v<error_set<U...>, error_set<T...>>)
#endif
    constexpr error_set& operator=(const error_set<U...>& rhs) {
        rhs.set_().visit_informed([this](auto&& value, auto info) {
            set_()
                .template emplace<detail::index_of_v<typename decltype(info)::type, T...>>(
                    value);
        });
        return *this;
    }
 
    /// @brief Move conversion assignment operator
    ///
    /// @details
    /// This function assigns the value contained in another
    /// @ref error_set that is a non-strict subset of the destination @ref
    /// error_set. Each of the alternative types in the source @ref error_set
    /// must also be an alternative type in the destination @ref error_set, but
    /// they need not have the same index.
    ///
    /// ## Example
    /// ```
    /// error_set<error1, error2> e1{std::in_place_index<1>};
    ///
    /// error_set<error2, error3, error1> e2{};
    ///
    /// e2 = std::move(e1);
    ///
    /// assert(holds_alternative<error2>(e2));
    ///
    /// assert(e2.index() == 0);
    /// ```
    template <typename... U>
#ifndef DOXYGEN
        requires(!std::is_same_v<error_set<U...>, error_set<T...>> &&
                 detail::is_subset_of_impl_v<error_set<U...>, error_set<T...>>)
#endif
    // NOLINTNEXTLINE(cppcoreguidelines-rvalue-reference-param-not-moved)
    constexpr error_set& operator=(error_set<U...>&& rhs) {
        std::move(rhs.set_()).visit_informed([this](auto&& value, auto info) {
            set_()
                .template emplace<detail::index_of_v<typename decltype(info)::type, T...>>(
                    info.forward(value));
        });
        return *this;
    }
 
    /// @brief Gets the index of the contained alternative
    ///
    /// @details
    /// The set of alternatives of a @ref error_set has a zero-based index based
    /// on the order in which they are specified in the @ref error_set template
    /// arguments.
    ///
    /// This index is the normalized discriminant of the @ref error_set. The
    /// discriminant may be represented differently internally, depending on
    /// the alternative types, so this function normalizes the discriminant by
    /// converting it to a zero-based index in order to provide a common
    /// interface for all @ref error_set instantiations.
    ///
    /// ## Example
    /// ```cpp
    /// error_set<error1, error2, error3, error4> e{std::in_place_index<2>};
    ///
    /// assert(e.index() == 2);
    /// ```
    ///
    /// @return The index of the contained alternative.
    [[nodiscard]] constexpr size_t index() const noexcept { return set_().index(); }
 
    /// @brief Constructs a new alternative in place by index
    ///
    /// @details
    /// This function destroys the alternative that the @ref error_set contains
    /// before the call, and constructs a new alternative with the specified
    /// index in place.
    ///
    /// ## Example
    /// ```cpp
    /// error_set<error, std::string> e;
    ///
    /// e.emplace<1>(5, 'a');
    ///
    /// assert(holds_alternative<std::string>(e));
    ///
    /// assert(e.index() == 1);
    ///
    /// assert(get<1>(e) == "aaaaa");
    /// ```
    ///
    /// @param args Constructor arguments forwarded to the new alternative
    /// @return A reference to the new alternative, if applicable
    template <size_t I, typename... Args>
    constexpr
#ifndef DOXYGEN
        typename detail::traits<detail::select_t<I, T...>>::reference
#else
        REFERENCE
#endif
        emplace(Args&&... args) {
        return set_().template emplace<I>(std::forward<Args>(args)...);
    }
 
    /// @brief Constructs a new alternative in place by index
    ///
    /// @details
    /// This function destroys the alternative that the @ref error_set contains
    /// before the call, and constructs a new alternative with the specified
    /// index in place.
    ///
    /// ## Example
    /// ```cpp
    /// error_set<error, std::vector<int>> e;
    ///
    /// e.emplace<1>({1, 2, 3, 4, 5});
    ///
    /// assert(holds_alternative<std::vector<int>>(e));
    ///
    /// assert(e.index() == 1);
    ///
    /// assert(get<1>(e).size() == 5);
    /// ```
    ///
    /// @param ilist Initializer list forward to the new alternative
    /// @param args Constructor arguments forwarded to the new alternative
    /// @return A reference to the new alternative, if applicable
    template <size_t I, typename U, typename... Args>
    constexpr
#ifndef DOXYGEN
        typename detail::traits<detail::select_t<I, T...>>::reference
#else
        REFERENCE
#endif
        emplace(std::initializer_list<U> ilist, Args&&... args) {
        return set_().template emplace<I>(ilist, std::forward<Args>(args)...);
    }
 
    /// @brief Constructs a new alternative in place by type
    ///
    /// @details
    /// This function destroy the alternative that the @ref error_set contains
    /// before the call, and constructs a new alternative with the specified
    /// type in place.
    ///
    /// ## Example
    /// ```cpp
    /// error_set<error, std::string> e;
    ///
    /// e.emplace<std::string>(5, 'a');
    ///
    /// assert(holds_alternative<std::string>(e));
    ///
    /// assert(e.index() == 1);
    ///
    /// assert(get<1>(e) == "aaaaa");
    /// ```
    ///
    /// @param args Constructor arguments forwarded to the new alternative
    /// @return A reference to the new alternative, if applicable
    template <typename U, typename... Args>
    constexpr
#ifndef DOXYGEN
        typename detail::traits<U>::reference
#else
        REFERENCE
#endif
        emplace(Args&&... args) {
        return set_().template emplace<U>(std::forward<Args>(args)...);
    }
 
    /// @brief Constructs a new alternative in place by type
    ///
    /// @details
    /// This function destroy the alternative that the @ref error_set contains
    /// before the call, and constructs a new alternative with the specified
    /// type in place.
    ///
    /// ## Example
    /// ```cpp
    /// error_set<error, std::vector<int>> e;
    ///
    /// e.emplace<std::vector<int>>({1, 2, 3, 4, 5});
    ///
    /// assert(holds_alternative<std::vector<int>>(e));
    ///
    /// assert(e.index() == 1);
    ///
    /// assert(get<1>(e).size() == 5);
    /// ```
    ///
    /// @param ilist Initializer list forward to the new alternative
    /// @param args Constructor arguments forwarded to the new alternative
    /// @return A reference to the new alternative, if applicable
    template <typename U, typename V, typename... Args>
    constexpr
#ifndef DOXYGEN
        typename detail::traits<U>::reference
#else
        REFERENCE
#endif
        emplace(std::initializer_list<V> ilist, Args&&... args) {
        return set_().template emplace<U>(ilist, std::forward<Args>(args)...);
    }
 
    /// @brief Alternative access operator by index
    ///
    /// @details
    /// This function allows accessing alternatives by index using the square
    /// bracket operator. Because the index must be a compile time value,
    /// instead of passing the index directly, the index is provided as an
    /// instance of @ref index_t.
    ///
    /// This operator is unchecked and does not throw an exception. Passing an
    /// index that does not correspond to the currently contained alternative
    /// results in undefined behavior.
    ///
    /// ## Example
    /// ```cpp
    /// error_set<error1, std::string, error2> e{std::in_place_index<1>, "oh no"};
    ///
    /// assert(e[index<1>] == "oh no");
    ///
    /// v[index<1>] = "no problem";
    ///
    /// assert(get<1>(v) == "no problem");
    /// ```
    ///
    /// @param index A tag value that communicates a compile time index
    /// @return A reference to the accessed alternative, if applicable
    template <size_t I>
    [[nodiscard]] constexpr
#ifndef DOXYGEN
        typename detail::traits<detail::select_t<I, T...>>::reference
#else
        REFERENCE
#endif
        operator[]([[maybe_unused]] index_t<I> index) & noexcept {
        return set_()[index];
    }
 
    /// @brief Alternative access operator by index
    ///
    /// @details
    /// This function allows accessing alternatives by index using the square
    /// bracket operator. Because the index must be a compile time value,
    /// instead of passing the index directly, the index is provided as an
    /// instance of @ref index_t.
    ///
    /// This operator is unchecked and does not throw an exception. Passing an
    /// index that does not correspond to the currently contained alternative
    /// results in undefined behavior.
    ///
    /// ## Example
    /// ```cpp
    /// const error_set<error1, std::string, error2> e{
    ///         std::in_place_index<1>, "oh no"};
    ///
    /// assert(e[index<1>] == "oh no");
    /// ```
    ///
    /// @param index A tag value that communicates a compile time index
    /// @return A reference to the accessed alternative, if applicable
    template <size_t I>
    [[nodiscard]] constexpr
#ifndef DOXYGEN
        typename detail::traits<detail::select_t<I, T...>>::const_reference
#else
        CONST_REFERENCE
#endif
        operator[]([[maybe_unused]] index_t<I> index) const& noexcept {
        return set_()[index];
    }
 
    /// @brief Alternative access operator by index
    ///
    /// @details
    /// This function allows accessing alternatives by index using the square
    /// bracket operator. Because the index must be a compile time value,
    /// instead of passing the index directly, the index is provided as an
    /// instance of @ref index_t.
    ///
    /// This operator is unchecked and does not throw an exception. Passing an
    /// index that does not correspond to the currently contained alternative
    /// results in undefined behavior.
    ///
    /// ## Example
    /// ```cpp
    /// error_set<error1, std::string, error2> e{std::in_place_index<1>, "oh no"};
    ///
    /// assert(std::move(e)[index<1>] == "oh no");
    /// ```
    ///
    /// @param index A tag value that communicates a compile time index
    /// @return A reference to the accessed alternative, if applicable
    template <size_t I>
    [[nodiscard]] constexpr
#ifndef DOXYGEN
        typename detail::traits<detail::select_t<I, T...>>::rvalue_reference
#else
        RVALUE_REFERENCE
#endif
        operator[]([[maybe_unused]] index_t<I> index) && {
        return std::move(set_())[index];
    }
 
    /// @brief Alternative access operator by index
    ///
    /// @details
    /// This function allows accessing alternatives by index using the square
    /// bracket operator. Because the index must be a compile time value,
    /// instead of passing the index directly, the index is provided as an
    /// instance of @ref index_t.
    ///
    /// This operator is unchecked and does not throw an exception. Passing an
    /// index that does not correspond to the currently contained alternative
    /// results in undefined behavior.
    ///
    /// ## Example
    /// ```cpp
    /// const error_set<error1, std::string, error2> e{
    ///         std::in_place_index<1>, "oh no"};
    ///
    /// assert(std::move(e)[index<1>] == "oh no");
    /// ```
    ///
    /// @param index A tag value that communicates a compile time index
    /// @return A reference to the accessed alternative, if applicable
    template <size_t I>
    [[nodiscard]] constexpr
#ifndef DOXYGEN
        typename detail::traits<detail::select_t<I, T...>>::const_rvalue_reference
#else
        CONST_RVALUE_REFERENCE
#endif
        operator[]([[maybe_unused]] index_t<I> index) const&& {
        return std::move(set_())[index];
    }
 
    /// @brief Alternative access operator by type
    ///
    /// @details
    /// This function allows accessing alternatives by type using the square
    /// bracket operator. Because the index must be a compile time value,
    /// the index is provided as an instance of @ref type_t.
    ///
    /// This operator is unchecked and does not throw an exception. Passing an
    /// index that does not correspond to the currently contained alternative
    /// results in undefined behavior.
    ///
    /// ## Example
    /// ```cpp
    /// error_set<error1, std::string, error2> e{
    ///         std::in_place_index<1>, "oh no"};
    ///
    /// assert(e[type<std::string>] == "oh no");
    ///
    /// v[type<std::string>] = "no problem";
    ///
    /// assert(get<std::string>(v) == "no problem");
    /// ```
    ///
    /// @param index A tag value that communicates a compile time index
    /// @return The accessed alternative value, if applicable
    template <typename U>
    [[nodiscard]] constexpr
#ifndef DOXYGEN
        typename detail::traits<U>::reference
#else
        REFERENCE
#endif
        operator[]([[maybe_unused]] type_t<U> type) & noexcept {
        return set_()[type];
    }
 
    /// @brief Alternative access operator by type
    ///
    /// @details
    /// This function allows accessing alternatives by type using the square
    /// bracket operator. Because the index must be a compile time value,
    /// the index is provided as an instance of @ref type_t.
    ///
    /// This operator is unchecked and does not throw an exception. Passing an
    /// index that does not correspond to the currently contained alternative
    /// results in undefined behavior.
    ///
    /// ## Example
    /// ```cpp
    /// const error_set<error1, std::string, error2> e{
    ///         std::in_place_index<1>, "oh no"};
    ///
    /// assert(e[type<std::string>] == "oh no");
    /// ```
    ///
    /// @param index A tag value that communicates a compile time index
    /// @return The accessed alternative value, if applicable
    template <typename U>
    [[nodiscard]] constexpr
#ifndef DOXYGEN
        typename detail::traits<U>::const_reference
#else
        CONST_REFERENCE
#endif
        operator[]([[maybe_unused]] type_t<U> type) const& noexcept {
        return set_()[type];
    }
 
    /// @brief Alternative access operator by type
    ///
    /// @details
    /// This function allows accessing alternatives by type using the square
    /// bracket operator. Because the index must be a compile time value,
    /// the index is provided as an instance of @ref type_t.
    ///
    /// This operator is unchecked and does not throw an exception. Passing an
    /// index that does not correspond to the currently contained alternative
    /// results in undefined behavior.
    ///
    /// ## Example
    /// ```cpp
    /// error_set<error1, std::string, error2> e{
    ///         std::in_place_index<1>, "oh no"};
    ///
    /// assert(std::move(e)[type<std::string>] == "oh no");
    /// ```
    ///
    /// @param index A tag value that communicates a compile time index
    /// @return The accessed alternative value, if applicable
    template <typename U>
    [[nodiscard]] constexpr
#ifndef DOXYGEN
        typename detail::traits<U>::rvalue_reference
#else
        RVALUE_REFERENCE
#endif
        operator[]([[maybe_unused]] type_t<U> type) && {
        return std::move(set_())[type];
    }
 
    /// @brief Alternative access operator by type
    ///
    /// @details
    /// This function allows accessing alternatives by type using the square
    /// bracket operator. Because the index must be a compile time value,
    /// the index is provided as an instance of @ref type_t.
    ///
    /// This operator is unchecked and does not throw an exception. Passing an
    /// index that does not correspond to the currently contained alternative
    /// results in undefined behavior.
    ///
    /// ## Example
    /// ```cpp
    /// const error_set<error1, std::string, error2> e{
    ///         std::in_place_index<1>, "oh no"};
    ///
    /// assert(std::move(e)[type<std::string>] == "oh no");
    /// ```
    ///
    /// @param index A tag value that communicates a compile time index
    /// @return The accessed alternative value, if applicable
    template <typename U>
    [[nodiscard]] constexpr
#ifndef DOXYGEN
        typename detail::traits<U>::const_rvalue_reference
#else
        CONST_RVALUE_REFERENCE
#endif
        operator[]([[maybe_unused]] type_t<U> type) const&& {
        return std::move(set_())[type];
    }
 
    /// @brief Gets an alternative by index
    ///
    /// @details
    /// This function allows accessing alternatives by index, which is provided
    /// as a template argument.
    ///
    /// ## Example
    /// ```cpp
    /// error_set<error1, std::string, error2> e{
    ///         std::in_place_index<1>, "oh no"};
    ///
    /// assert(e.get<1>() == "oh no");
    ///
    /// e.get<1>() = "no problem";
    ///
    /// assert(e.get<1>() == "no problem");
    /// ```
    ///
    /// @tparam I The index of the alternative to access.
    ///
    /// @return A reference to the accessed alternative, if applicable.
    ///
    /// @throws bad_variant_access Thrown if the @ref error_set does not contain
    /// the alternative with the corresponding index.
    template <size_t I>
    [[nodiscard]] constexpr
#ifndef DOXYGEN
        typename detail::traits<detail::select_t<I, T...>>::reference
#else
        REFERENCE
#endif
        get() & {
        return set_().template get<I>();
    }
 
    /// @brief Gets an alternative by index
    ///
    /// @details
    /// This function allows accessing alternatives by index, which is provided
    /// as a template argument.
    ///
    /// ## Example
    /// ```cpp
    /// const error_set<error1, std::string, error2> e{
    ///         std::in_place_index<1>, "oh no"};
    ///
    /// assert(e.get<1>() == "oh no");
    /// ```
    ///
    /// @tparam I The index of the alternative to access.
    ///
    /// @return A const reference to the accessed alternative, if applicable.
    ///
    /// @throws bad_variant_access Thrown if the @ref error_set does not contain
    /// the alternative with the corresponding index.
    template <size_t I>
    [[nodiscard]] constexpr
#ifndef DOXYGEN
        typename detail::traits<detail::select_t<I, T...>>::const_reference
#else
        CONST_REFERENCE
#endif
        get() const& {
        return set_().template get<I>();
    }
 
    /// @brief Gets an alternative by index
    ///
    /// @details
    /// This function allows accessing alternatives by index, which is provided
    /// as a template argument.
    ///
    /// ## Example
    /// ```cpp
    /// error_set<error1, std::string, error2> e{
    ///         std::in_place_index<1>, "oh no"};
    ///
    /// assert(std::move(e).get<1>() == "oh no");
    /// ```
    ///
    /// @tparam I The index of the alternative to access.
    ///
    /// @return An rvalue reference to the accessed alternative, if applicable.
    ///
    /// @throws bad_variant_access Thrown if the @ref error_set does not contain
    /// the alternative with the corresponding index.
    template <size_t I>
    [[nodiscard]] constexpr
#ifndef DOXYGEN
        typename detail::traits<detail::select_t<I, T...>>::rvalue_reference
#else
        RVALUE_REFERENCE
#endif
        get() && {
        return std::move(set_()).template get<I>();
    }
 
    /// @brief Gets an alternative by index
    ///
    /// @details
    /// This function allows accessing alternatives by index, which is provided
    /// as a template argument.
    ///
    /// ## Example
    /// ```cpp
    /// const error_set<error1, std::string, error2> e{
    ///         std::in_place_index<1>, "oh no"};
    ///
    /// assert(std::move(e).get<1>() == "oh no");
    /// ```
    ///
    /// @tparam I The index of the alternative to access.
    ///
    /// @return A const rvalue reference to the accessed alternative, if applicable.
    ///
    /// @throws bad_variant_access Thrown if the @ref error_set does not contain
    /// the alternative with the corresponding index.
    template <size_t I>
    [[nodiscard]] constexpr
#ifndef DOXYGEN
        typename detail::traits<detail::select_t<I, T...>>::const_rvalue_reference
#else
        CONST_RVALUE_REFERENCE
#endif
        get() const&& {
        return std::move(set_()).template get<I>();
    }
 
    /// @brief Gets an alternative by type
    ///
    /// @details
    /// This function allows accessing alternatives by type, which is provided
    /// as a template argument.
    ///
    /// ## Example
    /// ```cpp
    /// error_set<error1, std::string, error2> e{
    ///         std::in_place_index<1>, "oh no"};
    ///
    /// assert(e.get<std::string>() == "oh no");
    ///
    /// e.get<std::string>() = "no problem";
    ///
    /// assert(e.get<std::string>() == "no problem");
    /// ```
    ///
    /// @tparam U The type of the alternative to access.
    ///
    /// @return A reference to the accessed alternative, if applicable.
    ///
    /// @throws bad_variant_access Thrown if the @ref error_set does not contain
    /// the alternative with the corresponding type.
    template <typename U>
    [[nodiscard]] constexpr
#ifndef DOXYGEN
        typename detail::traits<U>::reference
#else
        REFERENCE
#endif
        get() & {
        return set_().template get<U>();
    }
 
    /// @brief Gets an alternative by type
    ///
    /// @details
    /// This function allows accessing alternatives by type, which is provided
    /// as a template argument.
    ///
    /// ## Example
    /// ```cpp
    /// const error_set<error1, std::string, error2> e{
    ///         std::in_place_index<1>, "oh no"};
    ///
    /// assert(e.get<std::string>() == "oh no");
    /// ```
    ///
    /// @tparam U The type of the alternative to access.
    ///
    /// @return A const reference to the accessed alternative, if applicable.
    ///
    /// @throws bad_variant_access Thrown if the @ref error_set does not contain
    /// the alternative with the corresponding type.
    template <typename U>
    [[nodiscard]] constexpr
#ifndef DOXYGEN
        typename detail::traits<U>::const_reference
#else
        CONST_REFERENCE
#endif
        get() const& {
        return set_().template get<U>();
    }
 
    /// @brief Gets an alternative by type
    ///
    /// @details
    /// This function allows accessing alternatives by type, which is provided
    /// as a template argument.
    ///
    /// ## Example
    /// ```cpp
    /// error_set<error1, std::string, error2> e{
    ///         std::in_place_index<1>, "oh no"};
    ///
    /// assert(std::move(e).get<std::string>() == "oh no");
    /// ```
    ///
    /// @tparam U The type of the alternative to access.
    ///
    /// @return An rvalue reference to the accessed alternative, if applicable.
    ///
    /// @throws bad_variant_access Thrown if the @ref error_set does not contain
    /// the alternative with the corresponding type.
    template <typename U>
    [[nodiscard]] constexpr
#ifndef DOXYGEN
        typename detail::traits<U>::rvalue_reference
#else
        RVALUE_REFERENCE
#endif
        get() && {
        return std::move(set_()).template get<U>();
    }
 
    /// @brief Gets an alternative by type
    ///
    /// @details
    /// This function allows accessing alternatives by type, which is provided
    /// as a template argument.
    ///
    /// ## Example
    /// ```cpp
    /// const error_set<error1, std::string, error2> e{
    ///         std::in_place_index<1>, "oh no"};
    ///
    /// assert(std::move(e).get<std::string>() == "oh no");
    /// ```
    ///
    /// @tparam U The type of the alternative to access.
    ///
    /// @return A const rvalue reference to the accessed alternative, if applicable.
    ///
    /// @throws bad_variant_access Thrown if the @ref error_set does not contain
    /// the alternative with the corresponding type.
    template <typename U>
    [[nodiscard]] constexpr
#ifndef DOXYGEN
        typename detail::traits<U>::const_rvalue_reference
#else
        CONST_RVALUE_REFERENCE
#endif
        get() const&& {
        return std::move(set_()).template get<U>();
    }
 
    /// @brief Gets an alternative pointer by index if the @ref error_set holds it
    ///
    /// @details
    /// This functions tries to access an alternative by index. If the @ref
    /// error_set contains the alternative, this function returns a pointer to
    /// the alternative, if applicable. If the @ref error_set does not contain
    /// the alternative, this function returns null. In the case where the
    /// alternative is of type `void`, this function does nothing.
    ///
    /// ## Example
    /// ```cpp
    /// error_set<error1, error2, error3> e{std::in_place_index<1>};
    ///
    /// assert(e.get_if<1>() != nullptr);
    ///
    /// assert(e.get_if<0>() == nullptr);
    /// ```
    ///
    /// @tparam I The index of the alternative to access.
    ///
    /// @return A pointer to the accessed alternative, if applicable, or null
    template <size_t I>
    [[nodiscard]] constexpr
#ifndef DOXYGEN
        typename detail::traits<detail::select_t<I, T...>>::pointer
#else
        POINTER
#endif
        get_if() noexcept {
        return set_().template get_if<I>();
    }
 
    /// @brief Gets an alternative pointer by index if the @ref error_set holds it
    ///
    /// @details
    /// This functions tries to access an alternative by index. If the @ref
    /// error_set contains the alternative, this function returns a pointer to
    /// the alternative, if applicable. If the @ref error_set does not contain
    /// the alternative, this function returns null. In the case where the
    /// alternative is of type `void`, this function does nothing.
    ///
    /// ## Example
    /// ```cpp
    /// const error_set<error1, error2, error3> e{std::in_place_index<1>};
    ///
    /// assert(e.get_if<1>() != nullptr);
    ///
    /// assert(e.get_if<0>() == nullptr);
    /// ```
    ///
    /// @tparam I The index of the alternative to access.
    ///
    /// @return A const pointer to the accessed alternative, if applicable, or null
    template <size_t I>
    [[nodiscard]] constexpr
#ifndef DOXYGEN
        typename detail::traits<detail::select_t<I, T...>>::const_pointer
#else
        CONST_POINTER
#endif
        get_if() const noexcept {
        return set_().template get_if<I>();
    }
 
    /// @brief Gets an alternative pointer by type if the @ref error_set holds it
    ///
    /// @details
    /// This functions tries to access an alternative by type. If the @ref
    /// error_set contains the alternative, this function returns a pointer to
    /// the alternative, if applicable. If the @ref error_set does not contain
    /// the alternative, this function returns null. In the case where the
    /// alternative is of type `void`, this function does nothing.
    ///
    /// ## Example
    /// ```cpp
    /// error_set<error1, error2, error3> e{std::in_place_index<1>};
    ///
    /// assert(e.get_if<error2>() != nullptr);
    ///
    /// assert(e.get_if<error1>() == nullptr);
    /// ```
    ///
    /// @tparam T The type of the alternative to access.
    ///
    /// @return A pointer to the accessed alternative, if applicable, or null
    template <typename U>
#ifndef DOXYGEN
        requires detail::is_unique_v<U, T...>
#endif
    [[nodiscard]] constexpr
#ifndef DOXYGEN
        typename detail::traits<U>::pointer
#else
        POINTER
#endif
        get_if() noexcept {
        return set_().template get_if<U>();
    }
 
    /// @brief Gets an alternative pointer by type if the @ref error_set holds it
    ///
    /// @details
    /// This functions tries to access an alternative by type. If the @ref
    /// error_set contains the alternative, this function returns a pointer to
    /// the alternative, if applicable. If the @ref error_set does not contain
    /// the alternative, this function returns null. In the case where the
    /// alternative is of type `void`, this function does nothing.
    ///
    /// ## Example
    /// ```cpp
    /// const error_set<error1, error2, error3> e{std::in_place_index<1>};
    ///
    /// assert(e.get_if<error2>() != nullptr);
    ///
    /// assert(e.get_if<error1>() == nullptr);
    /// ```
    ///
    /// @tparam T The type of the alternative to access.
    ///
    /// @return A const pointer to the accessed alternative, if applicable, or null
    template <typename U>
    [[nodiscard]] constexpr
#ifndef DOXYGEN
        typename detail::traits<U>::const_pointer
#else
        CONST_POINTER
#endif
        get_if() const noexcept {
        return set_().template get_if<U>();
    }
 
    /// @brief Checks if an @ref error_set contains a particular alternative.
    ///
    /// @details
    /// Given a type parameter, this function checks if the @ref error_set currently
    /// holds an alternative that has the exact same type.
    ///
    /// ## Example
    /// ```cpp
    /// error_set<error1, error2, error3> e1{std::in_place_index<0>};
    ///
    /// assert(e1.holds_alternative<error1>());
    ///
    /// error_set<error1, error2, error3> e2{std::in_place_index<2>};
    ///
    /// assert(e2.holds_alternative<error1>());
    /// ```
    ///
    /// @return `true` if the @ref error_set holds an alternative of the given type.
    template <typename U>
    [[nodiscard]] constexpr bool holds_alternative() const noexcept {
        return set_().template holds_alternative<U>();
    }
 
    /// @brief Calls a visitor callable with the contained alternative
    ///
    /// @details
    /// This function calls the visitor as `std::invoke(visitor, alternative)`
    /// and returns the result of that call, if any. As such, `visitor` *must*
    /// be able to accecpt any alternative type as an argument. In the case of
    /// an alternative of type `void`, the visitor must be callable as
    /// `std::invoke(visitor, void_v)`.
    ///
    /// Note that the @ref overload function can be helpful for defining a
    /// visitor inline.
    ///
    /// Also note that this function is implemented as a compile-time-defined
    /// jump table (array of function pointers). In performance critical
    /// applications, be wary of any assumptions about how well or poorly your
    /// compiler will optimize a call to this function.
    ///
    /// ## Example
    /// ```cpp
    /// error_set<error1, error2, error3> e1{std::in_place_index<1>};
    ///
    /// e1.visit(overload(
    ///     [](error1& e) { assert(false); },
    ///     [](error2& e) { assert(true); },
    ///     [](error3& e) { assert(false); }
    /// ));
    /// ```
    ///
    /// @param visitor The callable object that will be passed an alternative.
    /// @return The return value of the visitor, if any.
    template <typename V>
    constexpr
#ifndef DOXYGEN
        detail::invoke_result_t<
            V&&,
            typename detail::traits<detail::select_t<0, T...>>::reference>
#else
        DEDUCED
#endif
        visit(V&& visitor) & {
        return set_().visit(std::forward<V>(visitor));
    }
 
    /// @brief Calls a visitor callable with the contained alternative
    ///
    /// @details
    /// This function calls the visitor as `std::invoke(visitor, alternative)`
    /// and returns the result of that call, if any. As such, `visitor` *must*
    /// be able to accecpt any alternative type as an argument. In the case of
    /// an alternative of type `void`, the visitor must be callable as
    /// `std::invoke(visitor, void_v)`.
    ///
    /// Note that the @ref overload function can be helpful for defining a
    /// visitor inline.
    ///
    /// Also note that this function is implemented as a compile-time-defined
    /// jump table (array of function pointers). In performance critical
    /// applications, be wary of any assumptions about how well or poorly your
    /// compiler will optimize a call to this function.
    ///
    /// ## Example
    /// ```cpp
    /// const error_set<error1, error2, error3> e1{std::in_place_index<1>};
    ///
    /// e1.visit(overload(
    ///     [](const error1& e) { assert(false); },
    ///     [](const error2& e) { assert(true); },
    ///     [](const error3& e) { assert(false); }
    /// ));
    /// ```
    ///
    /// @param visitor The callable object that will be passed an alternative.
    /// @return The return value of the visitor, if any.
    template <typename V>
    constexpr
#ifndef DOXYGEN
        detail::invoke_result_t<
            V&&,
            typename detail::traits<detail::select_t<0, T...>>::const_reference>
#else
        DEDUCED
#endif
        visit(V&& visitor) const& {
        return set_().visit(std::forward<V>(visitor));
    }
 
    /// @brief Calls a visitor callable with the contained alternative
    ///
    /// @details
    /// This function calls the visitor as `std::invoke(visitor, alternative)`
    /// and returns the result of that call, if any. As such, `visitor` *must*
    /// be able to accecpt any alternative type as an argument. In the case of
    /// an alternative of type `void`, the visitor must be callable as
    /// `std::invoke(visitor, void_v)`.
    ///
    /// Note that the @ref overload function can be helpful for defining a
    /// visitor inline.
    ///
    /// Also note that this function is implemented as a compile-time-defined
    /// jump table (array of function pointers). In performance critical
    /// applications, be wary of any assumptions about how well or poorly your
    /// compiler will optimize a call to this function.
    ///
    /// ## Example
    /// ```cpp
    /// error_set<error1, error2, error3> e1{std::in_place_index<1>};
    ///
    /// std::move(e1).visit(overload(
    ///     [](error1&& e) { assert(false); },
    ///     [](error2&& e) { assert(true); },
    ///     [](error3&& e) { assert(false); }
    /// ));
    /// ```
    ///
    /// @param visitor The callable object that will be passed an alternative.
    /// @return The return value of the visitor, if any.
    template <typename V>
    constexpr
#ifndef DOXYGEN
        detail::invoke_result_t<
            V&&,
            typename detail::traits<detail::select_t<0, T...>>::rvalue_reference>
#else
        DEDUCED
#endif
        visit(V&& visitor) && {
        return std::move(set_()).visit(std::forward<V>(visitor));
    }
 
    /// @brief Calls a visitor callable with the contained alternative
    ///
    /// @details
    /// This function calls the visitor as `std::invoke(visitor, alternative)`
    /// and returns the result of that call, if any. As such, `visitor` *must*
    /// be able to accecpt any alternative type as an argument. In the case of
    /// an alternative of type `void`, the visitor must be callable as
    /// `std::invoke(visitor, void_v)`.
    ///
    /// Note that the @ref overload function can be helpful for defining a
    /// visitor inline.
    ///
    /// Also note that this function is implemented as a compile-time-defined
    /// jump table (array of function pointers). In performance critical
    /// applications, be wary of any assumptions about how well or poorly your
    /// compiler will optimize a call to this function.
    ///
    /// ## Example
    /// ```cpp
    /// const error_set<error1, error2, error3> e1{std::in_place_index<1>};
    ///
    /// std::move(e1).visit(overload(
    ///     [](const error1&& e) { assert(false); },
    ///     [](const error2&& e) { assert(true); },
    ///     [](const error3&& e) { assert(false); }
    /// ));
    /// ```
    ///
    /// @param visitor The callable object that will be passed an alternative.
    /// @return The return value of the visitor, if any.
    template <typename V>
    constexpr
#ifndef DOXYGEN
        detail::invoke_result_t<
            V&&,
            typename detail::traits<detail::select_t<0, T...>>::const_rvalue_reference>
#else
        DEDUCED
#endif
        visit(V&& visitor) const&& {
        return std::move(set_()).visit(std::forward<V>(visitor));
    }
 
    /// @brief Calls a visitor callable with the contained alternative and metadata
    ///
    /// @details
    /// This function calls the visitor as `std::invoke(visitor, alternative, info)`,
    /// and returns the result of that call, if any. As such, `visitor` *must* be
    /// able to accept any alternative type as an argument. In the case of an
    /// alternative of type `void`, the visitor must be callable as
    /// `std::invoke(visitor, void_v, info)`.
    ///
    /// The `info` argument passed to the visitor, which differentiates this
    /// function from `.visit(...)`, communicates `constexpr` information about
    /// the alternative being visited. The type of the `info` object is not
    /// meant to be named, but it has the API shown below. Note that `info` is
    /// always an empty type.
    ///
    /// ```
    /// struct alternative_info {
    ///     // index of the alternative in the source error_set
    ///     static inline constexpr size_t index = ...;
    ///
    ///     // type of the alternative as declared in the source error_set
    ///     using type = ...;
    ///
    ///     // helper function for forwarding non-const alternative values
    ///     // without needing to provide a template argument.
    ///     static constexpr decltype(auto) forward(...);
    /// };
    /// ```
    ///
    /// Note that the @ref overload function can be helpful for defining a
    /// visitor inline.
    ///
    /// Also note that this function is implemented as a compile-time-defined
    /// jump table (array of function pointers). In performance critical
    /// applications, be wary of any assumptions about how well or poorly your
    /// compiler will optimize a call to this function.
    ///
    /// ## Example
    /// ```
    /// error_set<error1, error2, error3> e1{std::in_place_index<1>};
    ///
    /// e1.visit_informed([](auto& value, auto info) {
    ///     if constexpr (info.index == 0) {
    ///         assert(false);
    ///     } else if constexpr (info.index == 1) {
    ///         assert(true);
    ///     } else if constexpr (info.index == 2) {
    ///         assert(false);
    ///     }
    /// });
    /// ```
    ///
    /// @param visitor The callable object that will be passed an alternative.
    /// @return The return value of the visitor, if any.
    template <typename V>
    constexpr
#ifndef DOXYGEN
        detail::invoke_result_t<
            V&&,
            typename detail::traits<detail::select_t<0, T...>>::reference,
            detail::alternative_info<0, variant<T...>>>
#else
        DEDUCED
#endif
        visit_informed(V&& visitor) & {
        return set_().visit_informed(std::forward<V>(visitor));
    }
 
    /// @brief Calls a visitor callable with the contained alternative and metadata
    ///
    /// @details
    /// This function calls the visitor as `std::invoke(visitor, alternative, info)`,
    /// and returns the result of that call, if any. As such, `visitor` *must* be
    /// able to accept any alternative type as an argument. In the case of an
    /// alternative of type `void`, the visitor must be callable as
    /// `std::invoke(visitor, void_v, info)`.
    ///
    /// The `info` argument passed to the visitor, which differentiates this
    /// function from `.visit(...)`, communicates `constexpr` information about
    /// the alternative being visited. The type of the `info` object is not
    /// meant to be named, but it has the API shown below. Note that `info` is
    /// always an empty type.
    ///
    /// ```
    /// struct alternative_info {
    ///     // index of the alternative in the source error_set
    ///     static inline constexpr size_t index = ...;
    ///
    ///     // type of the alternative as declared in the source error_set
    ///     using type = ...;
    ///
    ///     // helper function for forwarding non-const alternative values
    ///     // without needing to provide a template argument.
    ///     static constexpr decltype(auto) forward(...);
    /// };
    /// ```
    ///
    /// Note that the @ref overload function can be helpful for defining a
    /// visitor inline.
    ///
    /// Also note that this function is implemented as a compile-time-defined
    /// jump table (array of function pointers). In performance critical
    /// applications, be wary of any assumptions about how well or poorly your
    /// compiler will optimize a call to this function.
    ///
    /// ## Example
    /// ```
    /// const error_set<error1, error2, error3> e1{std::in_place_index<1>};
    ///
    /// e1.visit_informed([](const auto& value, auto info) {
    ///     if constexpr (info.index == 0) {
    ///         assert(false);
    ///     } else if constexpr (info.index == 1) {
    ///         assert(true);
    ///     } else if constexpr (info.index == 2) {
    ///         assert(false);
    ///     }
    /// });
    /// ```
    ///
    /// @param visitor The callable object that will be passed an alternative.
    /// @return The return value of the visitor, if any.
    template <typename V>
    constexpr
#ifndef DOXYGEN
        detail::invoke_result_t<
            V&&,
            typename detail::traits<detail::select_t<0, T...>>::const_reference,
            detail::alternative_info<0, variant<T...>>>
#else
        DEDUCED
#endif
        visit_informed(V&& visitor) const& {
        return set_().visit_informed(std::forward<V>(visitor));
    }
 
    /// @brief Calls a visitor callable with the contained alternative and metadata
    ///
    /// @details
    /// This function calls the visitor as `std::invoke(visitor, alternative, info)`,
    /// and returns the result of that call, if any. As such, `visitor` *must* be
    /// able to accept any alternative type as an argument. In the case of an
    /// alternative of type `void`, the visitor must be callable as
    /// `std::invoke(visitor, void_v, info)`.
    ///
    /// The `info` argument passed to the visitor, which differentiates this
    /// function from `.visit(...)`, communicates `constexpr` information about
    /// the alternative being visited. The type of the `info` object is not
    /// meant to be named, but it has the API shown below. Note that `info` is
    /// always an empty type.
    ///
    /// ```
    /// struct alternative_info {
    ///     // index of the alternative in the source error_set
    ///     static inline constexpr size_t index = ...;
    ///
    ///     // type of the alternative as declared in the source error_set
    ///     using type = ...;
    ///
    ///     // helper function for forwarding non-const alternative values
    ///     // without needing to provide a template argument.
    ///     static constexpr decltype(auto) forward(...);
    /// };
    /// ```
    ///
    /// Note that the @ref overload function can be helpful for defining a
    /// visitor inline.
    ///
    /// Also note that this function is implemented as a compile-time-defined
    /// jump table (array of function pointers). In performance critical
    /// applications, be wary of any assumptions about how well or poorly your
    /// compiler will optimize a call to this function.
    ///
    /// ## Example
    /// ```
    /// error_set<error1, error2, error3> e1{std::in_place_index<1>};
    ///
    /// std::move(e1).visit_informed([](auto&& value, auto info) {
    ///     if constexpr (info.index == 0) {
    ///         assert(false);
    ///     } else if constexpr (info.index == 1) {
    ///         assert(true);
    ///     } else if constexpr (info.index == 2) {
    ///         assert(false);
    ///     }
    /// });
    /// ```
    ///
    /// @param visitor The callable object that will be passed an alternative.
    /// @return The return value of the visitor, if any.
    template <typename V>
    constexpr
#ifndef DOXYGEN
        detail::invoke_result_t<
            V&&,
            typename detail::traits<detail::select_t<0, T...>>::rvalue_reference,
            detail::alternative_info<0, variant<T...>>>
#else
        DEDUCED
#endif
        visit_informed(V&& visitor) && {
        return std::move(set_()).visit_informed(std::forward<V>(visitor));
    }
 
    /// @brief Calls a visitor callable with the contained alternative and metadata
    ///
    /// @details
    /// This function calls the visitor as `std::invoke(visitor, alternative, info)`,
    /// and returns the result of that call, if any. As such, `visitor` *must* be
    /// able to accept any alternative type as an argument. In the case of an
    /// alternative of type `void`, the visitor must be callable as
    /// `std::invoke(visitor, void_v, info)`.
    ///
    /// The `info` argument passed to the visitor, which differentiates this
    /// function from `.visit(...)`, communicates `constexpr` information about
    /// the alternative being visited. The type of the `info` object is not
    /// meant to be named, but it has the API shown below. Note that `info` is
    /// always an empty type.
    ///
    /// ```
    /// struct alternative_info {
    ///     // index of the alternative in the source error_set
    ///     static inline constexpr size_t index = ...;
    ///
    ///     // type of the alternative as declared in the source error_set
    ///     using type = ...;
    ///
    ///     // helper function for forwarding non-const alternative values
    ///     // without needing to provide a template argument.
    ///     static constexpr decltype(auto) forward(...);
    /// };
    /// ```
    ///
    /// Note that the @ref overload function can be helpful for defining a
    /// visitor inline.
    ///
    /// Also note that this function is implemented as a compile-time-defined
    /// jump table (array of function pointers). In performance critical
    /// applications, be wary of any assumptions about how well or poorly your
    /// compiler will optimize a call to this function.
    ///
    /// ## Example
    /// ```
    /// const error_set<error1, error2, error3> e1{std::in_place_index<1>};
    ///
    /// std::move(e1).visit_informed([](const auto&& value, auto info) {
    ///     if constexpr (info.index == 0) {
    ///         assert(false);
    ///     } else if constexpr (info.index == 1) {
    ///         assert(true);
    ///     } else if constexpr (info.index == 2) {
    ///         assert(false);
    ///     }
    /// });
    /// ```
    ///
    /// @param visitor The callable object that will be passed an alternative.
    /// @return The return value of the visitor, if any.
    template <typename V>
    constexpr
#ifndef DOXYGEN
        detail::invoke_result_t<
            V&&,
            typename detail::traits<detail::select_t<0, T...>>::const_rvalue_reference,
            detail::alternative_info<0, variant<T...>>>
#else
        DEDUCED
#endif
        visit_informed(V&& visitor) const&& {
        return std::move(set_()).visit_informed(std::forward<V>(visitor));
    }
 
    /// @brief Swaps two @ref error_set instances
    ///
    /// @details
    /// If the two @ref error_set instances contain the same alternative, the
    /// alternative values are swapped directly. Otherwise, the alternatives
    /// are swapped by moving out of the variants, destroying the old
    /// alternatives, and move constructed into the new alternatives.
    ///
    /// ## Example
    /// ```cpp
    /// error_set<error1, error2, error3> e1{std::in_place_index<0>};
    ///
    /// error_set<error1, error2, error3> e2{std::in_place_index<1>};
    ///
    /// e1.swap(e2);
    ///
    /// assert(e1.index() == 1);
    ///
    /// assert(e2.index() == 0);
    /// ```
    ///
    /// @param other The "other" @ref error_set to swap with this @ref error_set
    constexpr void swap(error_set& other)
#ifndef DOXYGEN
        noexcept(noexcept(set_().swap(other.set_())))
#else
        CONDITIONALLY_NOEXCEPT
#endif
    {
        set_().swap(other.set_());
    }
};
 
/// @relates error_set
/// @brief Checks if an @ref error_set contains a particular alternative.
///
/// @details
/// Given a type parameter, this function checks if the @ref error_set currently
/// holds an alternative that has the exact same type.
///
/// ## Example
/// ```cpp
/// error_set<error1, error2, error3> e1{std::in_place_index<0>};
///
/// assert(holds_alternative<error1>(e1));
///
/// error_set<error1, error2, error3> e2{std::in_place_index<2>};
///
/// assert(holds_alternative<error1>(e2));
/// ```
///
/// @return `true` if the @ref error_set holds an alternative of the given type.
template <typename T, typename... U>
constexpr bool holds_alternative(const error_set<U...>& e) noexcept {
    return e.template holds_alternative<T>();
}
 
/// @relates error_set
/// @brief Gets an alternative by index
///
/// @details
/// This function allows accessing alternatives by index, which is provided
/// as a template argument.
///
/// ## Example
/// ```cpp
/// error_set<error1, std::string, error2> e{
///         std::in_place_index<1>, "oh no"};
///
/// assert(get<1>(e) == "oh no");
///
/// get<1>(e) = "no problem";
///
/// assert(get<1>(e) == "no problem");
/// ```
///
/// @tparam I The index of the alternative to access.
///
/// @return A reference to the accessed alternative, if applicable.
///
/// @throws bad_variant_access Thrown if the @ref error_set does not contain
/// the alternative with the corresponding index.
template <size_t I, typename... T>
constexpr
#ifndef DOXYGEN
    typename detail::traits<detail::select_t<I, T...>>::reference
#else
    REFERENCE
#endif
    get(error_set<T...>& e) {
    return e.template get<I>();
}
 
/// @relates error_set
/// @brief Gets an alternative by index
///
/// @details
/// This function allows accessing alternatives by index, which is provided
/// as a template argument.
///
/// ## Example
/// ```cpp
/// const error_set<error1, std::string, error2> e{
///         std::in_place_index<1>, "oh no"};
///
/// assert(get<1>(e) == "oh no");
/// ```
///
/// @tparam I The index of the alternative to access.
///
/// @return A const reference to the accessed alternative, if applicable.
///
/// @throws bad_variant_access Thrown if the @ref error_set does not contain
/// the alternative with the corresponding index.
template <size_t I, typename... T>
constexpr
#ifndef DOXYGEN
    typename detail::traits<detail::select_t<I, T...>>::const_reference
#else
    CONST_REFERENCE
#endif
    get(const error_set<T...>& e) {
    return e.template get<I>();
}
 
/// @relates error_set
/// @brief Gets an alternative by index
///
/// @details
/// This function allows accessing alternatives by index, which is provided
/// as a template argument.
///
/// ## Example
/// ```cpp
/// error_set<error1, std::string, error2> e{
///         std::in_place_index<1>, "oh no"};
///
/// assert(get<1>(std::move(e)) == "oh no");
/// ```
///
/// @tparam I The index of the alternative to access.
///
/// @return An rvalue reference to the accessed alternative, if applicable.
///
/// @throws bad_variant_access Thrown if the @ref error_set does not contain
/// the alternative with the corresponding index.
template <size_t I, typename... T>
constexpr
#ifndef DOXYGEN
    typename detail::traits<detail::select_t<I, T...>>::rvalue_reference
#else
    RVALUE_REFERENCE
#endif
    get(error_set<T...>&& e) {
    return std::move(e).template get<I>();
}
 
/// @relates error_set
/// @brief Gets an alternative by index
///
/// @details
/// This function allows accessing alternatives by index, which is provided
/// as a template argument.
///
/// ## Example
/// ```cpp
/// const error_set<error1, std::string, error2> e{
///         std::in_place_index<1>, "oh no"};
///
/// assert(get<1>(std::move(e)) == "oh no");
/// ```
///
/// @tparam I The index of the alternative to access.
///
/// @return A const rvalue reference to the accessed alternative, if applicable.
///
/// @throws bad_variant_access Thrown if the @ref error_set does not contain
/// the alternative with the corresponding index.
template <size_t I, typename... T>
constexpr
#ifndef DOXYGEN
    typename detail::traits<detail::select_t<I, T...>>::const_rvalue_reference
#else
    CONST_RVALUE_REFERENCE
#endif
    get(const error_set<T...>&& e) {
    return std::move(e).template get<I>();
}
 
/// @relates error_set
/// @brief Gets an alternative by type
///
/// @details
/// This function allows accessing alternatives by type, which is provided
/// as a template argument.
///
/// ## Example
/// ```cpp
/// error_set<error1, std::string, error2> e{
///         std::in_place_index<1>, "oh no"};
///
/// assert(get<std::string>(e) == "oh no");
///
/// get<std::string>(e) = "no problem";
///
/// assert(get<std::string>(e) == "no problem");
/// ```
///
/// @tparam U The type of the alternative to access.
///
/// @return A reference to the accessed alternative, if applicable.
///
/// @throws bad_variant_access Thrown if the @ref error_set does not contain
/// the alternative with the corresponding type.
template <typename T, typename... U>
constexpr
#ifndef DOXYGEN
    typename detail::traits<T>::reference
#else
    REFERENCE
#endif
    get(error_set<U...>& e) {
    return e.template get<T>();
}
 
/// @relates error_set
/// @brief Gets an alternative by type
///
/// @details
/// This function allows accessing alternatives by type, which is provided
/// as a template argument.
///
/// ## Example
/// ```cpp
/// const error_set<error1, std::string, error2> e{
///         std::in_place_index<1>, "oh no"};
///
/// assert(get<std::string>(e) == "oh no");
/// ```
///
/// @tparam U The type of the alternative to access.
///
/// @return A const reference to the accessed alternative, if applicable.
///
/// @throws bad_variant_access Thrown if the @ref error_set does not contain
/// the alternative with the corresponding type.
template <typename T, typename... U>
constexpr
#ifndef DOXYGEN
    typename detail::traits<T>::const_reference
#else
    CONST_REFERENCE
#endif
    get(const error_set<U...>& e) {
    return e.template get<T>();
}
 
/// @relates error_set
/// @brief Gets an alternative by type
///
/// @details
/// This function allows accessing alternatives by type, which is provided
/// as a template argument.
///
/// ## Example
/// ```cpp
/// error_set<error1, std::string, error2> e{
///         std::in_place_index<1>, "oh no"};
///
/// assert(get<std::string>(std::move(e)) == "oh no");
/// ```
///
/// @tparam U The type of the alternative to access.
///
/// @return An rvalue reference to the accessed alternative, if applicable.
///
/// @throws bad_variant_access Thrown if the @ref error_set does not contain
/// the alternative with the corresponding type.
template <typename T, typename... U>
constexpr
#ifndef DOXYGEN
    typename detail::traits<T>::rvalue_reference
#else
    RVALUE_REFERENCE
#endif
    get(error_set<U...>&& e) {
    return std::move(e).template get<T>();
}
 
/// @relates error_set
/// @brief Gets an alternative by type
///
/// @details
/// This function allows accessing alternatives by type, which is provided
/// as a template argument.
///
/// ## Example
/// ```cpp
/// const error_set<error1, std::string, error2> e{
///         std::in_place_index<1>, "oh no"};
///
/// assert(std::move(e).get<std::string>() == "oh no");
/// ```
///
/// @tparam U The type of the alternative to access.
///
/// @return A const rvalue reference to the accessed alternative, if applicable.
///
/// @throws bad_variant_access Thrown if the @ref error_set does not contain
/// the alternative with the corresponding type.
template <typename T, typename... U>
constexpr
#ifndef DOXYGEN
    typename detail::traits<T>::const_rvalue_reference
#else
    CONST_RVALUE_REFERENCE
#endif
    get(const error_set<U...>&& e) {
    return std::move(e).template get<T>();
}
 
/// @relates error_set
/// @brief Gets an alternative pointer by index if the @ref error_set holds it
///
/// @details
/// This functions tries to access an alternative by index. If the @ref
/// error_set contains the alternative, this function returns a pointer to
/// the alternative, if applicable. If the @ref error_set does not contain
/// the alternative, this function returns null. In the case where the
/// alternative is of type `void`, this function does nothing.
///
/// ## Example
/// ```cpp
/// error_set<error1, error2, error3> e{std::in_place_index<1>};
///
/// assert(get_if<1>(e) != nullptr);
///
/// assert(get_if<0>(e) == nullptr);
/// ```
///
/// @tparam I The index of the alternative to access.
///
/// @return A pointer to the accessed alternative, if applicable, or null
template <size_t I, typename... T>
constexpr
#ifndef DOXYGEN
    typename detail::traits<detail::select_t<I, T...>>::pointer
#else
    POINTER
#endif
    get_if(error_set<T...>& e) noexcept {
    return e.template get_if<I>();
}
 
/// @relates error_set
/// @brief Gets an alternative pointer by index if the @ref error_set holds it
///
/// @details
/// This functions tries to access an alternative by index. If the @ref
/// error_set contains the alternative, this function returns a pointer to
/// the alternative, if applicable. If the @ref error_set does not contain
/// the alternative, this function returns null. In the case where the
/// alternative is of type `void`, this function does nothing.
///
/// ## Example
/// ```cpp
/// const error_set<error1, error2, error3> e{std::in_place_index<1>};
///
/// assert(get_if<1>(e) != nullptr);
///
/// assert(get_if<0>(e) == nullptr);
/// ```
///
/// @tparam I The index of the alternative to access.
///
/// @return A const pointer to the accessed alternative, if applicable, or null
template <size_t I, typename... T>
constexpr
#ifndef DOXYGEN
    typename detail::traits<detail::select_t<I, T...>>::const_pointer
#else
    CONST_POINTER
#endif
    get_if(const error_set<T...>& e) noexcept {
    return e.template get_if<I>();
}
 
/// @relates error_set
/// @brief Gets an alternative pointer by type if the @ref error_set holds it
///
/// @details
/// This functions tries to access an alternative by type. If the @ref
/// error_set contains the alternative, this function returns a pointer to
/// the alternative, if applicable. If the @ref error_set does not contain
/// the alternative, this function returns null. In the case where the
/// alternative is of type `void`, this function does nothing.
///
/// ## Example
/// ```cpp
/// error_set<error1, error2, error3> e{std::in_place_index<1>};
///
/// assert(get_if<error2>(e) != nullptr);
///
/// assert(get_if<error1>(e) == nullptr);
/// ```
///
/// @tparam T The type of the alternative to access.
///
/// @return A pointer to the accessed alternative, if applicable, or null
template <typename T, typename... U>
constexpr
#ifndef DOXYGEN
    typename detail::traits<T>::pointer
#else
    POINTER
#endif
    get_if(error_set<U...>& e) noexcept {
    return e.template get_if<T>();
}
 
/// @relates error_set
/// @brief Gets an alternative pointer by type if the @ref error_set holds it
///
/// @details
/// This functions tries to access an alternative by type. If the @ref
/// error_set contains the alternative, this function returns a pointer to
/// the alternative, if applicable. If the @ref error_set does not contain
/// the alternative, this function returns null. In the case where the
/// alternative is of type `void`, this function does nothing.
///
/// ## Example
/// ```cpp
/// const error_set<error1, error2, error3> e{std::in_place_index<1>};
///
/// assert(get_if<error2>(e) != nullptr);
///
/// assert(get_if<error1>(e) == nullptr);
/// ```
///
/// @tparam T The type of the alternative to access.
///
/// @return A const pointer to the accessed alternative, if applicable, or null
template <typename T, typename... U>
constexpr
#ifndef DOXYGEN
    typename detail::traits<T>::const_pointer
#else
    CONST_POINTER
#endif
    get_if(const error_set<U...>& e) noexcept {
    return e.template get_if<T>();
}
 
/// @relates error_set
/// @brief Swaps two @ref error_set instances
///
/// @details
/// If the two @ref error_set instances contain the same alternative, the
/// alternative values are swapped directly. Otherwise, the alternatives
/// are swapped by moving out of the variants, destroying the old
/// alternatives, and move constructed into the new alternatives.
///
/// ## Example
/// ```cpp
/// error_set<error1, error2, error3> e1{std::in_place_index<0>};
///
/// error_set<error1, error2, error3> e2{std::in_place_index<1>};
///
/// swap(e1, e2);
///
/// assert(e1.index() == 1);
///
/// assert(e2.index() == 0);
/// ```
///
/// @param other The "other" @ref error_set to swap with this @ref error_set
template <typename... T>
constexpr void swap(error_set<T...>& a, error_set<T...>& b)
#ifndef DOXYGEN
    noexcept(noexcept(a.swap(b)))
#else
    CONDITIONALLY_NOEXCEPT
#endif
{
    a.swap(b);
}
 
namespace detail {
 
template <typename T>
struct error_set_size_helper;
 
template <typename... T>
struct error_set_size_helper<error_set<T...>>
    : std::integral_constant<size_t, sizeof...(T)> {};
 
template <typename... T>
struct error_set_size_helper<const error_set<T...>>
    : std::integral_constant<size_t, sizeof...(T)> {};
 
template <size_t I, typename T>
struct error_set_alternative_helper;
 
template <size_t I, typename... T>
struct error_set_alternative_helper<I, error_set<T...>> {
    using type = detail::select_t<I, T...>;
};
 
template <size_t I, typename... T>
struct error_set_alternative_helper<I, const error_set<T...>>
    : error_set_alternative_helper<I, error_set<T...>> {};
 
template <typename T, typename U>
struct merge_error_set_helper;
 
template <typename... T, typename U>
    requires(all_unique_v<T..., U>)
struct merge_error_set_helper<error_set<T...>, error_set<U>> {
    using type = error_set<T..., U>;
};
 
template <typename... T, typename U>
    requires(!all_unique_v<T..., U>)
struct merge_error_set_helper<error_set<T...>, error_set<U>> {
    using type = error_set<T...>;
};
 
template <typename... T, typename U0, typename... UN>
    requires(all_unique_v<T..., U0>)
struct merge_error_set_helper<error_set<T...>, error_set<U0, UN...>>
    : merge_error_set_helper<error_set<T..., U0>, error_set<UN...>> {};
 
template <typename... T, typename U0, typename... UN>
    requires(!all_unique_v<T..., U0>)
struct merge_error_set_helper<error_set<T...>, error_set<U0, UN...>>
    : merge_error_set_helper<error_set<T...>, error_set<UN...>> {};
 
template <typename T, typename U>
    requires(!is_error_set_v<std::remove_cvref_t<T>> &&
             !is_error_set_v<std::remove_cvref_t<U>>)
struct merge_error_set_helper<T, U> : merge_error_set_helper<error_set<T>, error_set<U>> {};
 
template <typename T, typename U>
    requires(is_error_set_v<std::remove_cvref_t<T>> &&
             !is_error_set_v<std::remove_cvref_t<U>>)
struct merge_error_set_helper<T, U> : merge_error_set_helper<T, error_set<U>> {};
 
template <typename T, typename U>
    requires(!is_error_set_v<std::remove_cvref_t<T>> &&
             is_error_set_v<std::remove_cvref_t<U>>)
struct merge_error_set_helper<T, U> : merge_error_set_helper<error_set<T>, U> {};
 
template <typename... T>
struct make_error_set_helper;
 
template <typename... T>
struct make_error_set_helper<error_set<T...>> {
    using type = error_set<T...>;
};
 
template <typename T>
    requires(!is_error_set_v<T>)
struct make_error_set_helper<T> {
    using type = error_set<T>;
};
 
template <typename T0, typename T1, typename... TN>
struct make_error_set_helper<T0, T1, TN...>
    : make_error_set_helper<typename merge_error_set_helper<T0, T1>::type, TN...> {};
 
} // namespace detail
 
/// @relates error_set
/// @class is_subset_of error_set.hpp <sumty/error_set.hpp>
/// @brief Utility to test that one @ref error_set is a subset of another.
///
/// @details
/// This type is a template metaprogramming utility to test that the @ref
/// error_set `ES1` is a subset of the @ref error_set `ES2`. If every
/// alternative of `ES1` is an alternative of `ES2`, regardless of order or
/// index, then `ES1` is a subset of `ES2`. The static member constant `value`
/// is a `bool` that is `true` if `ES1` is a subset of `ES2`.
///
/// ## Example
/// ```
/// assert(is_subset_of<
///     error_set<error1>,
///     error_set<error3, error2, error2>
/// >::value);
///
/// assert(!is_subset_of<
///     error_set<error3, error2, error2>
///     error_set<error1>,
/// >::value);
/// ```
///
/// @tparam ES1 The proposed subset
/// @tparam ES2 The proposed superset
template <typename ES1, typename ES2>
struct is_subset_of : detail::is_subset_of_impl<ES1, ES2> {};
 
/// @relates is_subset_of
/// @brief Utility to test that one @ref error_set is a subset of another.
///
/// @details
/// This is a template metaprogramming utility to test that the @ref
/// error_set, `ES1`, is a subset of the @ref error_set `ES2`. If every
/// alternative of `ES1` is an alternative of `ES2`, regardless of order or
/// index, then `ES1` is a subset of `ES2`.
///
/// ## Example
/// ```
/// assert(is_subset_of_v<
///     error_set<error1>,
///     error_set<error3, error2, error2>
/// >);
///
/// assert(!is_subset_of_v<
///     error_set<error3, error2, error2>
///     error_set<error1>,
/// >);
/// ```
///
/// @tparam ES1 The proposed subset
/// @tparam ES2 The proposed superset
template <typename ES1, typename ES2>
static inline constexpr bool is_subset_of_v = is_subset_of<ES1, ES2>::value;
 
/// @relates error_set
/// @class is_equivalent error_set.hpp <sumty/error_set.hpp>
/// @brief Utility to test that one @ref error_set is equivalent to another.
///
/// @details
/// This type is a template metaprogramming utility to test that the @ref
/// error_set `ES1` is equivalent to the @ref error_set `ES2`. Two @ref
/// error_set instantiations are equivalent if each alternative type of
/// one is an alternative type in the other, in both directions. Thus
/// equivalence is commutative. So, reworded, the two are equivalent if
/// the have the same alternative types, but potentially in different
/// orders.
///
/// @ref is_equivalent has the member constant `value`, which is `true`
/// if the two @ref error_set instantiations are equivalent, and `false`
/// otherwise.
///
/// ## Example
/// ```
/// assert(is_equivalent<
///     error_set<error1, error2, error3>,
///     error_set<error2, error1, error3>
/// >::value);
///
/// assert(!is_equivalent<
///     error_set<error1, error2, error3>,
///     error_set<error1, error2>
/// >::value);
/// ```
///
/// @tparam ES1 An @ref error_set type
/// @tparam ES2 An @ref error_set type
template <typename ES1, typename ES2>
struct is_equivalent : detail::is_equivalent_impl<ES1, ES2> {};
 
/// @relates is_equivalent
/// @brief Utility to test that one @ref error_set is equivalent to another.
///
/// @details
/// This is a template metaprogramming utility to test that the @ref
/// error_set `ES1` is equivalent to the @ref error_set `ES2`. Two @ref
/// error_set instantiations are equivalent if each alternative type of
/// one is an alternative type in the other, in both directions. Thus
/// equivalence is commutative. So, reworded, the two are equivalent if
/// the have the same alternative types, but potentially in different
/// orders.
///
/// ## Example
/// ```
/// assert(is_equivalent_v<
///     error_set<error1, error2, error3>,
///     error_set<error2, error1, error3>
/// >);
///
/// assert(!is_equivalent_v<
///     error_set<error1, error2, error3>,
///     error_set<error1, error2>
/// >);
/// ```
///
/// @tparam ES1 An @ref error_set type
/// @tparam ES2 An @ref error_set type
template <typename ES1, typename ES2>
static inline constexpr bool is_equivalent_v = is_equivalent<ES1, ES2>::value;
 
/// @relates error_set
/// @class error_set_size error_set.hpp <sumty/error_set.hpp>
/// @brief Utility to get the number of alternatives in an @ref error_set
///
/// @details
/// @ref error_set_size provides the number alternatives in the @ref error_set,
/// `T`, in the static constexpr member `value`.
///
/// ## Example
/// ```cpp
/// assert(error_set_size<error_set<error1, error2, error3>>::value == 3);
/// ```
///
/// @tparam T The @ref error_set type to get the size of
template <typename T>
struct error_set_size : detail::error_set_size_helper<T> {};
 
/// @relates error_set_size
/// @brief Utility to get the number of alternatives in an @ref error_set
///
/// @details
/// ## Example
/// ```cpp
/// assert(error_set_size_v<error_set<error1, error2, error3>> == 3);
/// ```
///
/// @tparam T The @ref error_set type to get the size of
template <typename T>
static inline constexpr size_t error_set_size_v = error_set_size<T>::value;
 
template <typename... T>
struct variant_size<error_set<T...>> : error_set_size<error_set<T...>> {};
 
template <typename... T>
struct variant_size<const error_set<T...>> : error_set_size<const error_set<T...>> {};
 
/// @relates error_set
/// @class error_set_alternative error_set.hpp <sumty/error_set.hpp>
/// @brief Utility to get the type of a @ref error_set alternative with some index
///
/// @details
/// @ref error_set_alternative provides the type of an alternative with the
/// index `I` in the member type, `type`.
///
/// ## Example
/// ```cpp
/// assert(std::is_same_v<
///     typename error_set_alternative<1, variant<error1, error2, error3>>::type,
///     error2
/// >);
/// ```
///
/// @tparam I The index of the @ref error_set alternative
///
/// @tparam ES The @ref error_set type containing the alternative
template <size_t I, typename ES>
struct error_set_alternative : detail::error_set_alternative_helper<I, ES> {};
 
/// @relates error_set_alternative
/// @brief Utility to get the type of a @ref error_set alternative with some index
///
/// @details
/// @ref error_set_alternative_t is the type of an alternative with the index `I`.
///
/// ## Example
/// ```cpp
/// assert(std::is_same_v<
///     error_set_alternative_t<1, variant<error1, error2, error3>>,
///     error2
/// >);
/// ```
///
/// @tparam I The index of the @ref error_set alternative
///
/// @tparam ES The @ref error_set type containing the alternative
template <size_t I, typename ES>
using error_set_alternative_t = typename error_set_alternative<I, ES>::type;
 
template <size_t I, typename... T>
struct variant_alternative<I, error_set<T...>> : error_set_alternative<I, error_set<T...>> {
};
 
template <size_t I, typename... T>
struct variant_alternative<I, const error_set<T...>>
    : error_set_alternative<I, const error_set<T...>> {};
 
/// @relates error_set
/// @class merge_error_set error_set.hpp <sumty/error_set.hpp>
/// @brief Utility to merge two @ref error_set types
///
/// @details
/// @ref merge_error_set combines the alternative types of two @ref error_set
/// instantiations into a single @ref error_set instantiation. The two types
/// may or may not have alternatives in common. Since @ref error_set requires
/// that there are no two alternatives with the same type, any alternatives
/// common between the two @ref error_set instantiations are deduplicated.
///
/// ## Example
/// ```
/// using merged = typename merge_error_set<
///     error_set<error1, error2>,
///     error_set<error3, error1>
/// >::type;
///
/// assert(is_equivalent_v<merged, error_set<error1, error2, error3>>);
/// ```
///
/// @tparam ES1 An @ref error_set type
/// @tparam ES2 An @ref error_set type
template <typename ES1, typename ES2>
struct merge_error_set : detail::merge_error_set_helper<ES1, ES2> {};
 
/// @relates merge_error_set
/// @brief Utility to merge two @ref error_set types
///
/// @details
/// @ref merge_error_set combines the alternative types of two @ref error_set
/// instantiations into a single @ref error_set instantiation. The two types
/// may or may not have alternatives in common. Since @ref error_set requires
/// that there are no two alternatives with the same type, any alternatives
/// common between the two @ref error_set instantiations are deduplicated.
///
/// ## Example
/// ```
/// using merged = merge_error_set_t<
///     error_set<error1, error2>,
///     error_set<error3, error1>
/// >;
///
/// assert(is_equivalent_v<merged, error_set<error1, error2, error3>>);
/// ```
///
/// @tparam ES1 An @ref error_set type
/// @tparam ES2 An @ref error_set type
template <typename ES1, typename ES2>
using merge_error_set_t = typename merge_error_set<ES1, ES2>::type;
 
/// @relates error_set
/// @class make_error_set error_set.hpp <sumty/error_set.hpp>
/// @brief Utility to create an @ref error_set type.
///
/// @details
/// @ref make_error_set is a builder for the @ref error_set type that
/// deduplicates alternatives. @ref error_set requires that each alternative
/// be a unique type, so @ref make_error_set simplifies generically building
/// an @ref error_set by ensuring that condition is met automatically.
///
/// ## Example
/// ```
/// assert(is_equivalent_v<
///     typename make_error_set<
///         error1, error2, error1, error1, error3, error2
///     >::type,
///     error_set<error1, error2, error3>
/// >);
/// ```
///
/// @tparam T The alternative types of the resulting @ref error_set
template <typename... T>
struct make_error_set : detail::make_error_set_helper<T...> {};
 
/// @relates make_error_set
/// @brief Utility to create an @ref error_set type.
///
/// @details
/// @ref make_error_set is a builder for the @ref error_set type that
/// deduplicates alternatives. @ref error_set requires that each alternative
/// be a unique type, so @ref make_error_set simplifies generically building
/// an @ref error_set by ensuring that condition is met automatically.
///
/// ## Example
/// ```
/// assert(is_equivalent_v<
///     make_error_set_t<error1, error2, error1, error1, error3, error2>,
///     error_set<error1, error2, error3>
/// >);
/// ```
///
/// @tparam T The alternative types of the resulting @ref error_set
template <typename... T>
using make_error_set_t = typename make_error_set<T...>::type;
 
/// @private
template <typename... T>
    requires((true && ... && std::is_base_of_v<never, std::remove_cvref_t<T>>))
class error_set<T...> : public never {};
 
} // namespace sumty
 
#endif