option_result.h

Go to the documentation of this file.

#pragma once

#include "stx/internal/panic_helpers.h"

// Why so long? Option and Result depend on each other. I don't know of a
// way to break the cyclic dependency, primarily because they are templated
//
// Lifetime notes:
// - Every change of state must be followed by a destruction (and construction
// if it has a non-null variant)
// - The object must be destroyed immediately after the contained value is moved
// from it.
//
// Notes:
// - Result is an object-forwarding type. It is unique to an
// interaction. It functions like a std::unique_ptr, as it doesn't allow
// implicitly copying its data content. Unless explicitly stated via the
// .clone() method
// - We strive to make lifetime paths as visible and predictable as
// possible
// - We also try to prevent you from shooting yourself in the foot, especially
// with references and implicit copies
// - Many are marked constexpr but won't work in a constexpr context in C++ 17
// mode. They work in C++ 20 and We don't want macros for that
// - std::move & std::forward or macros?


STX_BEGIN_NAMESPACE

template <typename T>
struct Some;

struct NoneType;

template <typename T>
struct Option;

template <typename T>
struct Ok;

template <typename E>
struct Err;

template <typename T, typename E>
struct Result;

struct [[nodiscard]] NoneType {
  constexpr NoneType() noexcept = default;
  constexpr NoneType(NoneType const&) noexcept = default;
  constexpr NoneType(NoneType &&) noexcept = default;
  constexpr NoneType& operator=(NoneType const&) noexcept = default;
  constexpr NoneType& operator=(NoneType&&) noexcept = default;

  STX_CXX20_DESTRUCTOR_CONSTEXPR ~NoneType() noexcept = default;

  [[nodiscard]] constexpr bool operator==(NoneType const&) const noexcept {
    return true;
  }

  [[nodiscard]] constexpr bool operator!=(NoneType const&) const noexcept {
    return false;
  }

  template <typename T>
  [[nodiscard]] constexpr bool operator==(Some<T> const&) const noexcept {
    return false;
  }

  template <typename T>
  [[nodiscard]] constexpr bool operator!=(Some<T> const&) const noexcept {
    return true;
  }
};

constexpr NoneType const None{};

template <typename T>
struct [[nodiscard]] Some {
  static_assert(movable<T>, "Value type 'T' for 'Option<T>' must be movable");
  static_assert(
      !is_reference<T>,
      "Cannot use a reference for value type 'T' of 'Option<T>' , To prevent "
      "subtleties use "
      "type wrappers like std::reference_wrapper (stx::Ref) or any of the "
      "`stx::ConstRef` or `stx::MutRef` specialized aliases instead");

  using value_type = T;

  explicit constexpr Some(T && value) : value_(std::forward<T&&>(value)) {}

  constexpr Some(Some && rhs) = default;
  constexpr Some& operator=(Some&& rhs) = default;
  constexpr Some(Some const&) = default;
  constexpr Some& operator=(Some const&) = default;

  STX_CXX20_DESTRUCTOR_CONSTEXPR ~Some() = default;

  [[nodiscard]] constexpr T const& value() const& noexcept { return value_; }
  [[nodiscard]] constexpr T& value()& noexcept { return value_; }
  [[nodiscard]] constexpr T const value() const&& { return std::move(value_); }
  [[nodiscard]] constexpr T value()&& { return std::move(value_); }

  template <typename U>
  [[nodiscard]] constexpr bool operator==(Some<U> const& cmp) const {
    static_assert(equality_comparable<T, U>);
    return value() == cmp.value();
  }

  template <typename U>
  [[nodiscard]] constexpr bool operator!=(Some<U> const& cmp) const {
    static_assert(equality_comparable<T, U>);
    return value() != cmp.value();
  }

  [[nodiscard]] constexpr bool operator==(NoneType const&) const noexcept {
    return false;
  }

  [[nodiscard]] constexpr bool operator!=(NoneType const&) const noexcept {
    return true;
  }

 private:
  T value_;

  template <typename Tp>
  friend struct Option;
};

template <typename T>
struct [[nodiscard]] Ok {
  static_assert(movable<T>, "Value type 'T' for 'Ok<T>' must be movable");
  static_assert(
      !is_reference<T>,
      "Cannot use a reference for value type 'T' of 'Ok<T>' , To prevent "
      "subtleties use "
      "type wrappers like std::reference_wrapper (stx::Ref) or any of the "
      "`stx::ConstRef` or `stx::MutRef` specialized aliases instead");

  using value_type = T;

  explicit constexpr Ok(T && value) : value_(std::forward<T&&>(value)) {}

  constexpr Ok(Ok && rhs) = default;
  constexpr Ok& operator=(Ok&& rhs) = default;
  constexpr Ok(Ok const&) = default;
  constexpr Ok& operator=(Ok const&) = default;

  STX_CXX20_DESTRUCTOR_CONSTEXPR ~Ok() = default;

  template <typename U>
  [[nodiscard]] constexpr bool operator==(Ok<U> const& cmp) const {
    static_assert(equality_comparable<T, U>);
    return value() == cmp.value();
  }

  template <typename U>
  [[nodiscard]] constexpr bool operator!=(Ok<U> const& cmp) const {
    static_assert(equality_comparable<T, U>);
    return value() != cmp.value();
  }

  template <typename U>
  [[nodiscard]] constexpr bool operator==(Err<U> const&) const noexcept {
    return false;
  }

  template <typename U>
  [[nodiscard]] constexpr bool operator!=(Err<U> const&) const noexcept {
    return true;
  }

