result.hpp

/* Copyright 2023 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_RESULT_HPP
#define SUMTY_RESULT_HPP
 
#include "sumty/detail/fwd.hpp"    // IWYU pragma: export
#include "sumty/detail/traits.hpp" // IWYU pragma: export
#include "sumty/detail/utils.hpp"
#include "sumty/exceptions.hpp"
#include "sumty/option.hpp" // IWYU pragma: keep
#include "sumty/utils.hpp"  // IWYU pragma: export
#include "sumty/variant.hpp"
 
#include <cstddef>
#include <functional>
#include <initializer_list>
#include <type_traits>
#include <utility>
 
namespace sumty {
 
/// @class result result.hpp <sumty/result.hpp>
/// @brief Type that contains an ok value, or an error.
///
/// @details
/// @ref result is a reimplementation of `std::expected` with several
/// improvements. The key difference is that references (lvalue and rvalue) are
/// can be used for both the value type and the error type, and `void` can be
/// used for the error type (`std::expected` already allows `void` for the
/// value type).
///
/// Internally, `result<T, E>` is represented as a @ref variant<T, E>. Thus,
/// @ref result benefits from the size optimizations implemented by @ref
/// variant (see @ref variant documentation for details). A couple special case
/// @ref result size examples are shown in the example below.
///
/// ```
/// struct my_error {}; // NOTE: empty type
///
/// assert(sizeof(result<void, my_error>) == sizeof(bool));
///
/// assert(sizeof(result<int&, my_error>) == sizeof(int*));
/// ```
///
/// In practice, the benefit of @ref result over `std::expected` is that @ref
/// result can be used in more places, especially with generic code. A generic
/// function (function template) that wants to be able to return a value of any
/// type, but also allow that return value to instead communicate an error on
/// failure can simply return a `result<T, E>`, where `T` is now allowed to be
/// a reference or even `void` (and so is `E`, for that matter).
///
/// ```
/// struct negative_number_error {};
///
/// // If value is negative, returns a negative_number_error. Otherwise,
/// // invokes func with the value as an argument and returns the result,
/// // even if the result is void or a reference.
/// template <typename F>
/// result<std::invoke_result_t<F>, negative_number_error>
/// call_if_non_negative(int value, F&& func) {
///     if (value < 0) {
///         return error<negative_number_error>();
///     }
///     // sumty::invoke needed to handle `void` return type
///     return invoke(std::forward<F>(func), value);
/// }
/// ```
///
/// The power of @ref result is also enhanced when used in combination with
/// @ref error_set. @ref error_set makes it easy to represent a set of
/// different error possibilities of different types in a single value, and
/// simplifies error propagation when used with @ref result. See the
/// documentation of @ref error_set for more details and examples.
template <typename T, typename E>
class result : variant<T, E> {
  private:
    [[nodiscard]] constexpr variant<T, E>& res_() & noexcept {
        return *static_cast<variant<T, E>*>(this);
    }
 
    [[nodiscard]] constexpr const variant<T, E>& res_() const& noexcept {
        return *static_cast<const variant<T, E>*>(this);
    }
 
    [[nodiscard]] constexpr variant<T, E>&& res_() && {
        return std::move(*static_cast<variant<T, E>*>(this));
    }
 
    [[nodiscard]] constexpr const variant<T, E>& res_() const&& {
        return std::move(*static_cast<const variant<T, E>*>(this));
    }
 
    template <typename, typename>
    friend class result;
 
  public:
#ifndef DOXYGEN
    using value_type = typename detail::traits<T>::value_type;
    using reference = typename detail::traits<T>::reference;
    using const_reference = typename detail::traits<T>::const_reference;
    using rvalue_reference = typename detail::traits<T>::rvalue_reference;
    using const_rvalue_reference = typename detail::traits<T>::const_rvalue_reference;
    using pointer = typename detail::traits<T>::pointer;
    using const_pointer = typename detail::traits<T>::const_pointer;
 
    using error_type = typename detail::traits<E>::value_type;
    using error_reference = typename detail::traits<E>::reference;
    using error_const_reference = typename detail::traits<E>::const_reference;
    using error_rvalue_reference = typename detail::traits<E>::rvalue_reference;
    using error_const_rvalue_reference = typename detail::traits<E>::const_rvalue_reference;
    using error_pointer = typename detail::traits<E>::pointer;
    using error_const_pointer = typename detail::traits<E>::const_pointer;
#else
    using value_type = ...;
    using reference = ...;
    using const_reference = ...;
    using rvalue_reference = ...;
    using const_rvalue_reference = ...;
    using pointer = ...;
    using const_pointer = ...;
 
    using error_type = ...;
    using error_reference = ...;
    using error_const_reference = ...;
    using error_rvalue_reference = ...;
    using error_const_rvalue_reference = ...;
    using error_pointer = ...;
    using error_const_pointer = ...;
#endif
 
    template <typename U>
    using rebind = result<U, E>;
 
    template <typename V>
    using rebind_error = result<T, V>;
 
    // For compatibility with std::expected
    using unexpected_type = result<never, E>;
 
    /// @brief Default constructor
    ///
    /// @details
    /// Initializes the @ref result with a default constructed ok value.
    ///
    /// ## Example
    /// ```
    /// result<int, std::string> res{};
    ///
    /// assert(res.has_value());
    ///
    /// assert(*res == 0);
    /// ```
    constexpr result()
#ifndef DOXYGEN
        noexcept(std::is_nothrow_default_constructible_v<variant<T, E>>)
        requires(std::is_default_constructible_v<variant<T, E>>)
    = default;
#else
        CONDITIONALLY_NOEXCEPT;
#endif
 
    /// @brief Copy constructor
    ///
    /// @details
    /// If the source @ref result has an ok value, the new @ref result is
    /// initialized with a copy constructed ok value. If the source @ref result
    /// has an error value, the new @ref result is initialized with a copy
    /// constructed error.
    ///
    /// ## Example
    /// ```
    /// result<int, std::string> res1{42};
    /// result<int, std::string> res2{in_place_error, "oh no"};
    ///
    /// result<int, std::string> res1_copy{res1};
    /// result<int, std::string> res2_copy{res2};
    ///
    /// assert(res1_copy.has_value());
    /// assert(*res1_copy == 42);
    ///
    /// assert(!res2_copy.has_value());
    /// assert(res2_copy.error() == "oh no");
    /// ```
    constexpr result(const result&)
#ifndef DOXYGEN
        noexcept(std::is_nothrow_copy_constructible_v<variant<T, E>>)
        requires(std::is_copy_constructible_v<variant<T, E>>)
    = default;
#else
        CONDITIONALLY_NOEXCEPT;
#endif
 
    /// @brief Move constructor
    ///
    /// @details
    /// If the source @ref result has an ok value, the new @ref result is
    /// initialized with a move constructed ok value. If the source @ref result
    /// has an error value, the new @ref result is initialized with a move
    /// constructed error.
    ///
    /// ## Example
    /// ```
    /// result<int, std::string> res1{42};
    /// result<int, std::string> res2{in_place_error, "oh no"};
    ///
    /// result<int, std::string> res1_copy{std::move(res1)};
    /// result<int, std::string> res2_copy{std::move(res2)};
    ///
    /// assert(res1_copy.has_value());
    /// assert(*res1_copy == 42);
    ///
    /// assert(!res2_copy.has_value());
    /// assert(res2_copy.error() == "oh no");
    /// ```
    constexpr result(result&&)
#ifndef DOXYGEN
        noexcept(std::is_nothrow_move_constructible_v<variant<T, E>>)
        requires(std::is_move_constructible_v<variant<T, E>>)
    = default;
#else
        CONDITIONALLY_NOEXCEPT;
#endif
 
    /// @brief Emplacement constructor
    ///
    /// @details
    /// The @ref result is initialized such that an ok value is constructed in
    /// place from the forwarded arguments.
    ///
    /// This constructor is `explicit` if `inplace` is the only argument.
    ///
    /// ## Example
    /// ```
    /// result<std::string, std::string> res{std::in_place, 5, 'a'};
    ///
    /// assert(res.has_value());
    ///
    /// assert(*res == "aaaaa");
    /// ```
    template <typename... Args>
#ifndef DOXYGEN
    explicit(sizeof...(Args) == 0)
#else
    CONDITONALLY_EXPLICIT
#endif
        // NOLINTNEXTLINE(hicpp-explicit-conversions)
        constexpr result([[maybe_unused]] std::in_place_t inplace, Args&&... args)
        : variant<T, E>(std::in_place_index<0>, std::forward<Args>(args)...) {
    }
 
    /// @brief Emplacement constructor with initializer list
    ///
    /// @details
    /// The @ref result is initialized such that an ok value is constructed in
    /// place from the forwarded arguments.
    ///
    /// ## Example
    /// ```
    /// result<std::vector<int>, std::string> res{
    ///         std::in_place, {1, 2, 3, 4, 5}};
    ///
    /// assert(res.has_value());
    ///
    /// assert(res->size() == 5);
    /// ```
    template <typename U, typename... Args>
    constexpr result([[maybe_unused]] std::in_place_t inplace,
                     std::initializer_list<U> init,
                     Args&&... args)
        : variant<T, E>(std::in_place_index<0>, init, std::forward<Args>(args)...) {}
 
    /// @brief Emplacement constructor
    ///
    /// @details
    /// The @ref result is initialized such that an ok value is constructed in
    /// place from the forwarded arguments.
    ///
    /// This constructor is `explicit` if `inplace` is the only argument.
    ///
    /// ## Example
    /// ```
    /// result<std::string, std::string> res{std::in_place_index<0>, 5, 'a'};
    ///
    /// assert(res.has_value());
    ///
    /// assert(*res == "aaaaa");
    /// ```
    template <typename... Args>
#ifndef DOXYGEN
    explicit(sizeof...(Args) == 0)
#else
    CONDITIONALLY_EXPLICIT
#endif
        // NOLINTNEXTLINE(hicpp-explicit-conversions)
        constexpr result(std::in_place_index_t<0> inplace, Args&&... args)
        : variant<T, E>(inplace, std::forward<Args>(args)...) {
    }
 
    /// @brief Emplacement constructor with initializer list
    ///
    /// @details
    /// The @ref result is initialized such that an ok value is constructed in
    /// place from the forwarded arguments.
    ///
    /// ## Example
    /// ```
    /// result<std::vector<int>, std::string> res{
    ///         std::in_place_index<0>, {1, 2, 3, 4, 5}};
    ///
    /// assert(res.has_value());
    ///
    /// assert(res->size() == 5);
    /// ```
    template <typename U, typename... Args>
    constexpr result(std::in_place_index_t<0> inplace,
                     std::initializer_list<U> init,
                     Args&&... args)
        : variant<T, E>(inplace, init, std::forward<Args>(args)...) {}
 
    /// @brief Error emplacement constructor
    ///
    /// @details
    /// The @ref result is initialized such that an error value is constructed
    /// in place from the forwarded arguments.
    ///
    /// ## Example
    /// ```
    /// result<void, std::string> res{in_place_error, 5, 'a'};
    ///
    /// assert(!res.has_value());
    ///
    /// assert(res.error() == "aaaaa");
    /// ```
    template <typename... Args>
#ifndef DOXYGEN
    explicit(sizeof...(Args) == 0)
#else
    CONDITONALLY_EXPLICIT
#endif
        // NOLINTNEXTLINE(hicpp-explicit-conversions)
        constexpr result(in_place_error_t inplace, Args&&... args)
        : variant<T, E>(inplace, std::forward<Args>(args)...) {
    }
 
    /// @brief Error emplacement constructor with initializer list
    ///
    /// @details
    /// The @ref result is initialized such that an error value is constructed
    /// in place from the forwarded arguments.
    ///
    /// ## Example
    /// ```
    /// result<void, std::vector<int>> res{in_place_error, {1, 2, 3, 4, 5}};
    ///
    /// assert(!res.has_value());
    ///
    /// assert(res.error().size() == 5);
    /// ```
    template <typename U, typename... Args>
    constexpr result(in_place_error_t inplace,
                     std::initializer_list<U> init,
                     Args&&... args)
        : variant<T, E>(inplace, init, std::forward<Args>(args)...) {}
 
    /// @brief Forwarding constructor
    ///
    /// @details
    /// The @ref result is initialized such that it contains an ok value that
    /// is constructed in place from the forwarded value.
    ///
    /// This constructor only participates in overload resolution if the ok
    /// value is constructible from the forwarded value, the forwarded value is
    /// not of type `std::in_place_t`, `sumty::in_place_t`,
    /// `std::in_place_index_t<0>`, `sumty::in_place_index_t<0>`,
    /// `std::in_place_index_t<1>`, `sumty::in_place_index_t<1>`, or
    /// `sumty::in_place_error_t`, and either the ok value type is a scalar or
    /// the forwarded value is not a @ref result instance.
    ///
    /// This constructor is `explicit` if the forwarded value is not implicitly
    /// convertible to `T`.
    ///
    /// ## Example
    /// ```
    /// float value = 3.14;
    ///
    /// result<int, std::string> res{value};
    ///
    /// assert(res.has_value());
    ///
    /// assert(*res == 3);
    /// ```
    template <typename U>
#ifndef DOXYGEN
        requires(std::is_constructible_v<variant<T, E>, std::in_place_index_t<0>, U &&> &&
                 !std::is_same_v<std::remove_cvref_t<U>, std::in_place_t> &&
                 !std::is_same_v<std::remove_cvref_t<U>, std::in_place_index_t<0>> &&
                 !std::is_same_v<std::remove_cvref_t<U>, std::in_place_index_t<1>> &&
                 (!std::is_scalar_v<std::remove_cvref_t<T>> ||
                  !detail::is_result_v<std::remove_cvref_t<U>>))
    explicit(!detail::traits<T>::template is_convertible_from<U>)
#else
    CONDITIONALLY_EXPLICIT
#endif
        // NOLINTNEXTLINE(hicpp-explicit-conversions)
        constexpr result(U&& value)
        : variant<T, E>(std::in_place_index<0>, std::forward<U>(value)) {
    }
 
    /// @brief Converting copy constructor
    ///
    /// @details
    /// This constructor converts a @ref result with one pair of ok and error
    /// types into a @result of a different pair of ok and error types. This
    /// constructor behaves much like the copy constructor, except that a type
    /// conversion may occur.
    ///
    /// This constructor only particpates in overload resolution if the ok type
    /// `T` of the destination @ref result is constructible from the ok type
    /// `U` of the source @ref result, *and* the error type `E` of the
    /// destiantion @ref result is constructible from the error type `V` of the
    /// source @ref result.
    ///
    /// This constructor is `explicit` if either `U` or `V` is not implicitly
    /// convertible to `T` or `E`, respectively.
    ///
    /// ## Example
    /// ```
    /// result<float, const char*> res1{3.14};
    /// result<float, const char*> res2{in_place_error, "oh no"};
    ///
    /// result<int, std::string> res3{res1};
    /// result<int, std::string> res4{res2};
    ///
    /// assert(res3.has_value());
    /// assert(*res3 == 3);
    ///
    /// assert(!res4.has_value());
    /// assert(res4.error() == "oh no");
    /// ```
    template <typename U, typename V>
#ifndef DOXYGEN
        requires(((std::is_void_v<U> && detail::traits<T>::is_default_constructible) ||
                  std::is_constructible_v<variant<T, E>,
                                          std::in_place_index_t<0>,
                                          typename detail::traits<U>::const_reference>) &&
                 ((std::is_void_v<V> && detail::traits<E>::is_default_constructible) ||
                  std::is_constructible_v<variant<T, E>,
                                          std::in_place_index_t<1>,
                                          typename detail::traits<E>::const_reference>))
    explicit((!std::is_void_v<U> && !detail::traits<T>::template is_convertible_from<U>) ||
             (!std::is_void_v<V> && !detail::traits<E>::template is_convertible_from<V>))
#else
    CONDITIONALLY_EXPLICIT
#endif
        // NOLINTNEXTLINE(hicpp-explicit-conversions)
        constexpr result(const result<U, V>& other)
        : variant<T, E>(detail::uninit) {
        other.res_().visit_informed([this](auto&& value, auto info) {
            res_().template uninit_emplace<info.index>(
                std::forward<decltype(value)>(value));
        });
    }
 
    /// @brief Converting move constructor
    ///
    /// @details
    /// This constructor converts a @ref result with one pair of ok and error
    /// types into a @result of a different pair of ok and error types. This
    /// constructor behaves much like the move constructor, except that a type
    /// conversion may occur.
    ///
    /// This constructor only particpates in overload resolution if the ok type
    /// `T` of the destination @ref result is constructible from the moved ok
    /// type `U` of the source @ref result, *and* the error type `E` of the
    /// destiantion @ref result is constructible from the move error type `V`
    /// of the source @ref result.
    ///
    /// This constructor is `explicit` if either `U` or `V` is not implicitly
    /// convertible to `T` or `E`, respectively.
    ///
    /// ## Example
    /// ```
    /// result<float, const char*> res1{3.14};
    /// result<float, const char*> res2{in_place_error, "oh no"};
    ///
    /// result<int, std::string> res3{std::move(res1)};
    /// result<int, std::string> res4{std::move(res2)};
    ///
    /// assert(res3.has_value());
    /// assert(*res3 == 3);
    ///
    /// assert(!res4.has_value());
    /// assert(res4.error() == "oh no");
    /// ```
    template <typename U, typename V>
#ifndef DOXYGEN
        requires(((std::is_void_v<U> && detail::traits<T>::is_default_constructible) ||
                  std::is_constructible_v<variant<T, E>,
                                          std::in_place_index_t<0>,
                                          typename detail::traits<U>::rvalue_reference>) &&
                 ((std::is_void_v<V> && detail::traits<E>::is_default_constructible) ||
                  std::is_constructible_v<variant<T, E>,
                                          std::in_place_index_t<1>,
                                          typename detail::traits<E>::rvalue_reference>))
    explicit((!std::is_void_v<U> && !detail::traits<T>::template is_convertible_from<U>) ||
             (!std::is_void_v<V> && !detail::traits<E>::template is_convertible_from<V>))
#else
    CONDITIONALLY_EXPLICIT
#endif
        // clang-format off
        // NOLINTNEXTLINE(hicpp-explicit-conversions,cppcoreguidelines-rvalue-reference-param-not-moved)
        constexpr result(result<U, V>&& other)
        // clang-format on
        : variant<T, E>(detail::uninit) {
        std::move(other).res_().visit_informed([this](auto&& value, auto info) {
            res_().template uninit_emplace<info.index>(
                std::forward<decltype(value)>(value));
        });
    }
 
    /// @brief Destructor
    ///
    /// @details
    /// Destroys the contained value in place.
    ///
    /// The desctructor is `noexcept` if both `T` and `E` are nothrow
    /// destructible.
    constexpr ~result()
#ifndef DOXYGEN
        noexcept(std::is_nothrow_destructible_v<variant<T, E>>) = default;
#else
        CONDITIONALLY_NOEXCEPT;
#endif
 
    /// @brief Copy assignment operator
    ///
    /// @details
    /// The destination @ref result is reassigned such that it will now contain
    /// a copy of the contained value of the source @ref result, which may be
    /// either the ok type or the error type.
    ///
    /// If both the source and destination contain the ok type, or both contain
    /// the error type, the values are copy assigned directly. Otherwise, the
    /// old value in the destination is destroyed and the new value is copy
    /// constructed.
    ///
    /// This function is `noexcept` if both `T` and `E` are all of the
    /// following:
    /// * Nothrow copy assignable
    /// * Nothrow copy constructible
    /// * Nothrow destructible
    ///
    /// ## Example
    /// ```
    /// result<float, const char*> res1{3.14};
    /// result<float, const char*> res2{in_place_error, "oh no"};
    ///
    /// result<int, std::string> res3{};
    /// result<int, std::string> res4{};
    ///
    /// res3 = res1;
    /// res4 = res2;
    ///
    /// assert(res3.has_value());
    /// assert(*res3 == 3);
    ///
    /// assert(!res4.has_value());
    /// assert(res4.error() == "oh no");
    /// ```
    constexpr result& operator=(const result&)
#ifndef DOXYGEN
        noexcept(std::is_nothrow_copy_assignable_v<variant<T, E>>)
        requires(std::is_copy_assignable_v<variant<T, E>>)
    = default;
#else
        CONDITIONALLY_NOEXCEPT;
#endif
 
    /// @brief Move assignment operator
    ///
    /// @details
    /// The destination @ref result is reassigned such that it will now contain
    /// the moved contained value of the source @ref result, which may be
    /// either the ok type or the error type.
    ///
    /// If both the source and destination contain the ok type, or both contain
    /// the error type, the values are move assigned directly. Otherwise, the
    /// old value in the destination is destroyed and the new value is move
    /// constructed.
    ///
    /// This function is `noexcept` if both `T` and `E` are all of the
    /// following:
    /// * Nothrow move assignable
    /// * Nothrow move constructible
    /// * Nothrow destructible
    ///
    /// ## Example
    /// ```
    /// result<float, const char*> res1{3.14};
    /// result<float, const char*> res2{in_place_error, "oh no"};
    ///
    /// result<int, std::string> res3{};
    /// result<int, std::string> res4{};
    ///
    /// res3 = std::move(res1);
    /// res4 = std::move(res2);
    ///
    /// assert(res3.has_value());
    /// assert(*res3 == 3);
    ///
    /// assert(!res4.has_value());
    /// assert(res4.error() == "oh no");
    /// ```
    constexpr result& operator=(result&&)
#ifndef DOXYGEN
        noexcept(std::is_nothrow_move_assignable_v<variant<T, E>>)
        requires(std::is_move_assignable_v<variant<T, E>>)
    = default;
#else
        CONDITIONALLY_NOEXCEPT;
#endif
 
    /// @brief Value assignment operator
    ///
    /// @details
    /// Sets the @ref result to contain the forwarded ok value, converted to
    /// `T`. If the @ref result already contains an ok value, the forwarded
    /// value is assigned directly to the contained value. Otherwise, the
    /// error type is destroyed, and the ok type is constructed from the
    /// forwarded value.
    ///
    /// This function only participates in overload resolution if:
    /// * The source value is not a @ref result
    /// * `T` is constructible from `U`
    /// * `T` is assignable from `U`
    ///
    /// ## Example
    /// ```
    /// result<int, std::string> res{};
    ///
    /// res = 3.14;
    ///
    /// assert(res.has_value());
    /// assert(*res == 3);
    /// ```
    template <typename U>
#ifndef DOXYGEN
        requires(!std::is_same_v<result, std::remove_cvref_t<U>> &&
                 !detail::is_result_v<std::remove_cvref_t<U>> &&
                 detail::traits<T>::template is_constructible<U> &&
                 detail::traits<T>::template is_assignable<U>)
#endif
    constexpr result<T, E>& operator=(U&& value) {
        if (res_().index() == 0) {
            res_()[index<0>] = std::forward<U>(value);
        } else {
            res_().template emplace<0>(std::forward<U>(value));
        }
        return *this;
    }
 
    /// @brief Implicit conversion to `bool`.
    ///
    /// @details
    /// This implicit conversion allows a @ref result to be used directly in a
    /// condition to check if the @ref result contains an ok value.
    ///
    /// ## Example
    /// ```
    /// result<int, std::string> res1{42};
    /// result<int, std::string> res2 = error<std::string>("oh no");
    ///
    /// if (res1) {
    ///     assert(*res1 == 42);
    /// } else {
    ///     assert(false);
    /// }
    ///
    /// if (res2) {
    ///     assert(false);
    /// } else {
    ///     assert(res2.error() == "oh no");
    /// }
    /// ```
    // NOLINTNEXTLINE(hicpp-explicit-conversions)
    constexpr operator bool() const noexcept { return res_().index() == 0; }
 
    /// @brief Returns `true` if the @ref result contains an ok value
    ///
    /// @details
    /// ## Example
    /// ```
    /// result<int, std::string> res1{42};
    /// result<int, std::string> res2{error<std::string>("oh no")};
    ///
    /// assert(res1.has_value());
    /// assert(!res1.has_value());
    /// ```
    [[nodiscard]] constexpr bool has_value() const noexcept { return res_().index() == 0; }
 
    /// @brief Returns `true` if the @ref result contains an ok value
    ///
    /// @details
    /// ## Example
    /// ```
    /// result<int, std::string> res1{42};
    /// result<int, std::string> res2{error<std::string>("oh no")};
    ///
    /// assert(res1.is_ok());
    /// assert(!res1.is_ok());
    /// ```
    [[nodiscard]] constexpr bool is_ok() const noexcept { return res_().index() == 0; }
 
    /// @brief Returns `true` if the @ref result contains an error value
    ///
    /// @details
    /// ## Example
    /// ```
    /// result<int, std::string> res1{42};
    /// result<int, std::string> res2{error<std::string>("oh no")};
    ///
    /// assert(!res1.is_error());
    /// assert(res1.is_error());
    /// ```
    [[nodiscard]] constexpr bool is_error() const noexcept { return res_().index() != 0; }
 
    /// @brief Accesses the ok value contained in the @ref result
    ///
    /// @details
    /// This operator does not check if the @ref result contains an ok value.
    /// Use of this operator when the @ref result contains and error results in
    /// undefined behavior.
    ///
    /// ## Example
    /// ```
    /// result<int, std::string> res{42};
    ///
    /// assert(*res == 42);
    /// ```
    [[nodiscard]] constexpr reference operator*() & noexcept { return res_()[index<0>]; }
 
    /// @brief Accesses the ok value contained in the @ref result
    ///
    /// @details
    /// This operator does not check if the @ref result contains an ok value.
    /// Use of this operator when the @ref result contains an error results in
    /// undefined behavior.
    ///
    /// ## Example
    /// ```
    /// const result<int, std::string> res{42};
    ///
    /// assert(*res == 42);
    /// ```
    [[nodiscard]] constexpr const_reference operator*() const& noexcept {
        return res_()[index<0>];
    }
 
    /// @brief Accesses the ok value contained in the @ref result
    ///
    /// @details
    /// This operator does not check if the @ref result contains an ok value.
    /// Use of this operator when the @ref result contains an error results in
    /// undefined behavior.
    ///
    /// ## Example
    /// ```
    /// result<int, std::string> res{42};
    ///
    /// assert(*std::move(res) == 42);
    /// ```
    [[nodiscard]] constexpr rvalue_reference operator*() && {
        return std::move(*this).res_()[index<0>];
    }
 
    /// @brief Accesses the ok value contained in the @ref result
    ///
    /// @details
    /// This operator does not check if the @ref result contains an ok value.
    /// Use of this operator when the @ref result contains an error results in
    /// undefined behavior.
    ///
    /// ## Example
    /// ```
    /// const result<int, std::string> res{42};
    ///
    /// assert(*std::move(res) == 42);
    /// ```
    [[nodiscard]] constexpr const_rvalue_reference operator*() const&& {
        return std::move(*this).res_()[index<0>];
    }
 
    /// @brief Accesses members of the ok value contained in the @ref result
    ///
    /// @details
    /// This operator does not check if the @ref result contains an ok value.
    /// Use of this operator when the @ref result contains an error results in
    /// undefined behavior.
    ///
    /// ## Example
    /// ```
    /// result<std::string, int> res{"hello"};
    ///
    /// assert(res->size() == 5);
    /// ```
    [[nodiscard]] constexpr pointer operator->() noexcept { return &res_()[index<0>]; }
 
    /// @brief Accesses members of the ok value contained in the @ref result
    ///
    /// @details
    /// This operator does not check if the @ref result contains an ok value.
    /// Use of this operator when the @ref result contains an error results in
    /// undefined behavior.
    ///
    /// ## Example
    /// ```
    /// const result<std::string, int> res{"hello"};
    ///
    /// assert(res->size() == 5);
    /// ```
    [[nodiscard]] constexpr const_pointer operator->() const noexcept {
        return &res_()[index<0>];
    }
 
    /// @brief Accesses the ok value contained in the @ref result
    ///
    /// @details
    /// This function first checks if the @ref result contains an ok value
    /// before attempting to access the value. If the @ref result contains an
    /// error, then this function throws an exception.
    ///
    /// ## Example
    /// ```
    /// result<int, std::string> res{42};
    ///
    /// assert(res.value() == 42);
    /// ```
    ///
    /// @throws bad_result_access Thrown if the @ref result contains an error
    [[nodiscard]] constexpr reference value() & {
        if (res_().index() != 0) {
            if constexpr (std::is_void_v<E>) {
                throw bad_result_access<void>();
            } else {
                throw bad_result_access<std::remove_cvref_t<E>>(res_()[index<1>]);
            }
        }
        return res_()[index<0>];
    }
 
    /// @brief Accesses the ok value contained in the @ref result
    ///
    /// @details
    /// This function first checks if the @ref result contains an ok value
    /// before attempting to access the value. If the @ref result contains an
    /// error, then this function throws an exception.
    ///
    /// ## Example
    /// ```
    /// const result<int, std::string> res{42};
    ///
    /// assert(res.value() == 42);
    /// ```
    ///
    /// @throws bad_result_access Thrown if the @ref result contains an error
    [[nodiscard]] constexpr const_reference value() const& {
        if (res_().index() != 0) {
            if constexpr (std::is_void_v<E>) {
                throw bad_result_access<void>();
            } else {
                throw bad_result_access<std::remove_cvref_t<E>>(res_()[index<1>]);
            }
        }
        return res_()[index<0>];
    }
 
    /// @brief Accesses the ok value contained in the @ref result
    ///
    /// @details
    /// This function first checks if the @ref result contains an ok value
    /// before attempting to access the value. If the @ref result contains an
    /// error, then this function throws an exception.
    ///
    /// ## Example
    /// ```
    /// result<int, std::string> res{42};
    ///
    /// assert(std::move(res).value() == 42);
    /// ```
    ///
    /// @throws bad_result_access Thrown if the @ref result contains an error
    [[nodiscard]] constexpr rvalue_reference value() && {
        if (res_().index() != 0) {
            if constexpr (std::is_void_v<E>) {
                throw bad_result_access<void>();
            } else {
                throw bad_result_access<std::remove_cvref_t<E>>(
                    std::move(*this).res_()[index<1>]);
            }
        }
        return std::move(*this).res_()[index<0>];
    }
 
    /// @brief Accesses the ok value contained in the @ref result
    ///
    /// @details
    /// This function first checks if the @ref result contains an ok value
    /// before attempting to access the value. If the @ref result contains an
    /// error, then this function throws an exception.
    ///
    /// ## Example
    /// ```
    /// const result<int, std::string> res{42};
    ///
    /// assert(std::move(res).value() == 42);
    /// ```
    ///
    /// @throws bad_result_access Thrown if the @ref result contains an error
    [[nodiscard]] constexpr rvalue_reference value() const&& {
        if (res_().index() != 0) {
            if constexpr (std::is_void_v<E>) {
                throw bad_result_access<void>();
            } else {
                throw bad_result_access<std::remove_cvref_t<E>>(
                    std::move(*this).res_()[index<1>]);
            }
        }
        return std::move(*this).res_()[index<0>];
    }
 
    /// @brief Accesses the error value contained in the @ref result
    ///
    /// @details
    /// This function does not check if the @ref result contains an ok value.
    /// Use of this function when the @ref result contains an error results in
    /// undefined behavior.
    ///
    /// ## Example
    /// ```
    /// result<int, std::string> res{in_place_error, "oh no"};
    ///
    /// assert(res.error() == "oh no");
    /// ```
    [[nodiscard]] constexpr error_reference error() & noexcept { return res_()[index<1>]; }
 
    /// @brief Accesses the error value contained in the @ref result
    ///
    /// @details
    /// This function does not check if the @ref result contains an ok value.
    /// Use of this function when the @ref result contains an error results in
    /// undefined behavior.
    ///
    /// ## Example
    /// ```
    /// const result<int, std::string> res{in_place_error, "oh no"};
    ///
    /// assert(res.error() == "oh no");
    /// ```
    [[nodiscard]] constexpr error_const_reference error() const& noexcept {
        return res_()[index<1>];
    }
 
    /// @brief Accesses the error value contained in the @ref result
    ///
    /// @details
    /// This function does not check if the @ref result contains an ok value.
    /// Use of this function when the @ref result contains an error results in
    /// undefined behavior.
    ///
    /// ## Example
    /// ```
    /// result<int, std::string> res{in_place_error, "oh no"};
    ///
    /// assert(std::move(res).error() == "oh no");
    /// ```
    [[nodiscard]] constexpr error_rvalue_reference error() && {
        return std::move(*this).res_()[index<1>];
    }
 
    /// @brief Accesses the error value contained in the @ref result
    ///
    /// @details
    /// This function does not check if the @ref result contains an ok value.
    /// Use of this function when the @ref result contains an error results in
    /// undefined behavior.
    ///
    /// ## Example
    /// ```
    /// const result<int, std::string> res{in_place_error, "oh no"};
    ///
    /// assert(std::move(res).error() == "oh no");
    /// ```
    [[nodiscard]] constexpr error_const_rvalue_reference error() const&& {
        return std::move(*this).res_()[index<1>];
    }
 
    /// @brief Extracts the error in order to propagate it
    ///
    /// @details
    /// This function returns the error value by itself. This
    /// value can then be converted into a different result type for the
    /// purpose of propagating the error.
    ///
    /// This function does not check if the @ref result contains an ok value.
    /// Use of this function when the @ref result contains an error results in
    /// undefined behavior.
    ///
    /// ## Example
    /// ```
    /// result<void, std::string> func() {
    ///     result<int, std::string> res{in_place_error, "oh no"};
    ///
    ///     return res.prop_error();
    /// }
    /// ```
    [[nodiscard]] constexpr result<never, E> prop_error() const& {
        return result<never, E>{in_place_error, error()};
    }
 
    /// @brief Extracts the error in order to propagate it
    ///
    /// @details
    /// This function returns the error value by itself. This
    /// value can then be converted into a different result type for the
    /// purpose of propagating the error.
    ///
    /// This function does not check if the @ref result contains an ok value.
    /// Use of this function when the @ref result contains an error results in
    /// undefined behavior.
    ///
    /// ## Example
    /// ```
    /// result<void, std::string> func() {
    ///     result<int, std::string> res{in_place_error, "oh no"};
    ///
    ///     return std::move(res).prop_error();
    /// }
    /// ```
    [[nodiscard]] constexpr result<never, E> prop_error() && {
        return result<never, E>{in_place_error, std::move(*this).error()};
    }
 
    /// @brief Gets the ok value, or a default if the @ref result is an error
    ///
    /// @details
    /// If the @ref result contains an ok value, a copy of that ok value is
    /// returned. If the @ref result contains an error value, the provided
    /// default value is forwarded, cast, and returned as by the following:
    /// `static_cast<T>(std::forward<U>(default_value))`.
    ///
    /// ## Example
    /// ```
    /// result<int, std::string> res1{42};
    /// result<int, std::string> res2{in_place_error, "oh no"};
    ///
    /// assert(res1.value_or(0) == 42);
    ///
    /// assert(res2.value_or(0) == 0);
    /// ```
    template <typename U>
    [[nodiscard]] constexpr value_type value_or(U&& default_value) const& {
        if (res_().index() == 0) {
            return res_()[index<0>];
        } else {
            return static_cast<value_type>(std::forward<U>(default_value));
        }
    }
 
    /// @brief Gets the ok value, or a default if the @ref result is an error
    ///
    /// @details
    /// If the @ref result contains an ok value, that ok value is
    /// returned. If the @ref result contains an error value, the provided
    /// default value is forwarded, cast, and returned as by the following:
    /// `static_cast<T>(std::forward<U>(default_value))`.
    ///
    /// ## Example
    /// ```
    /// result<int, std::string> res1{42};
    /// result<int, std::string> res2{in_place_error, "oh no"};
    ///
    /// assert(std::move(res1).value_or(0) == 42);
    ///
    /// assert(std::move(res2).value_or(0) == 0);
    /// ```
    template <typename U>
    [[nodiscard]] constexpr value_type value_or(U&& default_value) && {
        if (res_().index() == 0) {
            return std::move(*this).res_()[index<0>];
        } else {
            return static_cast<value_type>(std::forward<U>(default_value));
        }
    }
 
    /// @brief Gets the ok value, or returns the result of a callable
    ///
    /// @details
    /// If the @ref result contains an ok value, a copy of that ok value is
    /// returned. If the @ref result contains an error, the provided callable
    /// is invoked and the result is cast and returned, as if by:
    /// `static_cast<T>(std::invoke(std::forward<F>(f)))`.
    ///
    /// ## Example
    /// ```
    /// result<int, std::string> res1{42};
    /// result<int, std::string> res2{in_place_error, "oh no"};
    ///
    /// assert(res1.value_or_else([] { return 0; }) == 42);
    ///
    /// assert(res2.value_or_else({] { return 0; }) == 0);
    /// ```
    template <typename F>
    [[nodiscard]] constexpr value_type value_or_else(F&& f) const& {
        if (res_().index() == 0) {
            return res_()[index<0>];
        } else {
            return static_cast<T>(invoke(std::forward<F>(f)));
        }
    }
 
    /// @brief Gets the ok value, or returns the result of a callable
    ///
    /// @details
    /// If the @ref result contains an ok value, a copy of that ok value is
    /// returned. If the @ref result contains an error, the provided callable
    /// is invoked and the result is cast and returned, as if by:
    /// `static_cast<T>(std::invoke(std::forward<F>(f)))`.
    ///
    /// ## Example
    /// ```
    /// result<int, std::string> res1{42};
    /// result<int, std::string> res2{in_place_error, "oh no"};
    ///
    /// assert(std::move(res1).value_or_else([] { return 0; }) == 42);
    ///
    /// assert(std::move(res2).value_or_else({] { return 0; }) == 0);
    /// ```
    template <typename F>
    [[nodiscard]] constexpr value_type value_or_else(F&& f) && {
        if (res_().index() == 0) {
            return std::move(*this).res_()[index<0>];
        } else {
            return static_cast<T>(invoke(std::forward<F>(f)));
        }
    }
 
    /// @brief Accesses the ok value contained in the @ref result
    ///
    /// @details
    /// This function first checks if the @ref result contains an ok value
    /// before attempting to access the value. If the @ref result contains an
    /// error, then this function throws an exception.
    ///
    /// ## Example
    /// ```
    /// result<int, std::string> res{42};
    ///
    /// assert(res.ok() == 42);
    /// ```
    ///
    /// @throws bad_result_access Thrown if the @ref result contains an error
    [[nodiscard]] constexpr reference ok() & { return value(); }
 
    /// @brief Accesses the ok value contained in the @ref result
    ///
    /// @details
    /// This function first checks if the @ref result contains an ok value
    /// before attempting to access the value. If the @ref result contains an
    /// error, then this function throws an exception.
    ///
    /// ## Example
    /// ```
    /// const result<int, std::string> res{42};
    ///
    /// assert(res.ok() == 42);
    /// ```
    ///
    /// @throws bad_result_access Thrown if the @ref result contains an error
    [[nodiscard]] constexpr const_reference ok() const& { return value(); }
 
    /// @brief Accesses the ok value contained in the @ref result
    ///
    /// @details
    /// This function first checks if the @ref result contains an ok value
    /// before attempting to access the value. If the @ref result contains an
    /// error, then this function throws an exception.
    ///
    /// ## Example
    /// ```
    /// result<int, std::string> res{42};
    ///
    /// assert(std::move(res).ok() == 42);
    /// ```
    ///
    /// @throws bad_result_access Thrown if the @ref result contains an error
    [[nodiscard]] constexpr rvalue_reference ok() && { return std::move(*this).value(); }
 
    /// @brief Accesses the ok value contained in the @ref result
    ///
    /// @details
    /// This function first checks if the @ref result contains an ok value
    /// before attempting to access the value. If the @ref result contains an
    /// error, then this function throws an exception.
    ///
    /// ## Example
    /// ```
    /// const result<int, std::string> res{42};
    ///
    /// assert(std::move(res).ok() == 42);
    /// ```
    ///
    /// @throws bad_result_access Thrown if the @ref result contains an error
    [[nodiscard]] constexpr rvalue_reference ok() const&& {
        return std::move(*this).value();
    }
 
    /// @brief Gets the ok value, or a default if the @ref result is an error
    ///
    /// @details
    /// If the @ref result contains an ok value, a copy of that ok value is
    /// returned. If the @ref result contains an error value, the provided
    /// default value is forwarded, cast, and returned as by the following:
    /// `static_cast<T>(std::forward<U>(default_value))`.
    ///
    /// ## Example
    /// ```
    /// result<int, std::string> res1{42};
    /// result<int, std::string> res2{in_place_error, "oh no"};
    ///
    /// assert(res1.ok_or(0) == 42);
    ///
    /// assert(res2.ok_or(0) == 0);
    /// ```
    template <typename U>
    [[nodiscard]] constexpr value_type ok_or(U&& default_value) const& {
        return value_or(std::forward<U>(default_value));
    }
 
    /// @brief Gets the ok value, or a default if the @ref result is an error
    ///
    /// @details
    /// If the @ref result contains an ok value, that ok value is
    /// returned. If the @ref result contains an error value, the provided
    /// default value is forwarded, cast, and returned as by the following:
    /// `static_cast<T>(std::forward<U>(default_value))`.
    ///
    /// ## Example
    /// ```
    /// result<int, std::string> res1{42};
    /// result<int, std::string> res2{in_place_error, "oh no"};
    ///
    /// assert(std::move(res1).ok_or(0) == 42);
    ///
    /// assert(std::move(res2).ok_or(0) == 0);
    /// ```
    template <typename U>
    [[nodiscard]] constexpr value_type ok_or(U&& default_value) && {
        return std::move(*this).ok_or(std::forward<U>(default_value));
    }
 
    /// @brief Gets the ok value, or returns the result of a callable
    ///
    /// @details
    /// If the @ref result contains an ok value, a copy of that ok value is
    /// returned. If the @ref result contains an error, the provided callable
    /// is invoked and the result is cast and returned, as if by:
    /// `static_cast<T>(std::invoke(std::forward<F>(f)))`.
    ///
    /// ## Example
    /// ```
    /// result<int, std::string> res1{42};
    /// result<int, std::string> res2{in_place_error, "oh no"};
    ///
    /// assert(res1.ok_or_else([] { return 0; }) == 42);
    ///
    /// assert(res2.ok_or_else({] { return 0; }) == 0);
    /// ```
    template <typename F>
    [[nodiscard]] constexpr value_type ok_or_else(F&& f) const& {
        return value_or_else(std::forward<F>(f));
    }
 
    /// @brief Gets the ok value, or returns the result of a callable
    ///
    /// @details
    /// If the @ref result contains an ok value, a copy of that ok value is
    /// returned. If the @ref result contains an error, the provided callable
    /// is invoked and the result is cast and returned, as if by:
    /// `static_cast<T>(std::invoke(std::forward<F>(f)))`.
    ///
    /// ## Example
    /// ```
    /// result<int, std::string> res1{42};
    /// result<int, std::string> res2{in_place_error, "oh no"};
    ///
    /// assert(std::move(res1).ok_or_else([] { return 0; }) == 42);
    ///
    /// assert(std::move(res2).ok_or_else({] { return 0; }) == 0);
    /// ```
    template <typename F>
    [[nodiscard]] constexpr value_type ok_or_else(F&& f) && {
        return std::move(*this).value_or_else(std::forward<F>(f));
    }
 
    /// @brief Applies a callable to the contents of a @ref result
    ///
    /// @details
    /// If the @ref result contains an ok value, the value is passed into the
    /// callable, and the result of invoking the callable is returned from this
    /// function. If the @ref result contains an error, the callable is not
    /// invoked, and a copy of the error is returned.
    ///
    /// This function only participates in overload resultion if the result of
    /// invoking the callable is a @ref result.
    ///
    /// ## Example
    /// ```
    /// result<int, std::string> res1{42};
    /// result<int, std::string> res2{-42};
    /// result<int, std::string> res3{in_place_error, "oh no"};
    ///
    /// auto callable = [](int value) -> result<unsigned int, const char*> {
    ///     if (value < 0) {
    ///         return error<const char*>("negaive value");
    ///     } else {
    ///         return static_cast<unsigned int>(value);
    ///     }
    /// };
    ///
    /// auto res1_new = res1.and_then(callable);
    /// auto res2_new = res2.and_then(callable);
    /// auto res3_new = res3.and_then(callable);
    ///
    /// assert(res1_new.is_ok());
    /// assert(*res1_new == 42);
    ///
    /// assert(res2_new.is_error());
    /// assert(res2_new.error() == "negative value");
    ///
    /// assert(res3_new.is_error());
    /// assert(res3_new.error() == "oh no");
    /// ```
    template <typename F>
        constexpr auto and_then(F&& f) &
#ifndef DOXYGEN
        requires(
            detail::is_result_v<std::remove_cvref_t<detail::invoke_result_t<F, reference>>>)
#endif
    {
        if constexpr (std::is_void_v<T>) {
            if (res_().index() == 0) {
                return std::invoke(std::forward<F>(f), void_v);
            } else {
                if constexpr (std::is_void_v<E>) {
                    return std::remove_cvref_t<std::invoke_result_t<F, void_t>>{
                        in_place_error};
                } else {
                    return std::remove_cvref_t<std::invoke_result_t<F, void_t>>{
                        in_place_error, res_()[index<1>]};
                }
            }
        } else {
            if (res_().index() == 0) {
                return std::invoke(std::forward<F>(f), res_()[index<0>]);
            } else {
                if constexpr (std::is_void_v<E>) {
                    return std::remove_cvref_t<std::invoke_result_t<F, reference>>{
                        in_place_error};
                } else {
                    return std::remove_cvref_t<std::invoke_result_t<F, reference>>{
                        in_place_error, res_()[index<1>]};
                }
            }
        }
    }
 
        /// @brief Applies a callable to the contents of a @ref result
        ///
        /// @details
        /// If the @ref result contains an ok value, the value is passed into the
        /// callable, and the result of invoking the callable is returned from this
        /// function. If the @ref result contains an error, the callable is not
        /// invoked, and a copy of the error is returned.
        ///
        /// This function only participates in overload resultion if the result of
        /// invoking the callable is a @ref result.
        ///
        /// ## Example
        /// ```
        /// const result<int, std::string> res1{42};
        /// const result<int, std::string> res2{-42};
        /// const result<int, std::string> res3{in_place_error, "oh no"};
        ///
        /// auto callable = [](int value) -> result<unsigned int, const char*> {
        ///     if (value < 0) {
        ///         return error<const char*>("negaive value");
        ///     } else {
        ///         return static_cast<unsigned int>(value);
        ///     }
        /// };
        ///
        /// auto res1_new = res1.and_then(callable);
        /// auto res2_new = res2.and_then(callable);
        /// auto res3_new = res3.and_then(callable);
        ///
        /// assert(res1_new.is_ok());
        /// assert(*res1_new == 42);
        ///
        /// assert(res2_new.is_error());
        /// assert(res2_new.error() == "negative value");
        ///
        /// assert(res3_new.is_error());
        /// assert(res3_new.error() == "oh no");
        /// ```
        template <typename F>
        constexpr auto and_then(F&& f) const& {
        if constexpr (std::is_void_v<T>) {
            if (res_().index() == 0) {
                return std::invoke(std::forward<F>(f), void_v);
            } else {
                if constexpr (std::is_void_v<E>) {
                    return std::remove_cvref_t<std::invoke_result_t<F, void_t>>{
                        in_place_error};
                } else {
                    return std::remove_cvref_t<std::invoke_result_t<F, void_t>>{
                        in_place_error, res_()[index<1>]};
                }
            }
        } else {
            if (res_().index() == 0) {
                return std::invoke(std::forward<F>(f), res_()[index<0>]);
            } else {
                if constexpr (std::is_void_v<E>) {
                    return std::remove_cvref_t<std::invoke_result_t<F, const_reference>>{
                        in_place_error};
                } else {
                    return std::remove_cvref_t<std::invoke_result_t<F, const_reference>>{
                        in_place_error, res_()[index<1>]};
                }
            }
        }
    }
 
    /// @brief Applies a callable to the contents of a @ref result
    ///
    /// @details
    /// If the @ref result contains an ok value, the value is passed into the
    /// callable, and the result of invoking the callable is returned from this
    /// function. If the @ref result contains an error, the callable is not
    /// invoked, the error is returned.
    ///
    /// This function only participates in overload resultion if the result of
    /// invoking the callable is a @ref result.
    ///
    /// ## Example
    /// ```
    /// result<int, std::string> res1{42};
    /// result<int, std::string> res2{-42};
    /// result<int, std::string> res3{in_place_error, "oh no"};
    ///
    /// auto callable = [](int value) -> result<unsigned int, const char*> {
    ///     if (value < 0) {
    ///         return error<const char*>("negaive value");
    ///     } else {
    ///         return static_cast<unsigned int>(value);
    ///     }
    /// };
    ///
    /// auto res1_new = std::move(res1).and_then(callable);
    /// auto res2_new = std::move(res2).and_then(callable);
    /// auto res3_new = std::move(res3).and_then(callable);
    ///
    /// assert(res1_new.is_ok());
    /// assert(*res1_new == 42);
    ///
    /// assert(res2_new.is_error());
    /// assert(res2_new.error() == "negative value");
    ///
    /// assert(res3_new.is_error());
    /// assert(res3_new.error() == "oh no");
    /// ```
    template <typename F>
    constexpr auto and_then(F&& f) && {
        if constexpr (std::is_void_v<T>) {
            if (res_().index() == 0) {
                return std::invoke(std::forward<F>(f), void_v);
            } else {
                if constexpr (std::is_void_v<E>) {
                    return std::remove_cvref_t<std::invoke_result_t<F, void_t>>{
                        in_place_error};
                } else {
                    return std::remove_cvref_t<std::invoke_result_t<F, void_t>>{
                        in_place_error, std::move(*this).res_()[index<1>]};
                }
            }
        } else {
            if (res_().index() == 0) {
                return std::invoke(std::forward<F>(f), std::move(*this).res_()[index<0>]);
            } else {
                if constexpr (std::is_void_v<E>) {
                    return std::remove_cvref_t<std::invoke_result_t<F, rvalue_reference>>{
                        in_place_error};
                } else {
                    return std::remove_cvref_t<std::invoke_result_t<F, rvalue_reference>>{
                        in_place_error, std::move(*this).res_()[index<1>]};
                }
            }
        }
    }
 
    /// @brief Applies a callable to the contents of a @ref result
    ///
    /// @details
    /// If the @ref result contains an ok value, the value is passed into the
    /// callable, and the result of invoking the callable is returned from this
    /// function. If the @ref result contains an error, the callable is not
    /// invoked, the error is returned.
    ///
    /// This function only participates in overload resultion if the result of
    /// invoking the callable is a @ref result.
    ///
    /// ## Example
    /// ```
    /// const result<int, std::string> res1{42};
    /// const result<int, std::string> res2{-42};
    /// const result<int, std::string> res3{in_place_error, "oh no"};
    ///
    /// auto callable = [](int value) -> result<unsigned int, const char*> {
    ///     if (value < 0) {
    ///         return error<const char*>("negaive value");
    ///     } else {
    ///         return static_cast<unsigned int>(value);
    ///     }
    /// };
    ///
    /// auto res1_new = std::move(res1).and_then(callable);
    /// auto res2_new = std::move(res2).and_then(callable);
    /// auto res3_new = std::move(res3).and_then(callable);
    ///
    /// assert(res1_new.is_ok());
    /// assert(*res1_new == 42);
    ///
    /// assert(res2_new.is_error());
    /// assert(res2_new.error() == "negative value");
    ///
    /// assert(res3_new.is_error());
    /// assert(res3_new.error() == "oh no");
    /// ```
    template <typename F>
    constexpr auto and_then(F&& f) const&& {
        if constexpr (std::is_void_v<T>) {
            if (res_().index() == 0) {
                return std::invoke(std::forward<F>(f), void_v);
            } else {
                if constexpr (std::is_void_v<E>) {
                    return std::remove_cvref_t<std::invoke_result_t<F, void_t>>{
                        in_place_error};
                } else {
                    return std::remove_cvref_t<std::invoke_result_t<F, void_t>>{
                        in_place_error, std::move(*this).res_()[index<1>]};
                }
            }
        } else {
            if (res_().index() == 0) {
                return std::invoke(std::forward<F>(f), std::move(*this).res_()[index<0>]);
            } else {
                if constexpr (std::is_void_v<E>) {
                    return std::remove_cvref_t<
                        std::invoke_result_t<F, const_rvalue_reference>>{in_place_error};
                } else {
                    return std::remove_cvref_t<
                        std::invoke_result_t<F, const_rvalue_reference>>{
                        in_place_error, std::move(*this).res_()[index<1>]};
                }
            }
        }
    }
 
    /// @brief Perforams a transformation on the ok value of a @ref result
    ///
    /// @details
    /// If the @ref result contains an ok value, that value is passed to the
    /// transformation callable provided. The value returned from the callable
    /// is then returned from this function as the ok value of a new @ref
    /// result, where ok type of the new result is the exact type returned
    /// from the callable. If the @ref result contains an error value, a copy
    /// of the error is returned.
    ///
    /// Note that this function is identical to @ref map, but the name
    /// `transform` makes @ref result able to be a drop in replacement for
    /// `std::expected`. `map` is the more typical name of this monadic
    /// operation outside of C++.
    ///
    /// ## Example
    /// ```
    /// result<int, std::string> res1{42};
    /// result<int, std::string> res2{in_place_error, "oh no"};
    ///
    /// auto res1_mapped = res1.transform([](auto value) {
    ///     return std::to_string(value);
    /// });
    /// auto res2_mapped = res2.transform([](auto value) {
    ///     return std::to_string(value);
    /// });
    ///
    /// assert(res1_mapped.is_error());
    /// assert(res1_mapped.error() == "oh no");
    ///
    /// assert(res2_mapped.is_ok());
    /// assert(*res2_mapped == "42");
    /// ```
    template <typename F>
    constexpr auto transform(F&& f) & {
        if constexpr (std::is_void_v<T>) {
            using res_t = std::invoke_result_t<F, void_t>;
            if (res_().index() == 0) {
                if constexpr (std::is_void_v<res_t>) {
                    std::invoke(std::forward<F>(f), void_v);
                    return result<res_t, E>{std::in_place};
                } else {
                    return result<res_t, E>{std::in_place,
                                            std::invoke(std::forward<F>(f), void_v)};
                }
            } else {
                if constexpr (std::is_void_v<E>) {
                    return result<res_t, E>{in_place_error};
                } else {
                    return result<res_t, E>{in_place_error, res_()[index<1>]};
                }
            }
        } else {
            using res_t = std::invoke_result_t<F, reference>;
            if (res_().index() == 0) {
                if constexpr (std::is_void_v<res_t>) {
                    std::invoke(std::forward<F>(f), res_()[index<0>]);
                    return result<res_t, E>{std::in_place};
                } else {
                    return result<res_t, E>{
                        std::in_place, std::invoke(std::forward<F>(f), res_()[index<0>])};
                }
            } else {
                if constexpr (std::is_void_v<E>) {
                    return result<res_t, E>{in_place_error};
                } else {
                    return result<res_t, E>{in_place_error, res_()[index<1>]};
                }
            }
        }
    }
 
    /// @brief Perforams a transformation on the ok value of a @ref result
    ///
    /// @details
    /// If the @ref result contains an ok value, that value is passed to the
    /// transformation callable provided. The value returned from the callable
    /// is then returned from this function as the ok value of a new @ref
    /// result, where ok type of the new result is the exact type returned
    /// from the callable. If the @ref result contains an error value, a copy
    /// of the error is returned.
    ///
    /// Note that this function is identical to @ref map, but the name
    /// `transform` makes @ref result able to be a drop in replacement for
    /// `std::expected`. `map` is the more typical name of this monadic
    /// operation outside of C++.
    ///
    /// ## Example
    /// ```
    /// const result<int, std::string> res1{42};
    /// const result<int, std::string> res2{in_place_error, "oh no"};
    ///
    /// auto res1_mapped = res1.transform([](auto value) {
    ///     return std::to_string(value);
    /// });
    /// auto res2_mapped = res2.transform([](auto value) {
    ///     return std::to_string(value);
    /// });
    ///
    /// assert(res1_mapped.is_error());
    /// assert(res1_mapped.error() == "oh no");
    ///
    /// assert(res2_mapped.is_ok());
    /// assert(*res2_mapped == "42");
    /// ```
    template <typename F>
    constexpr auto transform(F&& f) const& {
        if constexpr (std::is_void_v<T>) {
            using res_t = std::invoke_result_t<F, void_t>;
            if (res_().index() == 0) {
                if constexpr (std::is_void_v<res_t>) {
                    std::invoke(std::forward<F>(f), void_v);
                    return result<res_t, E>{std::in_place};
                } else {
                    return result<res_t, E>{std::in_place,
                                            std::invoke(std::forward<F>(f), void_v)};
                }
            } else {
                if constexpr (std::is_void_v<E>) {
                    return result<res_t, E>{in_place_error};
                } else {
                    return result<res_t, E>{in_place_error, res_()[index<1>]};
                }
            }
        } else {
            using res_t = std::invoke_result_t<F, const_reference>;
            if (res_().index() == 0) {
                if constexpr (std::is_void_v<res_t>) {
                    std::invoke(std::forward<F>(f), res_()[index<0>]);
                    return result<res_t, E>{std::in_place};
                } else {
                    return result<res_t, E>{
                        std::in_place, std::invoke(std::forward<F>(f), res_()[index<0>])};
                }
            } else {
                if constexpr (std::is_void_v<E>) {
                    return result<res_t, E>{in_place_error};
                } else {
                    return result<res_t, E>{in_place_error, res_()[index<1>]};
                }
            }
        }
    }
 
    /// @brief Perforams a transformation on the ok value of a @ref result
    ///
    /// @details
    /// If the @ref result contains an ok value, that value is passed to the
    /// transformation callable provided. The value returned from the callable
    /// is then returned from this function as the ok value of a new @ref
    /// result, where ok type of the new result is the exact type returned
    /// from the callable. If the @ref result contains an error value, the
    /// error is returned.
    ///
    /// Note that this function is identical to @ref map, but the name
    /// `transform` makes @ref result able to be a drop in replacement for
    /// `std::expected`. `map` is the more typical name of this monadic
    /// operation outside of C++.
    ///
    /// ## Example
    /// ```
    /// result<int, std::string> res1{42};
    /// result<int, std::string> res2{in_place_error, "oh no"};
    ///
    /// auto res1_mapped = std::move(res1).transform([](auto value) {
    ///     return std::to_string(value);
    /// });
    /// auto res2_mapped = std::move(res2).transform([](auto value) {
    ///     return std::to_string(value);
    /// });
    ///
    /// assert(res1_mapped.is_error());
    /// assert(res1_mapped.error() == "oh no");
    ///
    /// assert(res2_mapped.is_ok());
    /// assert(*res2_mapped == "42");
    /// ```
    template <typename F>
    constexpr auto transform(F&& f) && {
        if constexpr (std::is_void_v<T>) {
            using res_t = std::invoke_result_t<F, void_t>;
            if (res_().index() == 0) {
                if constexpr (std::is_void_v<res_t>) {
                    std::invoke(std::forward<F>(f), void_v);
                    return result<res_t, E>{std::in_place};
                } else {
                    return result<res_t, E>{std::in_place,
                                            std::invoke(std::forward<F>(f), void_v)};
                }
            } else {
                if constexpr (std::is_void_v<E>) {
                    return result<res_t, E>{in_place_error};
                } else {
                    return result<res_t, E>{in_place_error,
                                            std::move(*this).res_()[index<1>]};
                }
            }
        } else {
            using res_t = std::invoke_result_t<F, rvalue_reference>;
            if (res_().index() == 0) {
                if constexpr (std::is_void_v<res_t>) {
                    std::invoke(std::forward<F>(f), std::move(*this).res_()[index<0>]);
                    return result<res_t, E>{std::in_place};
                } else {
                    return result<res_t, E>{
                        std::in_place,
                        std::invoke(std::forward<F>(f), std::move(*this).res_()[index<0>])};
                }
            } else {
                if constexpr (std::is_void_v<E>) {
                    return result<res_t, E>{in_place_error};
                } else {
                    return result<res_t, E>{in_place_error,
                                            std::move(*this).res_()[index<1>]};
                }
            }
        }
    }
 
    /// @brief Perforams a transformation on the ok value of a @ref result
    ///
    /// @details
    /// If the @ref result contains an ok value, that value is passed to the
    /// transformation callable provided. The value returned from the callable
    /// is then returned from this function as the ok value of a new @ref
    /// result, where ok type of the new result is the exact type returned
    /// from the callable. If the @ref result contains an error value, the
    /// error is returned.
    ///
    /// Note that this function is identical to @ref map, but the name
    /// `transform` makes @ref result able to be a drop in replacement for
    /// `std::expected`. `map` is the more typical name of this monadic
    /// operation outside of C++.
    ///
    /// ## Example
    /// ```
    /// const result<int, std::string> res1{42};
    /// const result<int, std::string> res2{in_place_error, "oh no"};
    ///
    /// auto res1_mapped = std::move(res1).transform([](auto value) {
    ///     return std::to_string(value);
    /// });
    /// auto res2_mapped = std::move(res2).transform([](auto value) {
    ///     return std::to_string(value);
    /// });
    ///
    /// assert(res1_mapped.is_error());
    /// assert(res1_mapped.error() == "oh no");
    ///
    /// assert(res2_mapped.is_ok());
    /// assert(*res2_mapped == "42");
    /// ```
    template <typename F>
    constexpr auto transform(F&& f) const&& {
        if constexpr (std::is_void_v<T>) {
            using res_t = std::invoke_result_t<F, void_t>;
            if (res_().index() == 0) {
                if constexpr (std::is_void_v<res_t>) {
                    std::invoke(std::forward<F>(f), void_v);
                    return result<res_t, E>{std::in_place};
                } else {
                    return result<res_t, E>{std::in_place,
                                            std::invoke(std::forward<F>(f), void_v)};
                }
            } else {
                if constexpr (std::is_void_v<E>) {
                    return result<res_t, E>{in_place_error};
                } else {
                    return result<res_t, E>{in_place_error,
                                            std::move(*this).res_()[index<1>]};
                }
            }
        } else {
            using res_t = std::invoke_result_t<F, const_rvalue_reference>;
            if (res_().index() == 0) {
                if constexpr (std::is_void_v<res_t>) {
                    std::invoke(std::forward<F>(f), std::move(*this).res_()[index<0>]);
                    return result<res_t, E>{std::in_place};
                } else {
                    return result<res_t, E>{
                        std::in_place,
                        std::invoke(std::forward<F>(f), std::move(*this).res_()[index<0>])};
                }
            } else {
                if constexpr (std::is_void_v<E>) {
                    return result<res_t, E>{in_place_error};
                } else {
                    return result<res_t, E>{in_place_error,
                                            std::move(*this).res_()[index<1>]};
                }
            }
        }
    }
 
    /// @brief Perforams a transformation on the ok value of a @ref result
    ///
    /// @details
    /// If the @ref result contains an ok value, that value is passed to the
    /// transformation callable provided. The value returned from the callable
    /// is then returned from this function as the ok value of a new @ref
    /// result, where ok type of the new result is the exact type returned
    /// from the callable. If the @ref result contains an error value, a copy
    /// of the error is returned.
    ///
    /// Note that this function is idential to @ref transform, but the name
    /// `map` is the more typical name of this monadic operation outside of
    /// C++.
    ///
    /// ## Example
    /// ```
    /// result<int, std::string> res1{42};
    /// result<int, std::string> res2{in_place_error, "oh no"};
    ///
    /// auto res1_mapped = res1.map([](auto value) {
    ///     return std::to_string(value);
    /// });
    /// auto res2_mapped = res2.map([](auto value) {
    ///     return std::to_string(value);
    /// });
    ///
    /// assert(res1_mapped.is_error());
    /// assert(res1_mapped.error() == "oh no");
    ///
    /// assert(res2_mapped.is_ok());
    /// assert(*res2_mapped == "42");
    /// ```
    template <typename F>
    constexpr auto map(F&& f) & {
        return transform(std::forward<F>(f));
    }
 
    /// @brief Perforams a transformation on the ok value of a @ref result
    ///
    /// @details
    /// If the @ref result contains an ok value, that value is passed to the
    /// transformation callable provided. The value returned from the callable
    /// is then returned from this function as the ok value of a new @ref
    /// result, where ok type of the new result is the exact type returned
    /// from the callable. If the @ref result contains an error value, a copy
    /// of the error is returned.
    ///
    /// Note that this function is idential to @ref transform, but the name
    /// `map` is the more typical name of this monadic operation outside of
    /// C++.
    ///
    /// ## Example
    /// ```
    /// const result<int, std::string> res1{42};
    /// const result<int, std::string> res2{in_place_error, "oh no"};
    ///
    /// auto res1_mapped = res1.map([](auto value) {
    ///     return std::to_string(value);
    /// });
    /// auto res2_mapped = res2.map([](auto value) {
    ///     return std::to_string(value);
    /// });
    ///
    /// assert(res1_mapped.is_error());
    /// assert(res1_mapped.error() == "oh no");
    ///
    /// assert(res2_mapped.is_ok());
    /// assert(*res2_mapped == "42");
    /// ```
    template <typename F>
    constexpr auto map(F&& f) const& {
        return transform(std::forward<F>(f));
    }
 
    /// @brief Perforams a transformation on the ok value of a @ref result
    ///
    /// @details
    /// If the @ref result contains an ok value, that value is passed to the
    /// transformation callable provided. The value returned from the callable
    /// is then returned from this function as the ok value of a new @ref
    /// result, where ok type of the new result is the exact type returned
    /// from the callable. If the @ref result contains an error value, the
    /// error is returned.
    ///
    /// Note that this function is idential to @ref transform, but the name
    /// `map` is the more typical name of this monadic operation outside of
    /// C++.
    ///
    /// ## Example
    /// ```
    /// result<int, std::string> res1{42};
    /// result<int, std::string> res2{in_place_error, "oh no"};
    ///
    /// auto res1_mapped = std::move(res1).map([](auto value) {
    ///     return std::to_string(value);
    /// });
    /// auto res2_mapped = std::move(res2).map([](auto value) {
    ///     return std::to_string(value);
    /// });
    ///
    /// assert(res1_mapped.is_error());
    /// assert(res1_mapped.error() == "oh no");
    ///
    /// assert(res2_mapped.is_ok());
    /// assert(*res2_mapped == "42");
    /// ```
    template <typename F>
    constexpr auto map(F&& f) && {
        return std::move(*this).transform(std::forward<F>(f));
    }
 
    /// @brief Perforams a transformation on the ok value of a @ref result
    ///
    /// @details
    /// If the @ref result contains an ok value, that value is passed to the
    /// transformation callable provided. The value returned from the callable
    /// is then returned from this function as the ok value of a new @ref
    /// result, where ok type of the new result is the exact type returned
    /// from the callable. If the @ref result contains an error value, the
    /// error is returned.
    ///
    /// Note that this function is idential to @ref transform, but the name
    /// `map` is the more typical name of this monadic operation outside of
    /// C++.
    ///
    /// ## Example
    /// ```
    /// const result<int, std::string> res1{42};
    /// const result<int, std::string> res2{in_place_error, "oh no"};
    ///
    /// auto res1_mapped = std::move(res1).map([](auto value) {
    ///     return std::to_string(value);
    /// });
    /// auto res2_mapped = std::move(res2).map([](auto value) {
    ///     return std::to_string(value);
    /// });
    ///
    /// assert(res1_mapped.is_error());
    /// assert(res1_mapped.error() == "oh no");
    ///
    /// assert(res2_mapped.is_ok());
    /// assert(*res2_mapped == "42");
    /// ```
    template <typename F>
    constexpr auto map(F&& f) const&& {
        return std::move(*this).transform(std::forward<F>(f));
    }
 
    /// @brief Returns the result of invoking `f` if the @ref result is an error
    ///
    /// @details
    /// If the @ref result contains an ok value, a copy of the entire @ref
    /// result is returned. If the @ref result contains an error value, `f` is
    /// invoked with the error value as an argument, and the returned value
    /// from invoking `f` is returned from this function, converting to
    /// `result<T, E>` if necessary.
    ///
    /// ## Example
    /// ```
    /// result<int, std::string> res1{42};
    /// result<int, std::string> res2{in_place_error, "oh no"};
    ///
    /// auto res1_new = res1.or_else([]([[maybe_unused]] const auto& err) {
    ///     return 0;
    /// });
    /// auto res2_new = res2.or_else([]([[maybe_unused]] const auto& err) {
    ///     return 0;
    /// });
    ///
    /// assert(res1_new.is_ok());
    /// assert(*res1_new == 42);
    ///
    /// assert(res2_new.is_ok());
    /// assert(*res2_new == 0);
    /// ```
    template <typename F>
    constexpr result or_else(F&& f) const& {
        if (res_().index() == 0) {
            return *this;
        } else {
            if constexpr (std::is_void_v<E>) {
                return std::invoke(std::forward<F>(f), void_v);
            } else {
                return std::invoke(std::forward<F>(f), res_()[index<1>]);
            }
        }
    }
 
    /// @brief Returns the result of invoking `f` if the @ref result is an error
    ///
    /// @details
    /// If the @ref result contains an ok value, the entire @ref
    /// result is returned. If the @ref result contains an error value, `f` is
    /// invoked with the error value as an argument, and the returned value
    /// from invoking `f` is returned from this function, converting to
    /// `result<T, E>` if necessary.
    ///
    /// ## Example
    /// ```
    /// result<int, std::string> res1{42};
    /// result<int, std::string> res2{in_place_error, "oh no"};
    ///
    /// auto res1_new = std::move(res1).or_else([]([[maybe_unused]] auto err) {
    ///     return 0;
    /// });
    /// auto res2_new = std::move(res2).or_else([]([[maybe_unused]] auto err) {
    ///     return 0;
    /// });
    ///
    /// assert(res1_new.is_ok());
    /// assert(*res1_new == 42);
    ///
    /// assert(res2_new.is_ok());
    /// assert(*res2_new == 0);
    /// ```
    template <typename F>
    constexpr result or_else(F&& f) && {
        if (res_().index() == 0) {
            return std::move(*this);
        } else {
            if constexpr (std::is_void_v<E>) {
                return std::invoke(std::forward<F>(f), void_v);
            } else {
                return std::invoke(std::forward<F>(f), std::move(res_()[index<1>]));
            }
        }
    }
 
    /// @brief Converts `result<result<T, E1>, E2>` into `result<T, E3>`
    ///
    /// @details
    /// If the outer @ref result contains an error, a copy of that error is
    /// returned. If the outer @ref result contains an ok value, and the inner
    /// @ref result contains an error, a copy of that inner error is returned.
    /// If the outer @ref result contains an ok value and the inner @ref result
    /// contains an ok value, a copy of that inner ok value is returned.
    ///
    /// If the outer @ref result and the inner @ref result have different error
    /// types, the returned @ref result will be one of these two types based on
    /// the following priority rules:
    ///
    /// 1. If the outer error type is `void`, use the inner error type
    /// 2. Else, if the inner error type is `void`, use the outer error type
    /// 3. Else, if the outer error type is constructible from the inner error
    ///    type, use the outer error type.
    /// 4. Else, if the inner error type is constructible from the outer error
    ///    type, use the inner error type.
    ///
    /// Note that only one level of @ref result is removed. For example, a
    /// `result<result<result<T, E>, E>, E>` will flatten to a
    /// `result<result<T, E>, E>`.
    ///
    /// ## Example
    /// ```
    /// result<result<int, const char*>, std::string> res1{in_place, 42};
    /// result<result<int, const char*>, std::string> res2{
    ///         in_place, in_place_error, "oh no"};
    /// result<result<int, const char*>, std::string> res3{
    ///         in_place_error, "oh no"};
    ///
    /// result<int, std::string> res1_flat = res1.flatten();
    /// result<int, std::string> res2_flat = res2.flatten();
    /// result<int, std::string> res3_flat = res3.flatten();
    ///
    /// assert(res1_flat.is_ok());
    /// assert(*res1_flat == 42);
    ///
    /// assert(res2_flat.is_error());
    /// assert(res2_flat.error() == "oh no");
    ///
    /// assert(res3_flat.is_error());
    /// assert(res3_flat.error() == "oh no");
    /// ```
    [[nodiscard]] constexpr auto flatten() const&
#ifndef DOXYGEN
        requires(detail::is_result_v<T>)
#endif
    {
        if constexpr (std::is_void_v<typename T::error_type>) {
            using ret_t = result<typename T::value_type, E>;
            if (is_ok()) {
                return ret_t{res_()[index<0>]};
            } else {
                if constexpr (std::is_void_v<E>) {
                    return ret_t{in_place_error};
                } else {
                    return ret_t{in_place_error, error()};
                }
            }
        } else if constexpr (std::is_void_v<E>) {
            using ret_t = T;
            if (is_ok()) {
                return res_()[index<0>];
            } else {
                return ret_t{in_place_error, error()};
            }
        } else if constexpr (detail::traits<E>::template is_constructible<
                                 typename T::error_const_reference>) {
            using ret_t = result<typename T::value_type, E>;
            if (is_ok()) {
                return ret_t{res_()[index<0>]};
            } else {
                return ret_t{in_place_error, error()};
            }
        } else if constexpr (detail::traits<typename T::error_type>::
                                 template is_constructible<error_const_reference>) {
            using ret_t = T;
            if (is_ok()) {
                return res_()[index<0>];
            } else {
                return ret_t{in_place_error, error()};
            }
        }
    }
 
    /// @brief Converts `result<result<T, E1>, E2>` into `result<T, E3>`
    ///
    /// @details
    /// If the outer @ref result contains an error, that error is
    /// returned. If the outer @ref result contains an ok value, and the inner
    /// @ref result contains an error, that inner error is returned.
    /// If the outer @ref result contains an ok value and the inner @ref result
    /// contains an ok value, that inner ok value is returned.
    ///
    /// If the outer @ref result and the inner @ref result have different error
    /// types, the returned @ref result will be one of these two types based on
    /// the following priority rules:
    ///
    /// 1. If the outer error type is `void`, use the inner error type
    /// 2. Else, if the inner error type is `void`, use the outer error type
    /// 3. Else, if the outer error type is constructible from the inner error
    ///    type, use the outer error type.
    /// 4. Else, if the inner error type is constructible from the outer error
    ///    type, use the inner error type.
    ///
    /// Note that only one level of @ref result is removed. For example, a
    /// `result<result<result<T, E>, E>, E>` will flatten to a
    /// `result<result<T, E>, E>`.
    ///
    /// ## Example
    /// ```
    /// result<result<int, const char*>, std::string> res1{in_place, 42};
    /// result<result<int, const char*>, std::string> res2{
    ///         in_place, in_place_error, "oh no"};
    /// result<result<int, const char*>, std::string> res3{
    ///         in_place_error, "oh no"};
    ///
    /// result<int, std::string> res1_flat = std::move(res1).flatten();
    /// result<int, std::string> res2_flat = std::move(res2).flatten();
    /// result<int, std::string> res3_flat = std::move(res3).flatten();
    ///
    /// assert(res1_flat.is_ok());
    /// assert(*res1_flat == 42);
    ///
    /// assert(res2_flat.is_error());
    /// assert(res2_flat.error() == "oh no");
    ///
    /// assert(res3_flat.is_error());
    /// assert(res3_flat.error() == "oh no");
    /// ```
    [[nodiscard]] constexpr auto flatten() &&
#ifndef DOXYGEN
        requires(detail::is_result_v<T>)
#endif
    {
        if constexpr (std::is_void_v<typename T::error_type>) {
            using ret_t = result<typename T::value_type, E>;
            if (is_ok()) {
                return ret_t{std::move(res_()[index<0>])};
            } else {
                if constexpr (std::is_void_v<E>) {
                    return ret_t{in_place_error};
                } else {
                    return ret_t{in_place_error, std::move(error())};
                }
            }
        } else if constexpr (std::is_void_v<E>) {
            using ret_t = T;
            if (is_ok()) {
                return std::move(res_()[index<0>]);
            } else {
                return ret_t{in_place_error, std::move(error())};
            }
        } else if constexpr (detail::traits<E>::template is_constructible<
                                 typename T::error_rvalue_reference>) {
            using ret_t = result<typename T::value_type, E>;
            if (is_ok()) {
                return ret_t{std::move(res_()[index<0>])};
            } else {
                return ret_t{in_place_error, std::move(error())};
            }
        } else if constexpr (detail::traits<typename T::error_type>::
                                 template is_constructible<error_rvalue_reference>) {
            using ret_t = T;
            if (is_ok()) {
                return std::move(res_()[index<0>]);
            } else {
                return ret_t{in_place_error, std::move(error())};
            }
        }
    }
 
    /// @brief Converts nested @ref result types into a single @ref result
    ///
    /// @details
    /// Like @ref flatten, this function removes nested layers of @ref result,
    /// such as converting `result<result<T, E>, E>` into `result<T, E>`.
    /// However, unlike @ref flatten, this function removes all layers of
    /// nesting and works for unnested @ref result types. For example,
    /// `result<result<result<T, E>, E, E>` is converted directly to
    /// `result<T, E>`, and for `result<T, E>`, where `T` is not a @ref result
    /// type, no layers of @ref result are removed.
    ///
    /// ## Example
    /// ```
    /// using nested_result_t =
    ///     result<result<result<int, std::string>, std::string, std::string>;
    ///
    /// nested_result_t res1{in_place, in_place, in_place, 42};
    /// nested_result_t res2{in_place_error, "oh no"};
    /// nested_result_t res3{in_place, in_place_error, "oh no"};
    /// nested_result_t res4{in_place, in_place, in_place_error, "oh no"};
    ///
    /// result<int, std::string> res1_flat = res1.flatten_all();
    /// result<int, std::string> res2_flat = res2.flatten_all();
    /// result<int, std::string> res3_flat = res3.flatten_all();
    /// result<int, std::string> res4_flat = res4.flatten_all();
    ///
    /// assert(res1_flat.is_ok());
    /// assert(*res1_flat == 42);
    ///
    /// assert(res2_flat.is_error());
    /// assert(res2_flat.error() == "oh no");
    ///
    /// assert(res3_flat.is_error());
    /// assert(res3_flat.error() == "oh no");
    ///
    /// assert(res3_flat.is_error());
    /// assert(res3_flat.error() == "oh no");
    /// ```
    [[nodiscard]] constexpr auto flatten_all() const& {
        if constexpr (detail::is_result_v<T>) {
            return flatten().flatten_all();
        } else {
            return *this;
        }
    }
 
    /// @brief Converts nested @ref result types into a single @ref result
    ///
    /// @details
    /// Like @ref flatten, this function removes nested layers of @ref result,
    /// such as converting `result<result<T, E>, E>` into `result<T, E>`.
    /// However, unlike @ref flatten, this function removes all layers of
    /// nesting and works for unnested @ref result types. For example,
    /// `result<result<result<T, E>, E, E>` is converted directly to
    /// `result<T, E>`, and for `result<T, E>`, where `T` is not a @ref result
    /// type, no layers of @ref result are removed.
    ///
    /// ## Example
    /// ```
    /// using nested_result_t =
    ///     result<result<result<int, std::string>, std::string, std::string>;
    ///
    /// nested_result_t res1{in_place, in_place, in_place, 42};
    /// nested_result_t res2{in_place_error, "oh no"};
    /// nested_result_t res3{in_place, in_place_error, "oh no"};
    /// nested_result_t res4{in_place, in_place, in_place_error, "oh no"};
    ///
    /// result<int, std::string> res1_flat = std::move(res1).flatten_all();
    /// result<int, std::string> res2_flat = std::move(res2).flatten_all();
    /// result<int, std::string> res3_flat = std::move(res3).flatten_all();
    /// result<int, std::string> res4_flat = std::move(res4).flatten_all();
    ///
    /// assert(res1_flat.is_ok());
    /// assert(*res1_flat == 42);
    ///
    /// assert(res2_flat.is_error());
    /// assert(res2_flat.error() == "oh no");
    ///
    /// assert(res3_flat.is_error());
    /// assert(res3_flat.error() == "oh no");
    ///
    /// assert(res3_flat.is_error());
    /// assert(res3_flat.error() == "oh no");
    /// ```
    [[nodiscard]] constexpr auto flatten_all() && {
        if constexpr (detail::is_result_v<T>) {
            return std::move(*this).flatten().flatten_all();
        } else {
            return std::move(*this);
        }
    }
 
    /// @brief Converts `result<option<T>, E>` into `option<result<T, E>>`
    ///
    /// @details
    /// If the @ref result contains an error, the return value will be a @ref
    /// option that contains a @ref result that contains an error. If the @ref
    /// result contains an @ref option that contains a value, the return value
    /// will be a @ref option that contains @ref result that contains an ok
    /// value. If the @ref result contains a @ref option that is `none`, the
    /// return value will be an @ref option that is `none`.
    ///
    /// This function only participates in overload resolution of `T` is an
    /// @ref option.
    ///
    /// ## Example
    /// ```
    /// result<option<int>, std::string> val1{42};
    /// result<option<int>, std::string> val2{none};
    /// result<option<int>, std::string> val3{in_place_error, "oh no"};
    ///
    /// auto val1_trans = val1.transpose();
    /// auto val2_trans = val2.transpose();
    /// auto val3_trans = val3.transpose();
    ///
    /// assert(val1_trans.is_some());
    /// assert(val1_trans->is_ok());
    /// assert(**val1_trans == 42);
    ///
    /// assert(val2_trans.is_none());
    ///
    /// assert(val3_trans.is_some());
    /// assert(val3_trans->is_error());
    /// assert(val3_trans->error() == "oh no");
    /// ```
    [[nodiscard]] constexpr auto transpose() const&
#ifndef DOXYGEN
        requires(detail::is_option_v<T>)
#endif
    {
        using ret_t = option<result<typename T::value_type, E>>;
        if (is_ok()) {
            if (res_()[index<0>].is_some()) {
                return ret_t{in_place, in_place, *res_()[index<0>]};
            } else {
                return ret_t{none};
            }
        } else {
            return ret_t{in_place, in_place_error, error()};
        }
    }
 
    /// @brief Converts `result<option<T>, E>` into `option<result<T, E>>`
    ///
    /// @details
    /// If the @ref result contains an error, the return value will be a @ref
    /// option that contains a @ref result that contains an error. If the @ref
    /// result contains an @ref option that contains a value, the return value
    /// will be a @ref option that contains @ref result that contains an ok
    /// value. If the @ref result contains a @ref option that is `none`, the
    /// return value will be an @ref option that is `none`.
    ///
    /// This function only participates in overload resolution of `T` is an
    /// @ref option.
    ///
    /// ## Example
    /// ```
    /// result<option<int>, std::string> val1{42};
    /// result<option<int>, std::string> val2{none};
    /// result<option<int>, std::string> val3{in_place_error, "oh no"};
    ///
    /// auto val1_trans = std::move(val1).transpose();
    /// auto val2_trans = std::move(val2).transpose();
    /// auto val3_trans = std::move(val3).transpose();
    ///
    /// assert(val1_trans.is_some());
    /// assert(val1_trans->is_ok());
    /// assert(**val1_trans == 42);
    ///
    /// assert(val2_trans.is_none());
    ///
    /// assert(val3_trans.is_some());
    /// assert(val3_trans->is_error());
    /// assert(val3_trans->error() == "oh no");
    /// ```
    [[nodiscard]] constexpr auto transpose() &&
#ifndef DOXYGEN
        requires(detail::is_option_v<T>)
#endif
    {
        using ret_t = option<result<typename T::value_type, E>>;
        if (is_ok()) {
            if (res_()[index<0>].is_some()) {
                return ret_t{in_place, in_place, std::move(*res_()[index<0>])};
            } else {
                return ret_t{none};
            }
        } else {
            return ret_t{in_place, in_place_error, std::move(error())};
        }
    }
 
    /// @brief Swaps the ok and error types of a @ref result
    ///
    /// @details
    /// If the @ref result contains an ok value, a copy of the ok value will be
    /// returned as an error. If the @ref result contains an error value, the
    /// error value will be returned as an ok value.
    ///
    /// ## Example
    /// ```
    /// result<int, std::string> res1{42};
    /// result<int, std::string> res2{in_place_error, "oh no"};
    ///
    /// result<std::string, int> res1_inv = res1.invert();
    /// result<std::string, int> res2_inv = res2.invert();
    ///
    /// assert(res1_inv.is_error());
    /// assert(res1_inv.error() == 42);
    ///
    /// assert(res2_inv.is_ok());
    /// assert(*res2_inv == "oh no");
    /// ```
    [[nodiscard]] constexpr result<E, T> invert() const& {
        if (is_ok()) {
            return result<E, T>{in_place_error, res_()[0]};
        } else {
            return result<E, T>{in_place, error()};
        }
    }
 
    /// @brief Swaps the ok and error types of a @ref result
    ///
    /// @details
    /// If the @ref result contains an ok value, a copy of the ok value will be
    /// returned as an error. If the @ref result contains an error value, the
    /// error value will be returned as an ok value.
    ///
    /// ## Example
    /// ```
    /// result<int, std::string> res1{42};
    /// result<int, std::string> res2{in_place_error, "oh no"};
    ///
    /// result<std::string, int> res1_inv = std::move(res1).invert();
    /// result<std::string, int> res2_inv = std::move(res2).invert();
    ///
    /// assert(res1_inv.is_error());
    /// assert(res1_inv.error() == 42);
    ///
    /// assert(res2_inv.is_ok());
    /// assert(*res2_inv == "oh no");
    /// ```
    [[nodiscard]] constexpr result<E, T> invert() && {
        if (is_ok()) {
            return result<E, T>{in_place_error, std::move(res_()[0])};
        } else {
            return result<E, T>{in_place, std::move(error())};
        }
    }
 
    /// @brief Perforams a transformation on the error value of a @ref result
    ///
    /// @details
    /// If the @ref result contains an error value, that value is passed to the
    /// transformation callable provided. The value returned from the callable
    /// is then returned from this function as the error value of a new @ref
    /// result, where the error type of the new result is the exact type
    /// returned from the callable. If the @ref result contains an ok value, a
    /// copy of the ok value is returned.
    ///
    /// Note that this function is identical to @ref map_error, but the name
    /// `transform_error` makes @ref result able to be a drop in replacement
    /// for `std::expected`. `map_error` would be the more typical name of
    /// this monadic operation outside of C++.
    ///
    /// ## Example
    /// ```
    /// result<void, int> res1{};
    /// result<void, int> res2{in_place_error, 42};
    ///
    /// auto res1_mapped = res1.transform_error([](auto value) {
    ///     return std::to_string(value);
    /// });
    /// auto res2_mapped = res2.transform_error([](auto value) {
    ///     return std::to_string(value);
    /// });
    ///
    /// assert(res1_mapped.is_ok());
    ///
    /// assert(res2_mapped.is_error());
    /// assert(*res2_mapped == "42");
    /// ```
    template <typename F>
    constexpr auto transform_error(F&& f) & {
        if constexpr (std::is_void_v<E>) {
            using res_t = std::invoke_result_t<F, void_t>;
            if (res_().index() != 0) {
                if constexpr (std::is_void_v<res_t>) {
                    std::invoke(std::forward<F>(f), void_v);
                    return result<T, res_t>{in_place_error};
                } else {
                    return result<T, res_t>{in_place_error,
                                            std::invoke(std::forward<F>(f), void_v)};
                }
            } else {
                if constexpr (std::is_void_v<T>) {
                    return result<T, res_t>{std::in_place};
                } else {
                    return result<T, res_t>{std::in_place, res_()[index<0>]};
                }
            }
        } else {
            using res_t = std::invoke_result_t<F, error_reference>;
            if (res_().index() != 0) {
                if constexpr (std::is_void_v<res_t>) {
                    std::invoke(std::forward<F>(f), res_()[index<1>]);
                    return result<T, res_t>{in_place_error};
                } else {
                    return result<T, res_t>{
                        in_place_error, std::invoke(std::forward<F>(f), res_()[index<1>])};
                }
            } else {
                if constexpr (std::is_void_v<T>) {
                    return result<T, res_t>{std::in_place};
                } else {
                    return result<T, res_t>{std::in_place, res_()[index<0>]};
                }
            }
        }
    }
 
    /// @brief Perforams a transformation on the error value of a @ref result
    ///
    /// @details
    /// If the @ref result contains an error value, that value is passed to the
    /// transformation callable provided. The value returned from the callable
    /// is then returned from this function as the error value of a new @ref
    /// result, where the error type of the new result is the exact type
    /// returned from the callable. If the @ref result contains an ok value, a
    /// copy of the ok value is returned.
    ///
    /// Note that this function is identical to @ref map_error, but the name
    /// `transform_error` makes @ref result able to be a drop in replacement
    /// for `std::expected`. `map_error` would be the more typical name of
    /// this monadic operation outside of C++.
    ///
    /// ## Example
    /// ```
    /// const result<void, int> res1{};
    /// const result<void, int> res2{in_place_error, 42};
    ///
    /// auto res1_mapped = res1.transform_error([](auto value) {
    ///     return std::to_string(value);
    /// });
    /// auto res2_mapped = res2.transform_error([](auto value) {
    ///     return std::to_string(value);
    /// });
    ///
    /// assert(res1_mapped.is_ok());
    ///
    /// assert(res2_mapped.is_error());
    /// assert(*res2_mapped == "42");
    /// ```
    template <typename F>
    constexpr auto transform_error(F&& f) const& {
        if constexpr (std::is_void_v<E>) {
            using res_t = std::invoke_result_t<F, void_t>;
            if (res_().index() != 0) {
                if constexpr (std::is_void_v<res_t>) {
                    std::invoke(std::forward<F>(f), void_v);
                    return result<T, res_t>{in_place_error};
                } else {
                    return result<T, res_t>{in_place_error,
                                            std::invoke(std::forward<F>(f), void_v)};
                }
            } else {
                if constexpr (std::is_void_v<T>) {
                    return result<T, res_t>{std::in_place};
                } else {
                    return result<T, res_t>{std::in_place, res_()[index<0>]};
                }
            }
        } else {
            using res_t = std::invoke_result_t<F, error_const_reference>;
            if (res_().index() != 0) {
                if constexpr (std::is_void_v<res_t>) {
                    std::invoke(std::forward<F>(f), res_()[index<1>]);
                    return result<T, res_t>{in_place_error};
                } else {
                    return result<T, res_t>{
                        in_place_error, std::invoke(std::forward<F>(f), res_()[index<1>])};
                }
            } else {
                if constexpr (std::is_void_v<T>) {
                    return result<T, res_t>{std::in_place};
                } else {
                    return result<T, res_t>{std::in_place, res_()[index<0>]};
                }
            }
        }
    }
 
    /// @brief Perforams a transformation on the error value of a @ref result
    ///
    /// @details
    /// If the @ref result contains an error value, that value is passed to the
    /// transformation callable provided. The value returned from the callable
    /// is then returned from this function as the error value of a new @ref
    /// result, where the error type of the new result is the exact type
    /// returned from the callable. If the @ref result contains an ok value,
    /// the ok value is returned.
    ///
    /// Note that this function is identical to @ref map_error, but the name
    /// `transform_error` makes @ref result able to be a drop in replacement
    /// for `std::expected`. `map_error` would be the more typical name of
    /// this monadic operation outside of C++.
    ///
    /// ## Example
    /// ```
    /// result<void, int> res1{};
    /// result<void, int> res2{in_place_error, 42};
    ///
    /// auto res1_mapped = std::move(res1).transform_error([](auto value) {
    ///     return std::to_string(value);
    /// });
    /// auto res2_mapped = std::move(res2).transform_error([](auto value) {
    ///     return std::to_string(value);
    /// });
    ///
    /// assert(res1_mapped.is_ok());
    ///
    /// assert(res2_mapped.is_error());
    /// assert(*res2_mapped == "42");
    /// ```
    template <typename F>
    constexpr auto transform_error(F&& f) && {
        if constexpr (std::is_void_v<E>) {
            using res_t = std::invoke_result_t<F, void_t>;
            if (res_().index() != 0) {
                if constexpr (std::is_void_v<res_t>) {
                    std::invoke(std::forward<F>(f), void_v);
                    return result<T, res_t>{in_place_error};
                } else {
                    return result<T, res_t>{in_place_error,
                                            std::invoke(std::forward<F>(f), void_v)};
                }
            } else {
                if constexpr (std::is_void_v<T>) {
                    return result<T, res_t>{std::in_place};
                } else {
                    return result<T, res_t>{std::in_place,
                                            std::move(*this).res_()[index<0>]};
                }
            }
        } else {
            using res_t = std::invoke_result_t<F, error_rvalue_reference>;
            if (res_().index() != 0) {
                if constexpr (std::is_void_v<res_t>) {
                    std::invoke(std::forward<F>(f), std::move(*this).res_()[index<1>]);
                    return result<T, res_t>{in_place_error};
                } else {
                    return result<T, res_t>{
                        in_place_error,
                        std::invoke(std::forward<F>(f), std::move(*this).res_()[index<1>])};
                }
            } else {
                if constexpr (std::is_void_v<T>) {
                    return result<T, res_t>{std::in_place};
                } else {
                    return result<T, res_t>{std::in_place,
                                            std::move(*this).res_()[index<0>]};
                }
            }
        }
    }
 
    /// @brief Perforams a transformation on the error value of a @ref result
    ///
    /// @details
    /// If the @ref result contains an error value, that value is passed to the
    /// transformation callable provided. The value returned from the callable
    /// is then returned from this function as the error value of a new @ref
    /// result, where the error type of the new result is the exact type
    /// returned from the callable. If the @ref result contains an ok value,
    /// the ok value is returned.
    ///
    /// Note that this function is identical to @ref map_error, but the name
    /// `transform_error` makes @ref result able to be a drop in replacement
    /// for `std::expected`. `map_error` would be the more typical name of
    /// this monadic operation outside of C++.
    ///
    /// ## Example
    /// ```
    /// const result<void, int> res1{};
    /// const result<void, int> res2{in_place_error, 42};
    ///
    /// auto res1_mapped = std::move(res1).transform_error([](auto value) {
    ///     return std::to_string(value);
    /// });
    /// auto res2_mapped = std::move(res2).transform_error([](auto value) {
    ///     return std::to_string(value);
    /// });
    ///
    /// assert(res1_mapped.is_ok());
    ///
    /// assert(res2_mapped.is_error());
    /// assert(*res2_mapped == "42");
    /// ```
    template <typename F>
    constexpr auto transform_error(F&& f) const&& {
        if constexpr (std::is_void_v<E>) {
            using res_t = std::invoke_result_t<F, void_t>;
            if (res_().index() != 0) {
                if constexpr (std::is_void_v<res_t>) {
                    std::invoke(std::forward<F>(f));
                    return result<T, res_t>{in_place_error};
                } else {
                    return result<T, res_t>{in_place_error,
                                            std::invoke(std::forward<F>(f), void_v)};
                }
            } else {
                if constexpr (std::is_void_v<T>) {
                    return result<T, res_t>{std::in_place};
                } else {
                    return result<T, res_t>{std::in_place,
                                            std::move(*this).res_()[index<0>]};
                }
            }
        } else {
            using res_t = std::invoke_result_t<F, error_const_rvalue_reference>;
            if (res_().index() != 0) {
                if constexpr (std::is_void_v<res_t>) {
                    std::invoke(std::forward<F>(f), std::move(*this).res_()[index<1>]);
                    return result<T, res_t>{in_place_error};
                } else {
                    return result<T, res_t>{
                        in_place_error,
                        std::invoke(std::forward<F>(f), std::move(*this).res_()[index<1>])};
                }
            } else {
                if constexpr (std::is_void_v<T>) {
                    return result<T, res_t>{std::in_place};
                } else {
                    return result<T, res_t>{std::in_place,
                                            std::move(*this).res_()[index<0>]};
                }
            }
        }
    }
 
    /// @brief Perforams a transformation on the error value of a @ref result
    ///
    /// @details
    /// If the @ref result contains an error value, that value is passed to the
    /// transformation callable provided. The value returned from the callable
    /// is then returned from this function as the error value of a new @ref
    /// result, where the error type of the new result is the exact type
    /// returned from the callable. If the @ref result contains an ok value, a
    /// copy of the ok value is returned.
    ///
    /// Note that this function is identical to @ref transform_error, but the
    /// name `map_error` is more typical for this sort of monadic operation
    /// outside of C++.
    ///
    /// ## Example
    /// ```
    /// result<void, int> res1{};
    /// result<void, int> res2{in_place_error, 42};
    ///
    /// auto res1_mapped = res1.map_error([](auto value) {
    ///     return std::to_string(value);
    /// });
    /// auto res2_mapped = res2.map_error([](auto value) {
    ///     return std::to_string(value);
    /// });
    ///
    /// assert(res1_mapped.is_ok());
    ///
    /// assert(res2_mapped.is_error());
    /// assert(*res2_mapped == "42");
    /// ```
    template <typename F>
    constexpr auto map_error(F&& f) & {
        return transform_error(std::forward<F>(f));
    }
 
    /// @brief Perforams a transformation on the error value of a @ref result
    ///
    /// @details
    /// If the @ref result contains an error value, that value is passed to the
    /// transformation callable provided. The value returned from the callable
    /// is then returned from this function as the error value of a new @ref
    /// result, where the error type of the new result is the exact type
    /// returned from the callable. If the @ref result contains an ok value, a
    /// copy of the ok value is returned.
    ///
    /// Note that this function is identical to @ref transform_error, but the
    /// name `map_error` is more typical for this sort of monadic operation
    /// outside of C++.
    ///
    /// ## Example
    /// ```
    /// const result<void, int> res1{};
    /// const result<void, int> res2{in_place_error, 42};
    ///
    /// auto res1_mapped = res1.map_error([](auto value) {
    ///     return std::to_string(value);
    /// });
    /// auto res2_mapped = res2.map_error([](auto value) {
    ///     return std::to_string(value);
    /// });
    ///
    /// assert(res1_mapped.is_ok());
    ///
    /// assert(res2_mapped.is_error());
    /// assert(*res2_mapped == "42");
    /// ```
    template <typename F>
    constexpr auto map_error(F&& f) const& {
        return transform_error(std::forward<F>(f));
    }
 
    /// @brief Perforams a transformation on the error value of a @ref result
    ///
    /// @details
    /// If the @ref result contains an error value, that value is passed to the
    /// transformation callable provided. The value returned from the callable
    /// is then returned from this function as the error value of a new @ref
    /// result, where the error type of the new result is the exact type
    /// returned from the callable. If the @ref result contains an ok value,
    /// the ok value is returned.
    ///
    /// Note that this function is identical to @ref transform_error, but the
    /// name `map_error` is more typical for this sort of monadic operation
    /// outside of C++.
    ///
    /// ## Example
    /// ```
    /// result<void, int> res1{};
    /// result<void, int> res2{in_place_error, 42};
    ///
    /// auto res1_mapped = std::move(res1).map_error([](auto value) {
    ///     return std::to_string(value);
    /// });
    /// auto res2_mapped = std::move(res2).map_error([](auto value) {
    ///     return std::to_string(value);
    /// });
    ///
    /// assert(res1_mapped.is_ok());
    ///
    /// assert(res2_mapped.is_error());
    /// assert(*res2_mapped == "42");
    /// ```
    template <typename F>
    constexpr auto map_error(F&& f) && {
        return std::move(*this).transform_error(std::forward<F>(f));
    }
 
    /// @brief Perforams a transformation on the error value of a @ref result
    ///
    /// @details
    /// If the @ref result contains an error value, that value is passed to the
    /// transformation callable provided. The value returned from the callable
    /// is then returned from this function as the error value of a new @ref
    /// result, where the error type of the new result is the exact type
    /// returned from the callable. If the @ref result contains an ok value,
    /// the ok value is returned.
    ///
    /// Note that this function is identical to @ref transform_error, but the
    /// name `map_error` is more typical for this sort of monadic operation
    /// outside of C++.
    ///
    /// ## Example
    /// ```
    /// result<void, int> res1{};
    /// result<void, int> res2{in_place_error, 42};
    ///
    /// auto res1_mapped = std::move(res1).map_error([](auto value) {
    ///     return std::to_string(value);
    /// });
    /// auto res2_mapped = std::move(res2).map_error([](auto value) {
    ///     return std::to_string(value);
    /// });
    ///
    /// assert(res1_mapped.is_ok());
    ///
    /// assert(res2_mapped.is_error());
    /// assert(*res2_mapped == "42");
    /// ```
    template <typename F>
    constexpr auto map_error(F&& f) const&& {
        return std::move(*this).transform_error(std::forward<F>(f));
    }
 
    /// @brief Converts a @ref result reference into a @ref result of references
    ///
    /// @details
    /// ## Example
    /// ```
    /// result<int, std::string> res1{42};
    /// result<int, std::string> res2{in_place_error, "oh no"};
    ///
    /// result<int&, std::string&> res1_ref = res1.ref();
    /// result<int&, std::string&> ref2_ref = res2.ref();
    ///
    /// assert(res1_ref.is_ok());
    /// assert(&*res1_ref == &*res1);
    ///
    /// assert(res2_ref.is_error());
    /// assert(&res2_ref.error() == &res2.error());
    /// ```
    [[nodiscard]] constexpr result<reference, error_reference> ref() noexcept {
        if (res_().index() == 0) {
            if constexpr (std::is_void_v<T>) {
                return result<reference, error_reference>{std::in_place};
            } else {
                return result<reference, error_reference>{std::in_place, **this};
            }
        } else {
            if constexpr (std::is_void_v<E>) {
                return result<reference, error_reference>{in_place_error};
            } else {
                return result<reference, error_reference>{in_place_error, error()};
            }
        }
    }
 
    /// @brief Converts a @ref result reference into a @ref result of references
    ///
    /// @details
    /// ## Example
    /// ```
    /// const result<int, std::string> res1{42};
    /// const result<int, std::string> res2{in_place_error, "oh no"};
    ///
    /// result<const int&, const std::string&> res1_ref = res1.ref();
    /// result<const int&, const std::string&> ref2_ref = res2.ref();
    ///
    /// assert(res1_ref.is_ok());
    /// assert(&*res1_ref == &*res1);
    ///
    /// assert(res2_ref.is_error());
    /// assert(&res2_ref.error() == &res2.error());
    /// ```
    [[nodiscard]] constexpr result<const_reference, error_const_reference> ref()
        const noexcept {
        if (res_().index() == 0) {
            if constexpr (std::is_void_v<T>) {
                return result<const_reference, error_const_reference>{std::in_place};
            } else {
                return result<const_reference, error_const_reference>{std::in_place,
                                                                      **this};
            }
        } else {
            if constexpr (std::is_void_v<E>) {
                return result<const_reference, error_const_reference>{in_place_error};
            } else {
                return result<const_reference, error_const_reference>{in_place_error,
                                                                      error()};
            }
        }
    }
 
    /// @brief Converts a @ref result reference into a @ref result of references
    ///
    /// @details
    /// ## Example
    /// ```
    /// result<int, std::string> res1{42};
    /// result<int, std::string> res2{in_place_error, "oh no"};
    ///
    /// result<const int&, const std::string&> res1_ref = res1.cref();
    /// result<const int&, const std::string&> ref2_ref = res2.cref();
    ///
    /// assert(res1_ref.is_ok());
    /// assert(&*res1_ref == &*res1);
    ///
    /// assert(res2_ref.is_error());
    /// assert(&res2_ref.error() == &res2.error());
    /// ```
    [[nodiscard]] constexpr result<const_reference, error_const_reference> cref()
        const noexcept {
        return ref();
    }
 
    /// @brief Discards error values and converts into an @ref option
    ///
    /// @details
    /// If the @ref result contains an ok value, a copy of that value is
    /// returned wrapped in an @ref option. If the @ref result contains an
    /// error, `none` is returned.
    ///
    /// ## Example
    /// ```
    /// result<int, std::string> res1{42};
    /// result<int, std::string> res2{in_place_error, "oh no"};
    ///
    /// option<int> opt1 = res1.or_none();
    /// option<int> opt2 = res2.or_none();
    ///
    /// assert(opt1.is_some());
    /// assert(*opt1 == 42);
    ///
    /// assert(opt2.is_none());
    /// ```
    [[nodiscard]] constexpr option<T> or_none() const& noexcept {
        if (res_().index() == 0) {
            if constexpr (std::is_void_v<T>) {
                return option<T>{std::in_place};
            } else {
                return option<T>{std::in_place, res_()[index<0>]};
            }
        } else {
            return option<T>{};
        }
    }
 
    /// @brief Discards error values and converts into an @ref option
    ///
    /// @details
    /// If the @ref result contains an ok value, that value is
    /// returned wrapped in an @ref option. If the @ref result contains an
    /// error, `none` is returned.
    ///
    /// ## Example
    /// ```
    /// result<int, std::string> res1{42};
    /// result<int, std::string> res2{in_place_error, "oh no"};
    ///
    /// option<int> opt1 = std::move(res1).or_none();
    /// option<int> opt2 = std::move(res2).or_none();
    ///
    /// assert(opt1.is_some());
    /// assert(*opt1 == 42);
    ///
    /// assert(opt2.is_none());
    /// ```
    [[nodiscard]] constexpr option<T> or_none() && {
        if (res_().index() == 0) {
            if constexpr (std::is_void_v<T>) {
                return option<T>{std::in_place};
            } else {
                return option<T>{std::in_place, std::move(*this).res_()[index<0>]};
            }
        } else {
            return option<T>{};
        }
    }
 
    /// @brief Discards error values and converts into an @ref option
    ///
    /// @details
    /// If the @ref result contains an ok value, a copy of that value is
    /// returned wrapped in an @ref option. If the @ref result contains an
    /// error, `none` is returned.
    ///
    /// ## Example
    /// ```
    /// result<int, std::string> res1{42};
    /// result<int, std::string> res2{in_place_error, "oh no"};
    ///
    /// option<int> opt1 = res1.ok_or_none();
    /// option<int> opt2 = res2.ok_or_none();
    ///
    /// assert(opt1.is_some());
    /// assert(*opt1 == 42);
    ///
    /// assert(opt2.is_none());
    /// ```
    [[nodiscard]] constexpr option<T> ok_or_none() const& noexcept { return or_none(); }
 
    /// @brief Discards error values and converts into an @ref option
    ///
    /// @details
    /// If the @ref result contains an ok value, that value is
    /// returned wrapped in an @ref option. If the @ref result contains an
    /// error, `none` is returned.
    ///
    /// ## Example
    /// ```
    /// result<int, std::string> res1{42};
    /// result<int, std::string> res2{in_place_error, "oh no"};
    ///
    /// option<int> opt1 = std::move(res1).ok_or_none();
    /// option<int> opt2 = std::move(res2).ok_or_none();
    ///
    /// assert(opt1.is_some());
    /// assert(*opt1 == 42);
    ///
    /// assert(opt2.is_none());
    /// ```
    [[nodiscard]] constexpr option<T> ok_or_none() && { return std::move(*this).or_none(); }
 
    /// @brief Discards ok value and converts into an @ref option
    ///
    /// @details
    /// If the @ref result contains an error value, a copy of that value is
    /// returned wrapped in an @ref option. If the @ref result contains an ok
    /// value, `none` is returned.
    ///
    /// ## Example
    /// ```
    /// result<int, std::string> res1{42};
    /// result<int, std::string> res2{in_place_error, "oh no"};
    ///
    /// option<std::string> opt1 = res1.error_or_none();
    /// option<std::string> opt2 = res2.error_or_none();
    ///
    /// assert(opt1.is_none());
    ///
    /// assert(opt2.is_some());
    /// assert(*opt2 == "oh no");
    /// ```
    [[nodiscard]] constexpr option<E> error_or_none() const& noexcept {
        if (res_().index() != 0) {
            if constexpr (std::is_void_v<E>) {
                return option<E>{std::in_place};
            } else {
                return option<E>{std::in_place, res_()[index<1>]};
            }
        } else {
            return option<E>{};
        }
    }
 
    /// @brief Discards ok value and converts into an @ref option
    ///
    /// @details
    /// If the @ref result contains an error value, that value is
    /// returned wrapped in an @ref option. If the @ref result contains an ok
    /// value, `none` is returned.
    ///
    /// ## Example
    /// ```
    /// result<int, std::string> res1{42};
    /// result<int, std::string> res2{in_place_error, "oh no"};
    ///
    /// option<std::string> opt1 = res1.error_or_none();
    /// option<std::string> opt2 = res2.error_or_none();
    ///
    /// assert(opt1.is_none());
    ///
    /// assert(opt2.is_some());
    /// assert(*opt2 == "oh no");
    /// ```
    [[nodiscard]] constexpr option<E> error_or_none() && {
        if (res_().index() != 0) {
            if constexpr (std::is_void_v<E>) {
                return option<E>{std::in_place};
            } else {
                return option<E>{std::in_place, std::move(*this).res_()[index<1>]};
            }
        } else {
            return option<E>{};
        }
    }
 
    /// @brief Constructs a new ok value in place into the @ref result
    ///
    /// @details
    /// The value previously contained in the @ref result, ok or error, is
    /// destroyed in place. The new ok value is then constructed in place
    /// as if by placement new.
    ///
    /// ## Example
    /// ```
    /// result<std::string, int> res1{in_place_error, 42};
    /// result<std::string, int> res2{""};
    ///
    /// res1.emplace(5, 'a');
    /// res2.emplace(5, 'a');
    ///
    /// assert(res1.is_ok());
    /// assert(*res1 == "aaaaa");
    ///
    /// assert(res2.is_ok());
    /// assert(*res2 == "aaaaa");
    /// ```
    template <typename... Args>
    constexpr reference emplace(Args&&... args) {
        return res_().template emplace<0>(std::forward<Args>(args)...);
    }
 
    /// @brief Constructs a new ok value in place into the @ref result
    ///
    /// @details
    /// The value previously contained in the @ref result, ok or error, is
    /// destroyed in place. The new ok value is then constructed in place
    /// as if by placement new.
    ///
    /// ## Example
    /// ```
    /// result<std::vector<int>, int> res1{in_place_error, 42};
    /// result<std::vector<int>, int> res2{};
    ///
    /// res1.emplace({1, 2, 3, 4, 5});
    /// res2.emplace({1, 2, 3, 4, 5});
    ///
    /// assert(res1.is_ok());
    /// assert(res1->size() == 5);
    ///
    /// assert(res2.is_ok());
    /// assert(res2->size() == 5);
    /// ```
    template <typename U, typename... Args>
    constexpr reference emplace(std::initializer_list<U> ilist, Args&&... args) {
        return res_().template emplace<0>(ilist, std::forward<Args>(args)...);
    }
 
    /// @brief Constructs a new error value in place into the @ref result
    ///
    /// @details
    /// The value previously contained in the @ref result, ok or error, is
    /// destroyed in place. The new error value is then constructed in place
    /// as if by placement new.
    ///
    /// ## Example
    /// ```
    /// result<int, std::string> res1{42};
    /// result<int, std::string> res2{in_place_error, ""};
    ///
    /// res1.emplace_error(5, 'a');
    /// res2.emplace_error(5, 'a');
    ///
    /// assert(res1.is_error());
    /// assert(res1.error() == "aaaaa");
    ///
    /// assert(res2.is_error());
    /// assert(res2.error() == "aaaaa");
    /// ```
    template <typename... Args>
    constexpr error_reference emplace_error(Args&&... args) {
        return res_().template emplace<1>(std::forward<Args>(args)...);
    }
 
    /// @brief Constructs a new error value in place into the @ref result
    ///
    /// @details
    /// The value previously contained in the @ref result, ok or error, is
    /// destroyed in place. The new error value is then constructed in place
    /// as if by placement new.
    ///
    /// ## Example
    /// ```
    /// result<int, std::vector<int>> res1{42};
    /// result<int, std::vector<int>> res2{in_place_error};
    ///
    /// res1.emplace_error({1, 2, 3, 4, 5});
    /// res2.emplace_error({1, 2, 3, 4, 5});
    ///
    /// assert(res1.is_error());
    /// assert(res1.error().size() == 5);
    ///
    /// assert(res2.is_error());
    /// assert(res2.error().size() == 5);
    /// ```
    template <typename U, typename... Args>
    constexpr error_reference emplace_error(std::initializer_list<U> ilist,
                                            Args&&... args) {
        return res_().template emplace<1>(ilist, std::forward<Args>(args)...);
    }
 
    /// @brief Invokes a visitor witht he contained value
    ///
    /// @details
    /// This function treats a @ref result as if it was a @ref variant of
    /// `T` and `E` (i.e. `variant<T, E>`). If the @ref result contians an ok
    /// value, that value is passed to the visitor. If the @ref result contains
    /// an error, the error is passed to the visitor. When either `T` or `E`
    /// are `void`, an instance of @ref void_t is passed instead.
    ///
    /// Note that the @ref overload function can be helpful for defining a
    /// visiotr inline.
    ///
    /// ## Example
    /// ```
    /// result<int, std::string> res1{42};
    /// result<int, std::string> res2{in_place_error, "oh no"};
    ///
    /// res1.visit(overload([](int ok_val) {
    ///     assert(ok_val == 42);
    /// }, [](std::string& err_val) {
    ///     assert(false);
    /// }));
    ///
    /// res2.visit(overload([](int ok_val) {
    ///     assert(false);
    /// }, [](std::string& err_val) {
    ///     assert(err_val == "oh no");
    /// }));
    /// ```
    template <typename V>
    constexpr
#ifndef DOXYGEN
        decltype(auto)
#else
        DEDUCED
#endif
        visit(V&& visitor) & {
        return res_().visit(std::forward<V>(visitor));
    }
 
    /// @brief Invokes a visitor witht he contained value
    ///
    /// @details
    /// This function treats a @ref result as if it was a @ref variant of
    /// `T` and `E` (i.e. `variant<T, E>`). If the @ref result contians an ok
    /// value, that value is passed to the visitor. If the @ref result contains
    /// an error, the error is passed to the visitor. When either `T` or `E`
    /// are `void`, an instance of @ref void_t is passed instead.
    ///
    /// Note that the @ref overload function can be helpful for defining a
    /// visiotr inline.
    ///
    /// ## Example
    /// ```
    /// const result<int, std::string> res1{42};
    /// const result<int, std::string> res2{in_place_error, "oh no"};
    ///
    /// res1.visit(overload([](int ok_val) {
    ///     assert(ok_val == 42);
    /// }, [](const std::string& err_val) {
    ///     assert(false);
    /// }));
    ///
    /// res2.visit(overload([](int ok_val) {
    ///     assert(false);
    /// }, [](const std::string& err_val) {
    ///     assert(err_val == "oh no");
    /// }));
    /// ```
    template <typename V>
    constexpr
#ifndef DOXYGEN
        decltype(auto)
#else
        DEDUCED
#endif
        visit(V&& visitor) const& {
        return res_().visit(std::forward<V>(visitor));
    }
 
    /// @brief Invokes a visitor witht he contained value
    ///
    /// @details
    /// This function treats a @ref result as if it was a @ref variant of
    /// `T` and `E` (i.e. `variant<T, E>`). If the @ref result contians an ok
    /// value, that value is passed to the visitor. If the @ref result contains
    /// an error, the error is passed to the visitor. When either `T` or `E`
    /// are `void`, an instance of @ref void_t is passed instead.
    ///
    /// Note that the @ref overload function can be helpful for defining a
    /// visiotr inline.
    ///
    /// ## Example
    /// ```
    /// result<int, std::string> res1{42};
    /// result<int, std::string> res2{in_place_error, "oh no"};
    ///
    /// std::move(res1).visit(overload([](int ok_val) {
    ///     assert(ok_val == 42);
    /// }, [](std::string err_val) {
    ///     assert(false);
    /// }));
    ///
    /// std::move(res2).visit(overload([](int ok_val) {
    ///     assert(false);
    /// }, [](std::string err_val) {
    ///     assert(err_val == "oh no");
    /// }));
    /// ```
    template <typename V>
    constexpr
#ifndef DOXYGEN
        decltype(auto)
#else
        DEDUCED
#endif
        visit(V&& visitor) && {
        return std::move(*this).res_().visit(std::forward<V>(visitor));
    }
 
    /// @brief Invokes a visitor witht he contained value
    ///
    /// @details
    /// This function treats a @ref result as if it was a @ref variant of
    /// `T` and `E` (i.e. `variant<T, E>`). If the @ref result contians an ok
    /// value, that value is passed to the visitor. If the @ref result contains
    /// an error, the error is passed to the visitor. When either `T` or `E`
    /// are `void`, an instance of @ref void_t is passed instead.
    ///
    /// Note that the @ref overload function can be helpful for defining a
    /// visiotr inline.
    ///
    /// ## Example
    /// ```
    /// const result<int, std::string> res1{42};
    /// const result<int, std::string> res2{in_place_error, "oh no"};
    ///
    /// std::move(res1).visit(overload([](int ok_val) {
    ///     assert(ok_val == 42);
    /// }, [](std::string err_val) {
    ///     assert(false);
    /// }));
    ///
    /// std::move(res2).visit(overload([](int ok_val) {
    ///     assert(false);
    /// }, [](std::string err_val) {
    ///     assert(err_val == "oh no");
    /// }));
    /// ```
    template <typename V>
    constexpr
#ifndef DOXYGEN
        decltype(auto)
#else
        DEDUCED
#endif
        visit(V&& visitor) const&& {
        return std::move(*this).res_().visit(std::forward<V>(visitor));
    }
 
    /// @brief Invokes a visitor with the contained value and meta data
    ///
    /// @details
    /// This function treats a @ref result as if it was a @ref variant of
    /// `T` and `E` (i.e. `variant<T, E>`). If the @ref result contians an ok
    /// value, that value is passed to the visitor. If the @ref result contains
    /// an error, the error is passed to the visitor. When either `T` or `E`
    /// are `void`, an instance of @ref void_t is passed instead.
    ///
    /// Unlike @ref visit, this function also passes an extra meta data value
    /// when invoking the visitor. This meta data object provides `constexpr`
    /// information about the type and index of the value being visited. The ok
    /// value has index 0 and the error value has index 1. This object has the
    /// the API shown below.
    ///
    /// ```
    /// struct alternative_info {
    ///     // index of the alternative (ok == 0, error == 1)
    ///     static inline constexpr size_t index = ...;
    ///
    ///     // type of the alternative (ok == T, error == E)
    ///     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.
    ///
    /// ## Example
    /// ```
    /// result<int, std::string> res1{42};
    /// result<int, std::string> res2{in_place_error, "oh no"};
    ///
    /// res1.visit_informed([](auto&& value, auto info) {
    ///     if constexpr (info.index == 0) { // ok
    ///         assert(value == 42);
    ///     } else if constexpr (info.index == 1) { // error
    ///         assert(false);
    ///     }
    /// });
    ///
    /// res2.visit_informed([](auto&& value, auto info) {
    ///     if constexpr (info.index == 0) { // ok
    ///         assert(false);
    ///     } else if constexpr (info.index == 1) { // error
    ///         assert(value == "oh no");
    ///     }
    /// });
    /// ```
    template <typename V>
    constexpr
#ifndef DOXYGEN
        decltype(auto)
#else
        DEDUCED
#endif
        visit_informed(V&& visitor) & {
        return res_().visit_informed(std::forward<V>(visitor));
    }
 
    /// @brief Invokes a visitor with the contained value and meta data
    ///
    /// @details
    /// This function treats a @ref result as if it was a @ref variant of
    /// `T` and `E` (i.e. `variant<T, E>`). If the @ref result contians an ok
    /// value, that value is passed to the visitor. If the @ref result contains
    /// an error, the error is passed to the visitor. When either `T` or `E`
    /// are `void`, an instance of @ref void_t is passed instead.
    ///
    /// Unlike @ref visit, this function also passes an extra meta data value
    /// when invoking the visitor. This meta data object provides `constexpr`
    /// information about the type and index of the value being visited. The ok
    /// value has index 0 and the error value has index 1. This object has the
    /// the API shown below.
    ///
    /// ```
    /// struct alternative_info {
    ///     // index of the alternative (ok == 0, error == 1)
    ///     static inline constexpr size_t index = ...;
    ///
    ///     // type of the alternative (ok == T, error == E)
    ///     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.
    ///
    /// ## Example
    /// ```
    /// const result<int, std::string> res1{42};
    /// const result<int, std::string> res2{in_place_error, "oh no"};
    ///
    /// res1.visit_informed([](auto&& value, auto info) {
    ///     if constexpr (info.index == 0) { // ok
    ///         assert(value == 42);
    ///     } else if constexpr (info.index == 1) { // error
    ///         assert(false);
    ///     }
    /// });
    ///
    /// res2.visit_informed([](auto&& value, auto info) {
    ///     if constexpr (info.index == 0) { // ok
    ///         assert(false);
    ///     } else if constexpr (info.index == 1) { // error
    ///         assert(value == "oh no");
    ///     }
    /// });
    /// ```
    template <typename V>
    constexpr
#ifndef DOXYGEN
        decltype(auto)
#else
        DEDUCED
#endif
        visit_informed(V&& visitor) const& {
        return res_().visit_informed(std::forward<V>(visitor));
    }
 
    /// @brief Invokes a visitor with the contained value and meta data
    ///
    /// @details
    /// This function treats a @ref result as if it was a @ref variant of
    /// `T` and `E` (i.e. `variant<T, E>`). If the @ref result contians an ok
    /// value, that value is passed to the visitor. If the @ref result contains
    /// an error, the error is passed to the visitor. When either `T` or `E`
    /// are `void`, an instance of @ref void_t is passed instead.
    ///
    /// Unlike @ref visit, this function also passes an extra meta data value
    /// when invoking the visitor. This meta data object provides `constexpr`
    /// information about the type and index of the value being visited. The ok
    /// value has index 0 and the error value has index 1. This object has the
    /// the API shown below.
    ///
    /// ```
    /// struct alternative_info {
    ///     // index of the alternative (ok == 0, error == 1)
    ///     static inline constexpr size_t index = ...;
    ///
    ///     // type of the alternative (ok == T, error == E)
    ///     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.
    ///
    /// ## Example
    /// ```
    /// result<int, std::string> res1{42};
    /// result<int, std::string> res2{in_place_error, "oh no"};
    ///
    /// std::move(res1).visit_informed([](auto&& value, auto info) {
    ///     if constexpr (info.index == 0) { // ok
    ///         assert(value == 42);
    ///     } else if constexpr (info.index == 1) { // error
    ///         assert(false);
    ///     }
    /// });
    ///
    /// std::move(res2).visit_informed([](auto&& value, auto info) {
    ///     if constexpr (info.index == 0) { // ok
    ///         assert(false);
    ///     } else if constexpr (info.index == 1) { // error
    ///         assert(value == "oh no");
    ///     }
    /// });
    /// ```
    template <typename V>
    constexpr
#ifndef DOXYGEN
        decltype(auto)
#else
        DEDUCED
#endif
        visit_informed(V&& visitor) && {
        return std::move(*this).res_().visit_informed(std::forward<V>(visitor));
    }
 
    /// @brief Invokes a visitor with the contained value and meta data
    ///
    /// @details
    /// This function treats a @ref result as if it was a @ref variant of
    /// `T` and `E` (i.e. `variant<T, E>`). If the @ref result contians an ok
    /// value, that value is passed to the visitor. If the @ref result contains
    /// an error, the error is passed to the visitor. When either `T` or `E`
    /// are `void`, an instance of @ref void_t is passed instead.
    ///
    /// Unlike @ref visit, this function also passes an extra meta data value
    /// when invoking the visitor. This meta data object provides `constexpr`
    /// information about the type and index of the value being visited. The ok
    /// value has index 0 and the error value has index 1. This object has the
    /// the API shown below.
    ///
    /// ```
    /// struct alternative_info {
    ///     // index of the alternative (ok == 0, error == 1)
    ///     static inline constexpr size_t index = ...;
    ///
    ///     // type of the alternative (ok == T, error == E)
    ///     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.
    ///
    /// ## Example
    /// ```
    /// const result<int, std::string> res1{42};
    /// const result<int, std::string> res2{in_place_error, "oh no"};
    ///
    /// std::move(res1).visit_informed([](auto&& value, auto info) {
    ///     if constexpr (info.index == 0) { // ok
    ///         assert(value == 42);
    ///     } else if constexpr (info.index == 1) { // error
    ///         assert(false);
    ///     }
    /// });
    ///
    /// std::move(res2).visit_informed([](auto&& value, auto info) {
    ///     if constexpr (info.index == 0) { // ok
    ///         assert(false);
    ///     } else if constexpr (info.index == 1) { // error
    ///         assert(value == "oh no");
    ///     }
    /// });
    /// ```
    template <typename V>
    constexpr
#ifndef DOXYGEN
        decltype(auto)
#else
        DEDUCED
#endif
        visit_informed(V&& visitor) const&& {
        return std::move(*this).res_().visit_informed(std::forward<V>(visitor));
    }
 
    /// @brief Swaps two @ref result instances
    ///
    /// @details
    /// If both @ref result instances contain an ok value or both contain an
    /// error value, the values are swapped directly. If the two @ref result
    /// instances do not contain the same kind of value, the values are moved
    /// out of the @ref results temporarily, the old values are destroyed, and
    /// new values a move constructed in to the opposite @ref result.
    ///
    /// ## Example
    /// ```
    /// result<int, std::string> res1{42};
    /// result<int, std::string> res2{in_place_error, "oh no"};
    ///
    /// res1.swap(res2);
    ///
    /// assert(res1.is_error());
    /// assert(res1.error() == "oh no");
    ///
    /// assert(res2.is_ok());
    /// assert(*res2 == 42);
    /// ```
    constexpr void swap(result& other)
#ifndef DOXYGEN
        noexcept(std::is_nothrow_swappable_v<variant<T, E>>)
#else
        CONDITIONALLY_NOEXCEPT
#endif
    {
        res_().swap(other.res_);
    }
};
 
/// @relates result
/// @brief Gets a @ref result value by index, as if it were a @ref variant
///
/// @details
/// This function is provided to make @ref result generically compatible with
/// @ref variant. This function treats `result<T, E>`  as if it were
/// `variant<T, E>`, where index 0 is `T` and index 1 is `E`.
///
/// ## Example
/// ```
/// result<int, std::string> res1{42};
/// result<int, std::string> res2{in_place_error, "oh no"};
///
/// assert(get<0>(res1) == 42);
/// assert(get<1>(res2) == "oh no");
/// ```
///
/// @tparam IDX The "alternative" index
///
/// @param res The @ref result to access
///
/// @return A reference to the accessed "alternative"
///
/// @throws bad_result_access  Thrown if the @ref result does not contain the
/// matching index.
template <size_t IDX, typename T, typename E>
constexpr
#ifndef DOXYGEN
    typename detail::traits<detail::select_t<IDX, T, E>>::reference
#else
    REFERENCE
#endif
    get(result<T, E>& res) {
    return get<IDX>(res.res_);
}
 
/// @relates result
/// @brief Gets a @ref result value by index, as if it were a @ref variant
///
/// @details
/// This function is provided to make @ref result generically compatible with
/// @ref variant. This function treats `result<T, E>`  as if it were
/// `variant<T, E>`, where index 0 is `T` and index 1 is `E`.
///
/// ## Example
/// ```
/// const result<int, std::string> res1{42};
/// const result<int, std::string> res2{in_place_error, "oh no"};
///
/// assert(get<0>(res1) == 42);
/// assert(get<1>(res2) == "oh no");
/// ```
///
/// @tparam IDX The "alternative" index
///
/// @param res The @ref result to access
///
/// @return A const reference to the accessed "alternative"
///
/// @throws bad_result_access  Thrown if the @ref result does not contain the
/// matching index.
template <size_t IDX, typename T, typename E>
constexpr
#ifndef DOXYGEN
    typename detail::traits<detail::select_t<IDX, T, E>>::const_reference
#else
    CONST_REFERENCE
#endif
    get(const result<T, E>& res) {
    return get<IDX>(res.res_);
}
 
/// @relates result
/// @brief Gets a @ref result value by index, as if it were a @ref variant
///
/// @details
/// This function is provided to make @ref result generically compatible with
/// @ref variant. This function treats `result<T, E>`  as if it were
/// `variant<T, E>`, where index 0 is `T` and index 1 is `E`.
///
/// ## Example
/// ```
/// result<int, std::string> res1{42};
/// result<int, std::string> res2{in_place_error, "oh no"};
///
/// assert(get<0>(std::move(res1)) == 42);
/// assert(get<1>(std::move(res2)) == "oh no");
/// ```
///
/// @tparam IDX The "alternative" index
///
/// @param res The @ref result to access
///
/// @return An rvalue of the accessed "alternative"
///
/// @throws bad_result_access  Thrown if the @ref result does not contain the
/// matching index.
template <size_t IDX, typename T, typename E>
constexpr
#ifndef DOXYGEN
    typename detail::traits<detail::select_t<IDX, T, E>>::rvalue_reference
#else
    RVALUE_REFERENCE
#endif
    // NOLINTNEXTLINE(cppcoreguidelines-rvalue-reference-param-not-moved)
    get(result<T, E>&& res) {
    return get<IDX>(std::move(res.res_));
}
 
/// @relates result
/// @brief Gets a @ref result value by index, as if it were a @ref variant
///
/// @details
/// This function is provided to make @ref result generically compatible with
/// @ref variant. This function treats `result<T, E>`  as if it were
/// `variant<T, E>`, where index 0 is `T` and index 1 is `E`.
///
/// ## Example
/// ```
/// const result<int, std::string> res1{42};
/// const result<int, std::string> res2{in_place_error, "oh no"};
///
/// assert(get<0>(std::move(res1)) == 42);
/// assert(get<1>(std::move(res2)) == "oh no");
/// ```
///
/// @tparam IDX The "alternative" index
///
/// @param res The @ref result to access
///
/// @return A const rvalue of the accessed "alternative"
///
/// @throws bad_result_access  Thrown if the @ref result does not contain the
/// matching index.
template <size_t IDX, typename T, typename E>
constexpr
#ifndef DOXYGEN
    typename detail::traits<detail::select_t<IDX, T, E>>::const_rvalue_reference
#else
    CONST_RVALUE_REFERENCE
#endif
    get(const result<T, E>&& res) {
    return get<IDX>(std::move(res.res_));
}
 
/// @relates result
/// @brief Gets a @ref result value by type, as if it were a @ref variant
///
/// @details
/// This fucntion is provided to make @ref result generically compatible with
/// @ref variant. This function treats `result<T, E>` as if it were
/// `variant<T, E>`.
///
/// This function only participates in overload resolution if `T` and `E` are
/// distinct types, in order to avoid ambiguity.
///
/// ## Example
/// ```
/// result<int, std::string> res1{42};
/// result<int, std::string> res2{in_place_error, "oh no"};
///
/// assert(get<int>(res1) == 42);
/// assert(get<std::string>(res2) == "oh no");
/// ```
///
/// @tparam U The "alternative" type
///
/// @param res The @ref result to access
///
/// @return A reference to the accessed "alternative"
///
/// @throws bad_result_access  Thrown if the @ref result does not contain the
/// matching index.
template <typename U, typename T, typename E>
#ifndef DOXYGEN
    requires(std::is_same_v<U, T> || std::is_same_v<U, E>)
#endif
constexpr
#ifndef DOXYGEN
    typename detail::traits<U>::reference
#else
    REFERENCE
#endif
    get(result<T, E>& res) {
    return get<U>(res.res_);
}
 
/// @relates result
/// @brief Gets a @ref result value by type, as if it were a @ref variant
///
/// @details
/// This fucntion is provided to make @ref result generically compatible with
/// @ref variant. This function treats `result<T, E>` as if it were
/// `variant<T, E>`.
///
/// This function only participates in overload resolution if `T` and `E` are
/// distinct types, in order to avoid ambiguity.
///
/// ## Example
/// ```
/// const result<int, std::string> res1{42};
/// const result<int, std::string> res2{in_place_error, "oh no"};
///
/// assert(get<int>(res1) == 42);
/// assert(get<std::string>(res2) == "oh no");
/// ```
///
/// @tparam U The "alternative" type
///
/// @param res The @ref result to access
///
/// @return A const reference to the accessed "alternative"
///
/// @throws bad_result_access  Thrown if the @ref result does not contain the
/// matching index.
template <typename U, typename T, typename E>
#ifndef DOXYGEN
    requires(std::is_same_v<U, T> || std::is_same_v<U, E>)
#endif
constexpr
#ifndef DOXYGEN
    typename detail::traits<U>::const_reference
#else
    CONST_REFERENCE
#endif
    get(const result<T, E>& res) {
    return get<U>(res.res_);
}
 
/// @relates result
/// @brief Gets a @ref result value by type, as if it were a @ref variant
///
/// @details
/// This fucntion is provided to make @ref result generically compatible with
/// @ref variant. This function treats `result<T, E>` as if it were
/// `variant<T, E>`.
///
/// This function only participates in overload resolution if `T` and `E` are
/// distinct types, in order to avoid ambiguity.
///
/// ## Example
/// ```
/// result<int, std::string> res1{42};
/// result<int, std::string> res2{in_place_error, "oh no"};
///
/// assert(get<int>(std::move(res1)) == 42);
/// assert(get<std::string>(std::move(res2)) == "oh no");
/// ```
///
/// @tparam U The "alternative" type
///
/// @param res The @ref result to access
///
/// @return An rvalue of the accessed "alternative"
///
/// @throws bad_result_access  Thrown if the @ref result does not contain the
/// matching index.
template <typename U, typename T, typename E>
#ifndef DOXYGEN
    requires(std::is_same_v<U, T> || std::is_same_v<U, E>)
#endif
constexpr
#ifndef DOXYGEN
    typename detail::traits<U>::rvalue_reference
#else
    RVALUE_REFERENCE
#endif
    // NOLINTNEXTLINE(cppcoreguidelines-rvalue-reference-param-not-moved)
    get(result<T, E>&& res) {
    return get<U>(std::move(res.res_));
}
 
/// @relates result
/// @brief Gets a @ref result value by type, as if it were a @ref variant
///
/// @details
/// This fucntion is provided to make @ref result generically compatible with
/// @ref variant. This function treats `result<T, E>` as if it were
/// `variant<T, E>`.
///
/// This function only participates in overload resolution if `T` and `E` are
/// distinct types, in order to avoid ambiguity.
///
/// ## Example
/// ```
/// const result<int, std::string> res1{42};
/// const result<int, std::string> res2{in_place_error, "oh no"};
///
/// assert(get<int>(std::move(res1)) == 42);
/// assert(get<std::string>(std::move(res2)) == "oh no");
/// ```
///
/// @tparam U The "alternative" type
///
/// @param res The @ref result to access
///
/// @return A const rvalue of the accessed "alternative"
///
/// @throws bad_result_access  Thrown if the @ref result does not contain the
/// matching index.
template <typename U, typename T, typename E>
#ifndef DOXYGEN
    requires(std::is_same_v<U, T> || std::is_same_v<U, E>)
#endif
constexpr
#ifndef DOXYGEN
    typename detail::traits<U>::const_rvalue_reference
#else
    CONST_RVALUE_REFERENCE
#endif
    get(const result<T, E>&& res) {
    return get<U>(std::move(res.res_));
}
 
/// @relates result
/// @brief Compares two @ref result instances for equality
///
/// @details
/// Returns true if both @ref result instances either both contain ok values or
/// both contain error values, and the values compare equal.
///
/// ## Example
/// ```
/// result<int, std::string> res1{42};
/// result<unsigned int, const char*> res2{42};
///
/// assert(res1 == res2);
/// ```
template <typename T, typename E, typename U, typename V>
#ifndef DOXYGEN
    requires(std::is_void_v<T> == std::is_void_v<U> &&
             std::is_void_v<E> == std::is_void_v<V>)
#endif
constexpr bool operator==(const result<T, E>& lhs, const result<U, V>& rhs) {
    if (lhs.has_value()) {
        if constexpr (std::is_void_v<T>) {
            return rhs.has_value();
        } else {
            if (rhs.has_value()) {
                return *lhs == *rhs;
            } else {
                return false;
            }
        }
    } else {
        if constexpr (std::is_void_v<E>) {
            return !rhs.has_value();
        } else {
            if (rhs.has_value()) {
                return false;
            } else {
                return lhs.error() == rhs.error();
            }
        }
    }
}
 
/// @relates result
/// @brief Compares a @ref result with a plain value for equality
///
/// @details
/// This function return true if the @ref result contains an ok value and the
/// ok value compares equal with the plain value.
///
/// ## Example
/// ```
/// result<int, std::string> res1{42};
/// result<int, std::string> res2{in_place_error, "oh no"};
///
/// assert(res1 == 42);
/// assert(res2 != 42);
/// ```
template <typename T, typename E, typename U>
constexpr bool operator==(const result<T, E>& lhs, const U& rhs) {
    return lhs.has_value() && *lhs == rhs;
}
 
/// @relates result
/// @brief Compares a @ref result with a plain value for equality
///
/// @details
/// This function return true if the @ref result contains an ok value and the
/// ok value compares equal with the plain value.
///
/// ## Example
/// ```
/// result<int, std::string> res1{42};
/// result<int, std::string> res2{in_place_error, "oh no"};
///
/// assert(42 == res1);
/// assert(42 != res2);
/// ```
template <typename T, typename E, typename U>
constexpr bool operator==(const U& lhs, const result<T, E>& rhs) {
    return rhs.has_value() && lhs == *rhs;
}
 
/// @relates result
/// @brief Swaps two @ref result instances
///
/// @details
/// If both @ref result instances contain an ok value or both contain an
/// error value, the values are swapped directly. If the two @ref result
/// instances do not contain the same kind of value, the values are moved
/// out of the @ref results temporarily, the old values are destroyed, and
/// new values a move constructed in to the opposite @ref result.
///
/// ## Example
/// ```
/// result<int, std::string> res1{42};
/// result<int, std::string> res2{in_place_error, "oh no"};
///
/// swap(res1, res2);
///
/// assert(res1.is_error());
/// assert(res1.error() == "oh no");
///
/// assert(res2.is_ok());
/// assert(*res2 == 42);
/// ```
template <typename T, typename E>
constexpr void swap(result<T, E>& a, result<T, E>& b)
#ifndef DOXYGEN
    noexcept(std::is_nothrow_swappable_v<variant<T, E>>)
#else
    CONDITIONALLY_NOEXCEPT
#endif
{
    a.swap(b);
}
 
/// @relates result
/// @brief Creates an ok valued @ref result, constructed in place
///
/// @details
/// Similar to STL functions like `std::make_unique` and `std::make_optional`,
/// this function is provided a template argument to specify what contained
/// type should be constructed, and then is passed arguments that are
/// forwarded to the constructor of the contained type.
///
/// ## Example
/// ```
/// result<std::string, void> make_string() {
///     // returns a result<std::string, never> which gets converted to
///     // a result<std::string, void>
///     return ok<std::string>("hello");
/// }
/// ```
template <typename T, typename... Args>
constexpr result<T, never> ok(Args&&... args) {
    return result<T, never>{std::in_place, std::forward<Args>(args)...};
}
 
/// @relates result
/// @brief Creates an ok valued @ref result, constructed in place
///
/// @details
/// Similar to STL functions like `std::make_unique` and `std::make_optional`,
/// this function is provided a template argument to specify what contained
/// type should be constructed, and then is passed arguments that are
/// forwarded to the constructor of the contained type.
///
/// ## Example
/// ```
/// result<std::vector<int>, void> make_nums() {
///     // returns a result<std::vector<int>, never> which gets converted
///     // to a result<std::vector<int>, void>
///     return ok<std::vector<int>>({1, 2, 3, 4, 5});
/// }
/// ```
template <typename T, typename U, typename... Args>
constexpr result<T, never> ok(std::initializer_list<U> ilist, Args&&... args) {
    return result<T, never>{std::in_place, ilist, std::forward<Args>(args)...};
}
 
/// @relates result
/// @brief Creates an error valued @ref result, constructed in place
///
/// @details
/// Similar to STL functions like `std::make_unique` and `std::make_optional`,
/// this function is provided a template argument to specify what contained
/// error type should be constructed, and then is passed arguments that are
/// forwarded to the constructor of the contained error type.
///
/// ## Example
/// ```
/// result<void, std::string> ensure_positive(int value) {
///   if (value < 0) {
///       return error<std::string>("value is negative");
///   }
///   return value;
/// }
/// ```
template <typename E, typename... Args>
constexpr result<never, E> error(Args&&... args) {
    return result<never, E>{in_place_error, std::forward<Args>(args)...};
}
 
/// @relates result
/// @brief Creates an error valued @ref result, constructed in place
///
/// @details
/// Similar to STL functions like `std::make_unique` and `std::make_optional`,
/// this function is provided a template argument to specify what contained
/// error type should be constructed, and then is passed arguments that are
/// forwarded to the constructor of the contained error type.
///
/// ## Example
/// ```
/// result<void, std::vector<int>> ilist_error_example() {
///   // returns a result<never, std::vector<int>> which gets converted
///   // to a result<void, std::vector<int>>
///   return error<std::vector<int>>({1, 2, 3, 4, 5});
/// }
/// ```
template <typename E, typename U, typename... Args>
constexpr result<never, E> error(std::initializer_list<U> ilist, Args&&... args) {
    return result<never, E>{in_place_error, ilist, std::forward<Args>(args)...};
}
 
/// @private
template <typename T, typename E>
    requires(std::is_base_of_v<never, std::remove_cvref_t<T>> &&
             std::is_base_of_v<never, std::remove_cvref_t<E>>)
class result<T, E> : public never {};
 
} // namespace sumty
 
#endif