  [[nodiscard]] constexpr T const& value() const& noexcept { return value_; }
  [[nodiscard]] constexpr T& value()& noexcept { return value_; }
  [[nodiscard]] constexpr T const value() const&& { return std::move(value_); }
  [[nodiscard]] constexpr T value()&& { return std::move(value_); }

 private:
  T value_;

  template <typename Tp, typename Er>
  friend struct Result;
};

template <typename E>
struct [[nodiscard]] Err {
  static_assert(movable<E>, "Error type 'E' for 'Err<E>' must be movable");
  static_assert(
      !is_reference<E>,
      "Cannot use a reference for error type 'E' of 'Err<E>' , To prevent "
      "subtleties use "
      "type wrappers like std::reference_wrapper (stx::Ref) or any of the "
      "`stx::ConstRef` or `stx::MutRef` specialized aliases instead");

  using value_type = E;

  explicit constexpr Err(E && value) : value_(std::forward<E&&>(value)) {}

  constexpr Err(Err && rhs) = default;
  constexpr Err& operator=(Err&& rhs) = default;
  constexpr Err(Err const&) = default;
  constexpr Err& operator=(Err const&) = default;

  STX_CXX20_DESTRUCTOR_CONSTEXPR ~Err() = default;

  template <typename F>
  [[nodiscard]] constexpr bool operator==(Err<F> const& cmp) const {
    static_assert(equality_comparable<E, F>);
    return value() == cmp.value();
  }

  template <typename F>
  [[nodiscard]] constexpr bool operator!=(Err<F> const& cmp) const {
    static_assert(equality_comparable<E, F>);
    return value() != cmp.value();
  }

  template <typename F>
  [[nodiscard]] constexpr bool operator==(Ok<F> const&) const noexcept {
    return false;
  }

  template <typename F>
  [[nodiscard]] constexpr bool operator!=(Ok<F> const&) const noexcept {
    return true;
  }

  [[nodiscard]] constexpr E const& value() const& noexcept { return value_; }
  [[nodiscard]] constexpr E& value()& noexcept { return value_; }
  [[nodiscard]] constexpr E const value() const&& { return std::move(value_); }
  [[nodiscard]] constexpr E value()&& { return std::move(value_); }

 private:
  E value_;

  template <typename Tp, typename Er>
  friend struct Result;
};

// JUST LOOK AWAY

namespace internal {
namespace option {
// constructs an r-value reference to the option's value directly, without
// checking if it is in the `Some` or `None` state. This is totally unsafe and
// user-end code should **never** use this
template <typename Tp>
inline Tp&& unsafe_value_move(Option<Tp>&);

}  // namespace option
}  // namespace internal

template <typename T>
struct [[nodiscard]] Option {
 public:
  using value_type = T;

  static_assert(movable<T>, "Value type 'T' for 'Option<T>' must be movable");
  static_assert(
      !is_reference<T>,
      "Cannot use a reference for value type 'T' of 'Option<T>' , To prevent "
      "subtleties use "
      "type wrappers like std::reference_wrapper (stx::Ref) or any of the "
      "`stx::ConstRef` or `stx::MutRef` specialized aliases instead");

  constexpr Option() noexcept : is_none_(true) {}

  constexpr Option(Some<T> && some)
      : storage_value_(std::move(some.value_)), is_none_(false) {}

  constexpr Option(Some<T> const& some)
      : storage_value_(some.value()), is_none_(false) {
    static_assert(copy_constructible<T>);
  }

  constexpr Option(NoneType const&) noexcept : is_none_(true) {}

  // constexpr?
  // placement-new!
  // we can't make this constexpr as of C++ 20
  Option(Option && rhs) : is_none_(rhs.is_none_) {
    if (rhs.is_some()) {
      new (&storage_value_) T(std::move(rhs.storage_value_));
    }
  }

  Option& operator=(Option&& rhs) {
    // contained object is destroyed as appropriate in the parent scope
    if (is_some() && rhs.is_some()) {
      std::swap(storage_value_, rhs.storage_value_);
    } else if (is_some() && rhs.is_none()) {
      // we let the ref'd `rhs` destroy the object instead
      new (&rhs.storage_value_) T(std::move(storage_value_));
      storage_value_.~T();
      is_none_ = true;
      rhs.is_none_ = false;
    } else if (is_none() && rhs.is_some()) {
      new (&storage_value_) T(std::move(rhs.storage_value_));
      rhs.storage_value_.~T();
      rhs.is_none_ = true;
      is_none_ = false;
    }

    return *this;
  }

  Option(Option const& rhs) : is_none_(rhs.is_none_) {
    static_assert(copy_constructible<T>);
    if (rhs.is_some()) {
      new (&storage_value_) T(rhs.storage_value_);
    }
  }

  Option& operator=(Option const& rhs) {
    static_assert(copy_constructible<T>);

    if (is_some() && rhs.is_some()) {
      storage_value_ = rhs.storage_value_;
    } else if (is_some() && rhs.is_none()) {
      storage_value_.~T();
      is_none_ = true;
    } else if (is_none() && rhs.is_some()) {
      new (&storage_value_) T(rhs.storage_value_);
      is_none_ = false;
    }

    return *this;
  }

  STX_CXX20_DESTRUCTOR_CONSTEXPR ~Option() noexcept {
    if (is_some()) {
      storage_value_.~T();
    }
  }

  template <typename U>
  [[nodiscard]] constexpr bool operator==(Option<U> const& cmp) const {
    static_assert(equality_comparable<T, U>);
    if (is_some() && cmp.is_some()) {
      return value_cref_() == cmp.value_cref_();
    } else if (is_none() && cmp.is_none()) {
      return true;
    } else {
      return false;
    }
  }

  template <typename U>
  [[nodiscard]] constexpr bool operator!=(Option<U> const& cmp) const {
    static_assert(equality_comparable<T, U>);
    if (is_some() && cmp.is_some()) {
      return value_cref_() != cmp.value_cref_();
    } else if (is_none() && cmp.is_none()) {
      return false;
    } else {
      return true;
    }
  }

  template <typename U>
  [[nodiscard]] constexpr bool operator==(Some<U> const& cmp) const {
    static_assert(equality_comparable<T, U>);
    if (is_some()) {
      return value_cref_() == cmp.value();
    } else {
      return false;
    }
  }

  template <typename U>
  [[nodiscard]] constexpr bool operator!=(Some<U> const& cmp) const {
    static_assert(equality_comparable<T, U>);
    if (is_some()) {
      return value_cref_() != cmp.value();
    } else {
      return true;
    }
  }

  [[nodiscard]] constexpr bool operator==(NoneType const&) const noexcept {
    return is_none();
  }

  [[nodiscard]] constexpr bool operator!=(NoneType const&) const noexcept {
    return is_some();
  }

  [[nodiscard]] constexpr bool is_some() const noexcept { return !is_none(); }

  [[nodiscard]] constexpr bool is_none() const noexcept { return is_none_; }

  [[nodiscard]] operator bool() const noexcept { return is_some(); }

  template <typename CmpType>
  [[nodiscard]] constexpr bool contains(CmpType const& cmp) const {
    static_assert(equality_comparable<T, CmpType>);
    if (is_some()) {
      return value_cref_() == cmp;
    } else {
      return false;
    }
  }

  template <typename UnaryPredicate>
  [[nodiscard]] constexpr bool exists(UnaryPredicate && predicate) const {
    static_assert(invocable<UnaryPredicate&&, T const&>);
    static_assert(convertible<invoke_result<UnaryPredicate&&, T const&>, bool>);

    if (is_some()) {
      return std::forward<UnaryPredicate&&>(predicate)(value_cref_());
    } else {
      return false;
    }
  }

  [[nodiscard]] T& value()& noexcept {
    if (is_none()) internal::option::no_lref();
    return value_ref_();
  }

  [[nodiscard]] T const& value() const& noexcept {
    if (is_none()) internal::option::no_lref();
    return value_cref_();
  }

  [[deprecated("Use `unwrap()` instead")]] T value()&& = delete;
  [[deprecated("Use `unwrap()` instead")]] T const value() const&& = delete;

  [[nodiscard]] constexpr auto as_cref() const& noexcept->Option<ConstRef<T>> {
    if (is_some()) {
      return Some<ConstRef<T>>(ConstRef<T>(value_cref_()));
    } else {
      return None;
    }
  }

  [[deprecated(
      "calling Option::as_cref() on an r-value, and therefore binding a "
      "reference to an object that is marked to be moved")]]  //
  [[nodiscard]] constexpr auto
  as_cref() const&& noexcept->Option<ConstRef<T>> = delete;

  [[nodiscard]] constexpr auto as_ref()& noexcept->Option<MutRef<T>> {
    if (is_some()) {
      return Some<MutRef<T>>(MutRef<T>(value_ref_()));
    } else {
      return None;
    }
  }

  [[nodiscard]] constexpr auto as_ref() const& noexcept->Option<ConstRef<T>> {
    return as_cref();
  }

  [[deprecated(
      "calling Option::as_ref() on an r-value, and therefore binding a "
      "reference to an object that is marked to be moved")]]  //
  [[nodiscard]] constexpr auto
  as_ref()&& noexcept->Option<MutRef<T>> = delete;

  [[deprecated(
      "calling Option::as_ref() on an r-value, and therefore binding a "
      "reference to an object that is marked to be moved")]]  //
  [[nodiscard]] constexpr auto
  as_ref() const&& noexcept->Option<ConstRef<T>> = delete;

  [[nodiscard]] auto expect(std::string_view const& msg)&&->T {
    if (is_some()) {
      return std::move(value_ref_());
    } else {
      internal::option::expect_value_failed(msg);
    }
  }

  [[nodiscard]] auto unwrap()&&->T {
    if (is_some()) {
      return std::move(value_ref_());
    } else {
      internal::option::no_value();
    }
  }

  [[nodiscard]] constexpr auto unwrap_or(T && alt)&&->T {
    if (is_some()) {
      return std::move(value_ref_());
    } else {
      return std::move(alt);
    }
  }

  template <typename Fn>
  [[nodiscard]] constexpr auto unwrap_or_else(Fn && op)&&->T {
    static_assert(invocable<Fn&&>);
    if (is_some()) {
      return std::move(value_ref_());
    } else {
      return std::forward<Fn&&>(op)();
    }
  }

  template <typename Fn>
  [[nodiscard]] constexpr auto map(Fn &&
                                   op)&&->Option<invoke_result<Fn&&, T&&>> {
    static_assert(invocable<Fn&&, T&&>);
    if (is_some()) {
      return Some<invoke_result<Fn&&, T&&>>(
          std::forward<Fn&&>(op)(std::move(value_ref_())));
    } else {
      return None;
    }
  }

  template <typename Fn, typename A>
  [[nodiscard]] constexpr auto map_or(Fn && op,
                                      A && alt)&&->invoke_result<Fn&&, T&&> {
    static_assert(invocable<Fn&&, T&&>);
    if (is_some()) {
      return std::forward<Fn&&>(op)(std::move(value_ref_()));
    } else {
      return std::forward<A&&>(alt);
    }
  }

  template <typename Fn, typename AltFn>
  [[nodiscard]] constexpr auto map_or_else(
      Fn && op, AltFn && alt)&&->invoke_result<Fn&&, T&&> {
    static_assert(invocable<Fn&&, T&&>);
    static_assert(invocable<AltFn&&>);

    if (is_some()) {
      return std::forward<Fn&&>(op)(std::move(value_ref_()));
    } else {
      return std::forward<AltFn&&>(alt)();
    }
  }

  // copies the argument if not an r-value
  template <typename E>
  [[nodiscard]] constexpr auto ok_or(E error)&&->Result<T, E> {
    if (is_some()) {
      return Ok<T>(std::move(value_ref_()));
    } else {
      // tries to copy if it is an l-value ref and moves if it is an r-value
      return Err<E>(std::forward<E>(error));
    }
  }

  // can return reference but the user will get the error
  template <typename Fn>
  [[nodiscard]] constexpr auto ok_or_else(
      Fn && op)&&->Result<T, invoke_result<Fn&&>> {
    static_assert(invocable<Fn&&>);
    if (is_some()) {
      return Ok<T>(std::move(value_ref_()));
    } else {
      return Err<invoke_result<Fn&&>>(std::forward<Fn&&>(op)());
    }
  }

  // won't compile if a normal reference is passed since it is not copyable
  // if an rvalue, will pass. We are not forwarding refences here.
  // a requirement here is for it to be constructible with a None
  template <typename U>  //
  [[nodiscard]] constexpr auto AND(Option<U> && cmp)&&->Option<U> {
    if (is_some()) {
      return std::forward<Option<U>&&>(cmp);
    } else {
      return None;
    }
  }

  template <typename Fn>
  [[nodiscard]] constexpr auto and_then(Fn && op)&&->invoke_result<Fn&&, T&&> {
    static_assert(invocable<Fn&&, T&&>);
    if (is_some()) {
      return std::forward<Fn&&>(op)(std::move(value_ref_()));
    } else {
      return None;
    }
  }

  template <typename UnaryPredicate>
  [[nodiscard]] constexpr auto filter(UnaryPredicate && predicate)&&->Option {
    static_assert(invocable<UnaryPredicate&&, T const&>);
    static_assert(convertible<invoke_result<UnaryPredicate&&, T const&>, bool>);

    if (is_some() && std::forward<UnaryPredicate&&>(predicate)(value_cref_())) {
      return std::move(*this);
    } else {
      return None;
    }
  }

  template <typename UnaryPredicate>
  [[nodiscard]] constexpr auto filter_not(UnaryPredicate &&
                                          predicate)&&->Option {
    static_assert(invocable<UnaryPredicate&&, T const&>);
    static_assert(convertible<invoke_result<UnaryPredicate&&, T const&>, bool>);

    if (is_some() &&
        !std::forward<UnaryPredicate&&>(predicate)(value_cref_())) {
      return std::move(*this);
    } else {
      return None;
    }
  }

  [[nodiscard]] constexpr auto OR(Option && alt)&&->Option {
    if (is_some()) {
      return std::move(*this);
    } else {
      return std::move(alt);
    }
  }

  template <typename Fn>
  [[nodiscard]] constexpr auto or_else(Fn && op)&&->Option {
    static_assert(invocable<Fn&&>);
    if (is_some()) {
      return std::move(*this);
    } else {
      return std::forward<Fn&&>(op)();
    }
  }

  [[nodiscard]] constexpr auto XOR(Option && alt)&&->Option {
    if (is_some() && alt.is_none()) {
      return std::move(*this);
    } else if (is_none() && alt.is_some()) {
      return std::move(alt);
    } else {
      return None;
    }
  }

  [[nodiscard]] constexpr auto take()->Option {
    if (is_some()) {
      auto some = Some<T>(std::move(value_ref_()));
      value_ref_().~T();
      is_none_ = true;
      return some;
    } else {
      return None;
    }
  }

  [[nodiscard]] auto replace(T && replacement)->Option {
    if (is_some()) {
      std::swap(replacement, value_ref_());
      return Some<T>(std::move(replacement));
    } else {
      new (&storage_value_) T(std::forward<T&&>(replacement));
      is_none_ = false;
      return None;
    }
  }

  [[nodiscard]] auto replace(T const& replacement)->Option {
    static_assert(copy_constructible<T>);
    if (is_some()) {
      T copy = replacement;
      std::swap(copy, value_ref_());
      return Some<T>(std::move(copy));
    } else {
      new (&storage_value_) T(replacement);
      is_none_ = false;
      return None;
    }
  }

  [[nodiscard]] constexpr auto clone() const->Option {
    static_assert(copy_constructible<T>);
    if (is_some()) {
      return Some<T>(std::move(T(value_cref_())));
    } else {
      return None;
    }
  }

  void expect_none(std::string_view const& msg)&& {
    if (is_some()) {
      internal::option::expect_none_failed(msg);
    }
  }

  void unwrap_none()&& {
    if (is_some()) {
      internal::option::no_none();
    }
  }

  [[nodiscard]] constexpr auto unwrap_or_default()&&->T {
    static_assert(std::is_default_constructible_v<T>);
    if (is_some()) {
      return std::move(value_ref_());
    } else {
      return T();
    }
  }

  template <typename SomeFn, typename NoneFn>
  [[nodiscard]] constexpr auto match(
      SomeFn && some_fn, NoneFn && none_fn)&&->invoke_result<SomeFn&&, T&&> {
    static_assert(invocable<SomeFn&&, T&&>);
    static_assert(invocable<NoneFn&&>);

    if (is_some()) {
      return std::forward<SomeFn&&>(some_fn)(std::move(value_ref_()));
    } else {
      return std::forward<NoneFn&&>(none_fn)();
    }
  }

  template <typename SomeFn, typename NoneFn>
  [[nodiscard]] constexpr auto match(
      SomeFn && some_fn, NoneFn && none_fn)&->invoke_result<SomeFn&&, T&> {
    static_assert(invocable<SomeFn&&, T&>);
    static_assert(invocable<NoneFn&&>);

    if (is_some()) {
      return std::forward<SomeFn&&>(some_fn)(value_ref_());
    } else {
      return std::forward<NoneFn&&>(none_fn)();
    }
  }

  template <typename SomeFn, typename NoneFn>
  [[nodiscard]] constexpr auto match(SomeFn && some_fn, NoneFn && none_fn)
      const&->invoke_result<SomeFn&&, T const&> {
    static_assert(invocable<SomeFn&&, T const&>);
    static_assert(invocable<NoneFn&&>);

    if (is_some()) {
      return std::forward<SomeFn&&>(some_fn)(value_cref_());
    } else {
      return std::forward<NoneFn&&>(none_fn)();
    }
  }

 private:
  union {
    T storage_value_;
  };

  bool is_none_;

  [[nodiscard]] constexpr T& value_ref_() { return storage_value_; }

  [[nodiscard]] constexpr T const& value_cref_() const {
    return storage_value_;
  }

  template <typename Tp>
  friend Tp&& internal::option::unsafe_value_move(Option<Tp>&);
};

template <typename U, typename T>
[[nodiscard]] STX_FORCE_INLINE constexpr bool operator==(
    Some<U> const& cmp, Option<T> const& option) {
  return option == cmp;
}

template <typename U, typename T>
[[nodiscard]] STX_FORCE_INLINE constexpr bool operator!=(
    Some<U> const& cmp, Option<T> const& option) {
  return option != cmp;
}

template <typename T>
[[nodiscard]] STX_FORCE_INLINE constexpr bool operator==(
    NoneType const&, Option<T> const& option) noexcept {
  return option.is_none();
}

template <typename T>
[[nodiscard]] STX_FORCE_INLINE constexpr bool operator!=(
    NoneType const&, Option<T> const& option) noexcept {
  return option.is_some();
}

// JUST LOOK AWAY

namespace internal {
namespace result {

// constructs an r-value reference to the result's value directly, without
// checking if it is in the `Ok` or `Err` state. This is totally unsafe and
// user-end code should **never** use this
template <typename Tp, typename Er>
inline Tp&& unsafe_value_move(Result<Tp, Er>&);

// constructs an r-value reference to the result's error directly, without
// checking if it is in the `Err` or `Ok` state. This is totally unsafe and
// user-end code should **never** use this
template <typename Tp, typename Er>
inline Er&& unsafe_err_move(Result<Tp, Er>&);

}  // namespace result
}  // namespace internal

template <typename T, typename E>
struct [[nodiscard]] Result {
 public:
  static_assert(movable<T>,
                "Value type 'T' for 'Result<T, E>' must be movable");
  static_assert(movable<E>,
                "Error type 'E' for 'Result<T, E>' must be movable");
  static_assert(
      !is_reference<T>,
      "Cannot use a reference for value type 'T' of 'Result<T, E>', To prevent "
      "subtleties use "
      "type wrappers like std::reference_wrapper (stx::Ref) or any of the "
      "`stx::ConstRef` or `stx::MutRef` specialized aliases instead");
  static_assert(
      !is_reference<E>,
      "Cannot use a reference for error type 'E' of 'Result<T, E>', To prevent "
      "subtleties use "
      "type wrappers like std::reference_wrapper (stx::Ref) or any of the "
      "`stx::ConstRef` or `stx::MutRef` specialized aliases instead");

  using value_type = T;
  using error_type = E;

  constexpr Result(Ok<T> && result)
      : storage_value_(std::forward<T>(result.value_)), is_ok_(true) {}

  constexpr Result(Err<E> && err)
      : storage_err_(std::forward<E>(err.value_)), is_ok_(false) {}

  // not possible as constexpr yet:
  // 1 - we need to check which variant is present
  // 2 - the union will be default-constructed (empty) and we thus need to call
  // placement-new in the constructor block
  Result(Result && rhs) : is_ok_(rhs.is_ok_) {
    if (rhs.is_ok()) {
      new (&storage_value_) T(std::move(rhs.storage_value_));
    } else {
      new (&storage_err_) E(std::move(rhs.storage_err_));
    }
  }

  Result& operator=(Result&& rhs) {
    if (is_ok() && rhs.is_ok()) {
      std::swap(value_ref_(), rhs.value_ref_());
    } else if (is_ok() && rhs.is_err()) {
      // we need to place a new value in here (discarding old value)
      storage_value_.~T();
      new (&storage_err_) E(std::move(rhs.storage_err_));
      is_ok_ = false;
    } else if (is_err() && rhs.is_ok()) {
      storage_err_.~E();
      new (&storage_value_) T(std::move(rhs.storage_value_));
      is_ok_ = true;
    } else {
      // both are errs
      std::swap(err_ref_(), rhs.err_ref_());  // NOLINT
    }
    return *this;
  }

  Result() = delete;
  Result(Result const& rhs) = delete;
  Result& operator=(Result const& rhs) = delete;

  STX_CXX20_DESTRUCTOR_CONSTEXPR ~Result() noexcept {
    if (is_ok()) {
      storage_value_.~T();
    } else {
      storage_err_.~E();
    }
  };

  template <typename U>
  [[nodiscard]] constexpr bool operator==(Ok<U> const& cmp) const {
    static_assert(equality_comparable<T, U>);
    if (is_ok()) {
      return value_cref_() == cmp.value();
    } else {
      return false;
    }
  }

  template <typename U>
  [[nodiscard]] constexpr bool operator!=(Ok<U> const& cmp) const {
    static_assert(equality_comparable<T, U>);
    if (is_ok()) {
      return value_cref_() != cmp.value();
    } else {
      return true;
    }
  }

  template <typename F>
  [[nodiscard]] constexpr bool operator==(Err<F> const& cmp) const {
    static_assert(equality_comparable<E, F>);
    if (is_ok()) {
      return false;
    } else {
      return err_cref_() == cmp.value();
    }
  }

  template <typename F>
  [[nodiscard]] constexpr bool operator!=(Err<F> const& cmp) const {
    static_assert(equality_comparable<E, F>);
    if (is_ok()) {
      return true;
    } else {
      return err_cref_() != cmp.value();
    }
  }

  template <typename U, typename F>
  [[nodiscard]] constexpr bool operator==(Result<U, F> const& cmp) const {
    static_assert(equality_comparable<T, U>);
    static_assert(equality_comparable<E, F>);

    if (is_ok() && cmp.is_ok()) {
      return value_cref_() == cmp.value_cref_();
    } else if (is_err() && cmp.is_err()) {
      return err_cref_() == cmp.err_cref_();
    } else {
      return false;
    }
  }

  template <typename U, typename F>
  [[nodiscard]] constexpr bool operator!=(Result<U, F> const& cmp) const {
    static_assert(equality_comparable<T, U>);
    static_assert(equality_comparable<E, F>);

    if (is_ok() && cmp.is_ok()) {
      return value_cref_() != cmp.value_cref_();
    } else if (is_err() && cmp.is_err()) {
      return err_cref_() != cmp.err_cref_();
    } else {
      return true;
    }
  }

  [[nodiscard]] constexpr bool is_ok() const noexcept { return is_ok_; }

  [[nodiscard]] constexpr bool is_err() const noexcept { return !is_ok(); }

  [[nodiscard]] operator bool() const noexcept { return is_ok(); }

  template <typename CmpType>
  [[nodiscard]] constexpr bool contains(CmpType const& cmp) const {
    static_assert(equality_comparable<T, CmpType>);
    if (is_ok()) {
      return value_cref_() == cmp;
    } else {
      return false;
    }
  }

  template <typename ErrCmp>
  [[nodiscard]] constexpr bool contains_err(ErrCmp const& cmp) const {
    static_assert(equality_comparable<E, ErrCmp>);
    if (is_ok()) {
      return false;
    } else {
      return err_cref_() == cmp;
    }
  }

  template <typename UnaryPredicate>
  [[nodiscard]] constexpr bool exists(UnaryPredicate && predicate) const {
    static_assert(invocable<UnaryPredicate&&, T const&>);
    static_assert(convertible<invoke_result<UnaryPredicate&&, T const&>, bool>);

    if (is_ok()) {
      return std::forward<UnaryPredicate&&>(predicate)(value_cref_());
    } else {
      return false;
    }
  }

  template <typename UnaryPredicate>
  [[nodiscard]] constexpr bool err_exists(UnaryPredicate && predicate) const {
    static_assert(invocable<UnaryPredicate&&, E const&>);
    static_assert(convertible<invoke_result<UnaryPredicate&&, E const&>, bool>);

    if (is_err()) {
      return std::forward<UnaryPredicate&&>(predicate)(err_cref_());
    } else {
      return false;
    }
  }

  [[nodiscard]] T& value()& noexcept {
    if (is_err()) internal::result::no_lref(err_cref_());
    return value_ref_();
  }

  [[nodiscard]] T const& value() const& noexcept {
    if (is_err()) internal::result::no_lref(err_cref_());
    return value_cref_();
  }

  [[deprecated("Use `unwrap()` instead")]] T value()&& = delete;
  [[deprecated("Use `unwrap()` instead")]] T const value() const&& = delete;

  [[nodiscard]] E& err_value()& noexcept {
    if (is_ok()) internal::result::no_err_lref();
    return err_ref_();
  }

  [[nodiscard]] E const& err_value() const& noexcept {
    if (is_ok()) internal::result::no_err_lref();
    return err_cref_();
  }

  [[deprecated("Use `unwrap_err()` instead")]] E err_value()&& = delete;
  [[deprecated("Use `unwrap_err()` instead")]] E const err_value() const&& =
      delete;

  [[nodiscard]] constexpr auto ok()&&->Option<T> {
    if (is_ok()) {
      return Some<T>(std::move(value_ref_()));
    } else {
      return None;
    }
  }

  [[nodiscard]] constexpr auto err()&&->Option<E> {
    if (is_ok()) {
      return None;
    } else {
      return Some<E>(std::move(err_ref_()));
    }
  }

  [[nodiscard]] constexpr auto as_cref()
      const& noexcept->Result<ConstRef<T>, ConstRef<E>> {
    if (is_ok()) {
      return Ok<ConstRef<T>>(ConstRef<T>(value_cref_()));
    } else {
      return Err<ConstRef<E>>(ConstRef<E>(err_cref_()));
    }
  }

  [[deprecated(
      "calling Result::as_cref() on an r-value, and "
      "therefore binding an l-value reference to an object that is marked to "
      "be moved")]]  //
  [[nodiscard]] constexpr auto
  as_cref() const&& noexcept->Result<ConstRef<T>, ConstRef<E>> = delete;

  [[nodiscard]] constexpr auto as_ref()& noexcept
      ->Result<MutRef<T>, MutRef<E>> {
    if (is_ok()) {
      return Ok<MutRef<T>>(MutRef<T>(value_ref_()));
    } else {
      return Err<MutRef<E>>(MutRef<E>(err_ref_()));
    }
  }

  [[nodiscard]] constexpr auto as_ref()
      const& noexcept->Result<ConstRef<T>, ConstRef<E>> {
    return as_cref();
  }

  [[deprecated(
      "calling Result::as_ref() on an r-value, and therefore binding a "
      "reference to an object that is marked to be moved")]]  //
  [[nodiscard]] constexpr auto
  as_ref()&& noexcept->Result<MutRef<T>, MutRef<E>> = delete;

  [[deprecated(
      "calling Result::as_ref() on an r-value, and therefore binding a "
      "reference to an object that is marked to be moved")]]  //
  [[nodiscard]] constexpr auto
  as_ref() const&& noexcept->Result<ConstRef<T>, ConstRef<E>> = delete;

  template <typename Fn>
  [[nodiscard]] constexpr auto map(Fn &&
                                   op)&&->Result<invoke_result<Fn&&, T&&>, E> {
    static_assert(invocable<Fn&&, T&&>);
    if (is_ok()) {
      return Ok<invoke_result<Fn&&, T&&>>(
          std::forward<Fn&&>(op)(std::move(value_ref_())));
    } else {
      return Err<E>(std::move(err_ref_()));
    }
  }

  template <typename Fn, typename AltType>
  [[nodiscard]] constexpr auto map_or(
      Fn && op, AltType && alt)&&->invoke_result<Fn&&, T&&> {
    static_assert(invocable<Fn&&, T&&>);
    if (is_ok()) {
      return std::forward<Fn&&>(op)(std::move(value_ref_()));
    } else {
      return std::forward<AltType&&>(alt);
    }
  }

  template <typename Fn, typename A>
  [[nodiscard]] constexpr auto map_or_else(
      Fn && op, A && alt_op)&&->invoke_result<Fn&&, T&&> {
    static_assert(invocable<Fn&&, T&&>);
    static_assert(invocable<A&&, E&&>);

    if (is_ok()) {
      return std::forward<Fn&&>(op)(std::move(value_ref_()));
    } else {
      return std::forward<A&&>(alt_op)(std::move(err_ref_()));
    }
  }

  template <typename Fn>
  [[nodiscard]] constexpr auto map_err(
      Fn && op)&&->Result<T, invoke_result<Fn&&, E&&>> {
    static_assert(invocable<Fn&&, E&&>);
    if (is_ok()) {
      return Ok<T>(std::move(value_ref_()));
    } else {
      return Err<invoke_result<Fn&&, E&&>>(
          std::forward<Fn&&>(op)(std::move(err_ref_())));
    }
  }

  // a copy attempt like passing a const could cause an error
  template <typename U, typename F>
  [[nodiscard]] constexpr auto AND(Result<U, F> && res)&&->Result<U, F> {
    static_assert(convertible<E&&, F>);
    if (is_ok()) {
      return std::forward<Result<U, F>&&>(res);
    } else {
      return Err<F>(std::move(static_cast<F>(std::move(err_ref_()))));
    }
  }

  template <typename Fn>
  [[nodiscard]] constexpr auto and_then(
      Fn && op)&&->Result<invoke_result<Fn&&, T&&>, E> {
    static_assert(invocable<Fn&&, T&&>);
    if (is_ok()) {
      return Ok<invoke_result<Fn&&, T&&>>(
          std::forward<Fn&&>(op)(std::move(value_ref_())));
    } else {
      return Err<E>(std::move(err_ref_()));
    }
  }

  // passing a const ref will cause an error
  template <typename U, typename F>
  [[nodiscard]] constexpr auto OR(Result<U, F> && alt)&&->Result<U, F> {
    static_assert(convertible<T&&, U>);
    if (is_ok()) {
      return Ok<U>(std::move(static_cast<U>(std::move(value_ref_()))));
    } else {
      return std::forward<Result<U, F>&&>(alt);
    }
  }

  template <typename Fn>
  [[nodiscard]] constexpr auto or_else(Fn && op)&&->invoke_result<Fn&&, E&&> {
    static_assert(invocable<Fn&&, E&&>);
    if (is_ok()) {
      return Ok<T>(std::move(value_ref_()));
    } else {
      return std::forward<Fn&&>(op)(std::move(err_ref_()));
    }
  }

  [[nodiscard]] constexpr auto unwrap_or(T && alt)&&->T {
    if (is_ok()) {
      return std::move(value_ref_());
    } else {
      return std::move(alt);
    }
  }

  template <typename Fn>
  [[nodiscard]] constexpr auto unwrap_or_else(Fn && op)&&->T {
    static_assert(invocable<Fn&&, E&&>);
    if (is_ok()) {
      return std::move(value_ref_());
    } else {
      return std::forward<Fn&&>(op)(std::move(err_ref_()));
    }
  }

  [[nodiscard]] auto unwrap()&&->T {
    if (is_err()) {
      internal::result::no_value(err_cref_());
    }
    return std::move(value_ref_());
  }

  [[nodiscard]] auto expect(std::string_view const& msg)&&->T {
    if (is_err()) {
      internal::result::expect_value_failed(msg, err_cref_());
    }
    return std::move(value_ref_());
  }

  [[nodiscard]] auto unwrap_err()&&->E {
    if (is_ok()) {
      internal::result::no_err();
    }
    return std::move(err_ref_());
  }

  [[nodiscard]] auto expect_err(std::string_view const& msg)&&->E {
    if (is_ok()) {
      internal::result::expect_err_failed(msg);
    }
    return std::move(err_ref_());
  }

  [[nodiscard]] constexpr auto unwrap_or_default()&&->T {
    static_assert(std::is_default_constructible_v<T>);
    if (is_ok()) {
      return std::move(value_ref_());
    } else {
      return T();
    }
  }

  template <typename OkFn, typename ErrFn>
  [[nodiscard]] constexpr auto match(
      OkFn && ok_fn, ErrFn && err_fn)&&->invoke_result<OkFn&&, T&&> {
    static_assert(invocable<OkFn&&, T&&>);
    static_assert(invocable<ErrFn&&, E&&>);

    if (is_ok()) {
      return std::forward<OkFn&&>(ok_fn)(std::move(value_ref_()));
    } else {
      return std::forward<ErrFn&&>(err_fn)(std::move(err_ref_()));
    }
  }

  template <typename OkFn, typename ErrFn>
  [[nodiscard]] constexpr auto match(
      OkFn && ok_fn, ErrFn && err_fn)&->invoke_result<OkFn&&, T&> {
    static_assert(invocable<OkFn&&, T&>);
    static_assert(invocable<ErrFn&&, E&>);

    if (is_ok()) {
      return std::forward<OkFn&&>(ok_fn)(value_ref_());
    } else {
      return std::forward<ErrFn&&>(err_fn)(err_ref_());
    }
  }

  template <typename OkFn, typename ErrFn>
  [[nodiscard]] constexpr auto match(OkFn && ok_fn, ErrFn && err_fn)
      const&->invoke_result<OkFn&&, T const&> {
    static_assert(invocable<OkFn&&, T const&>);
    static_assert(invocable<ErrFn&&, E const&>);

    if (is_ok()) {
      return std::forward<OkFn&&>(ok_fn)(value_cref_());
    } else {
      return std::forward<ErrFn&&>(err_fn)(err_cref_());
    }
  }

  [[nodiscard]] constexpr auto clone() const->Result<T, E> {
    static_assert(copy_constructible<T>);
    static_assert(copy_constructible<E>);

    if (is_ok()) {
      return Ok<T>(std::move(T(value_cref_())));
    } else {
      return Err<E>(std::move(E(err_cref_())));
    }
  }

 private:
  union {
    T storage_value_;
    E storage_err_;
  };

  bool is_ok_;

  [[nodiscard]] constexpr T& value_ref_() noexcept { return storage_value_; }

  [[nodiscard]] constexpr T const& value_cref_() const noexcept {
    return storage_value_;
  }

  [[nodiscard]] constexpr E& err_ref_() noexcept { return storage_err_; }

  [[nodiscard]] constexpr E const& err_cref_() const noexcept {
    return storage_err_;
  }

  template <typename Tp, typename Er>
  friend Tp&& internal::result::unsafe_value_move(Result<Tp, Er>&);

  template <typename Tp, typename Er>
  friend Er&& internal::result::unsafe_err_move(Result<Tp, Er>&);
};

template <typename U, typename T, typename E>
[[nodiscard]] STX_FORCE_INLINE constexpr bool operator==(
    Ok<U> const& cmp, Result<T, E> const& result) {
  return result == cmp;
}

template <typename U, typename T, typename E>
[[nodiscard]] STX_FORCE_INLINE constexpr bool operator!=(
    Ok<U> const& cmp, Result<T, E> const& result) {
  return result != cmp;
}

template <typename F, typename T, typename E>
[[nodiscard]] STX_FORCE_INLINE constexpr bool operator==(
    Err<F> const& cmp, Result<T, E> const& result) {
  return result == cmp;
}

template <typename F, typename T, typename E>
[[nodiscard]] STX_FORCE_INLINE constexpr bool operator!=(
    Err<F> const& cmp, Result<T, E> const& result) {
  return result != cmp;
}

/*********************    HELPER FUNCTIONS    *********************/

template <typename T>
[[nodiscard]] STX_FORCE_INLINE constexpr auto make_some(T value) -> Option<T> {
  return Some<T>(std::forward<T>(value));
}

template <typename T>
[[nodiscard]] STX_FORCE_INLINE constexpr auto make_none() noexcept
    -> Option<T> {
  return None;
}

template <typename T, typename E>
[[nodiscard]] STX_FORCE_INLINE constexpr auto make_ok(T value) -> Result<T, E> {
  return Ok<T>(std::forward<T>(value));
}

template <typename T, typename E>
[[nodiscard]] STX_FORCE_INLINE constexpr auto make_err(E err) -> Result<T, E> {
  return Err<E>(std::forward<E>(err));
}

template <typename T>
STX_FORCE_INLINE auto some_ref(T& value) noexcept {
  return Some<Ref<T>>(std::forward<T&>(value));
}

template <typename T>
STX_FORCE_INLINE auto ok_ref(T& value) noexcept {
  return Ok<Ref<T>>(std::forward<T&>(value));
}

template <typename E>
STX_FORCE_INLINE auto err_ref(E& value) noexcept {
  return Err<Ref<E>>(std::forward<E&>(value));
}

STX_END_NAMESPACE

// Error propagation macros
#include "stx/internal/try.h"