/*
 * Copyright (C) 2019 The Android Open Source Project
 *
 * 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.
 */

#pragma once

#include <algorithm>
#include <initializer_list>
#include <type_traits>
#include <utility>
#include <variant>

// android::base::expected is a partial implementation of C++23's std::expected
// for Android.
//
// Usage:
// using android::base::expected;
// using android::base::unexpected;
//
// expected<double,std::string> safe_divide(double i, double j) {
//   if (j == 0) return unexpected("divide by zero");
//   else return i / j;
// }
//
// void test() {
//   auto q = safe_divide(10, 0);
//   if (q.ok()) { printf("%f\n", q.value()); }
//   else { printf("%s\n", q.error().c_str()); }
// }
//
// Once the Android platform has moved to C++23, this will be removed and
// android::base::expected will be type aliased to std::expected.
//

namespace android {
namespace base {

// Synopsis
template <class T, class E>
class expected;

template <class E>
class unexpected;
template <class E>
unexpected(E) -> unexpected<E>;

template <class E>
class bad_expected_access;

template <>
class bad_expected_access<void>;

struct unexpect_t {
   explicit unexpect_t() = default;
};
inline constexpr unexpect_t unexpect{};

// macros for SFINAE
#define _ENABLE_IF(...) \
  , std::enable_if_t<(__VA_ARGS__)>* = nullptr

// Define NODISCARD_EXPECTED to prevent expected<T,E> from being
// ignored when used as a return value. This is off by default.
#ifdef NODISCARD_EXPECTED
#define _NODISCARD_ [[nodiscard]]
#else
#define _NODISCARD_
#endif

#define _EXPLICIT(cond)                                                     \
  _Pragma("clang diagnostic push")                                          \
  _Pragma("clang diagnostic ignored \"-Wc++20-extensions\"") explicit(cond) \
  _Pragma("clang diagnostic pop")

#define _COMMA ,

namespace expected_internal {

template <class T>
struct remove_cvref {
  using type = std::remove_cv_t<std::remove_reference_t<T>>;
};

template <class T>
using remove_cvref_t = typename remove_cvref<T>::type;

// Can T be constructed from W (or W converted to T)? W can be lvalue or rvalue,
// const or not.
template <class T, class W>
inline constexpr bool converts_from_any_cvref =
    std::disjunction_v<std::is_constructible<T, W&>, std::is_convertible<W&, T>,
                       std::is_constructible<T, W>, std::is_convertible<W, T>,
                       std::is_constructible<T, const W&>, std::is_convertible<const W&, T>,
                       std::is_constructible<T, const W>, std::is_convertible<const W, T>>;

template <class T>
struct is_expected : std::false_type {};

template <class T, class E>
struct is_expected<expected<T, E>> : std::true_type {};

template <class T>
inline constexpr bool is_expected_v = is_expected<T>::value;

template <class T>
struct is_unexpected : std::false_type {};

template <class E>
struct is_unexpected<unexpected<E>> : std::true_type {};

template <class T>
inline constexpr bool is_unexpected_v = is_unexpected<T>::value;

// Constraints on constructing an expected<T, ...> from an expected<U, G>
// related to T and U. UF is either "const U&" or "U".
template <class T, class U, class G, class UF>
inline constexpr bool convert_value_constraints =
    std::is_constructible_v<T, UF> &&
    (std::is_same_v<std::remove_cv_t<T>, bool> || !converts_from_any_cvref<T, expected<U, G>>);

// Constraints on constructing an expected<..., E> from an expected<U, G>
// related to E, G, and expected<U, G>. GF is either "const G&" or "G".
template <class E, class U, class G, class GF>
inline constexpr bool convert_error_constraints =
    std::is_constructible_v<E, GF> &&
    !std::is_constructible_v<unexpected<E>, expected<U, G>&> &&
    !std::is_constructible_v<unexpected<E>, expected<U, G>> &&
    !std::is_constructible_v<unexpected<E>, const expected<U, G>&> &&
    !std::is_constructible_v<unexpected<E>, const expected<U, G>>;

// If an exception is thrown in expected::operator=, while changing the expected
// object between a value and an error, the expected object is supposed to
// retain its original value, which is only possible if certain constructors
// are noexcept. This implementation doesn't try to be exception-safe, but
// enforce these constraints anyway because std::expected also will enforce
// them, and we intend to switch to it eventually.
template <class T, class E, class Self, class Value>
inline constexpr bool eh_assign_constraints =
    std::is_nothrow_constructible_v<Self, Value> ||
    std::is_nothrow_move_constructible_v<T> ||
    std::is_nothrow_move_constructible_v<E>;

// Implement expected<..., E>::expected([const] unexpected<G> [&/&&]).
#define _CONSTRUCT_EXPECTED_FROM_UNEXPECTED(GF, ParamType, forward_func)     \
  template <class G _ENABLE_IF(std::is_constructible_v<E, GF>)>              \
  constexpr _EXPLICIT((!std::is_convertible_v<GF, E>))                       \
      expected(ParamType e) noexcept(std::is_nothrow_constructible_v<E, GF>) \
      : var_(std::in_place_index<1>, forward_func(e.error())) {}

// Implement expected<..., E>::operator=([const] unexpected<G> [&/&&]).
#define _ASSIGN_UNEXPECTED_TO_EXPECTED(GF, ParamType, forward_func, extra_constraints)          \
  template <class G _ENABLE_IF(std::is_constructible_v<E, GF> &&                                \
                               std::is_assignable_v<E&, GF>) &&                                 \
                               extra_constraints>                                               \
  constexpr expected& operator=(ParamType e) noexcept(std::is_nothrow_constructible_v<E, GF> && \
                                                      std::is_nothrow_assignable_v<E&, GF>) {   \
    if (has_value()) {                                                                          \
      var_.template emplace<1>(forward_func(e.error()));                                        \
    } else {                                                                                    \
      error() = forward_func(e.error());                                                        \
    }                                                                                           \
    return *this;                                                                               \
  }

}  // namespace expected_internal

// Class expected
template <class T, class E>
class _NODISCARD_ expected {
  static_assert(std::is_object_v<T> && !std::is_array_v<T> &&
                    !std::is_same_v<std::remove_cv_t<T>, std::in_place_t> &&
                    !std::is_same_v<std::remove_cv_t<T>, unexpect_t> &&
                    !expected_internal::is_unexpected_v<std::remove_cv_t<T>>,
                "expected value type cannot be a reference, a function, an array, in_place_t, "
                "unexpect_t, or unexpected");

 public:
  using value_type = T;
  using error_type = E;
  using unexpected_type = unexpected<E>;

  template <class U>
  using rebind = expected<U, error_type>;

  // Delegate simple operations to the underlying std::variant. std::variant
  // doesn't set noexcept well, at least for copy ctor/assign, so set it
  // explicitly. Technically the copy/move assignment operators should also be
  // deleted if neither T nor E satisfies is_nothrow_move_constructible_v, but
  // that would require making these operator= methods into template functions.
  constexpr expected() = default;
  constexpr expected(const expected& rhs) noexcept(
      std::is_nothrow_copy_constructible_v<T> && std::is_nothrow_copy_constructible_v<E>) = default;
  constexpr expected(expected&& rhs) noexcept(std::is_nothrow_move_constructible_v<T> &&
                                              std::is_nothrow_move_constructible_v<E>) = default;
  constexpr expected& operator=(const expected& rhs) noexcept(
      std::is_nothrow_copy_constructible_v<T> && std::is_nothrow_copy_assignable_v<T> &&
      std::is_nothrow_copy_constructible_v<E> && std::is_nothrow_copy_assignable_v<E>) = default;
  constexpr expected& operator=(expected&& rhs) noexcept(
      std::is_nothrow_move_constructible_v<T> && std::is_nothrow_move_assignable_v<T> &&
      std::is_nothrow_move_constructible_v<E> && std::is_nothrow_move_assignable_v<E>) = default;

  // Construct this expected<T, E> from a different expected<U, G> type.
#define _CONVERTING_CTOR(UF, GF, ParamType, forward_func)                                      \
  template <class U,                                                                           \
            class G _ENABLE_IF(expected_internal::convert_value_constraints<T, U, G, UF> &&    \
                               expected_internal::convert_error_constraints<E, U, G, GF>)>     \
  constexpr _EXPLICIT((!std::is_convertible_v<UF, T> || !std::is_convertible_v<GF, E>))        \
      expected(ParamType rhs) noexcept(std::is_nothrow_constructible_v<T, UF> &&               \
                                       std::is_nothrow_constructible_v<E, GF>)                 \
      : var_(rhs.has_value() ? variant_type(std::in_place_index<0>, forward_func(rhs.value())) \
                             : variant_type(std::in_place_index<1>, forward_func(rhs.error()))) {}

  // NOLINTNEXTLINE(google-explicit-constructor)
  _CONVERTING_CTOR(const U&, const G&, const expected<U _COMMA G>&, )
  // NOLINTNEXTLINE(google-explicit-constructor)
  _CONVERTING_CTOR(U, G, expected<U _COMMA G>&&, std::move)

#undef _CONVERTING_CTOR

  // Construct from (converted) success value, using a forwarding reference.
  template <class U = T _ENABLE_IF(
                !std::is_same_v<expected_internal::remove_cvref_t<U>, std::in_place_t> &&
                !std::is_same_v<expected_internal::remove_cvref_t<U>, expected> &&
                !expected_internal::is_unexpected_v<expected_internal::remove_cvref_t<U>> &&
                std::is_constructible_v<T, U> &&
                (!std::is_same_v<std::remove_cv_t<T>, bool> ||
                 !expected_internal::is_expected_v<expected_internal::remove_cvref_t<U>>))>
  constexpr _EXPLICIT((!std::is_convertible_v<U, T>))
      // NOLINTNEXTLINE(google-explicit-constructor)
      expected(U&& v) noexcept(std::is_nothrow_constructible_v<T, U>)
      : var_(std::in_place_index<0>, std::forward<U>(v)) {}

  // NOLINTNEXTLINE(google-explicit-constructor)
  _CONSTRUCT_EXPECTED_FROM_UNEXPECTED(const G&, const unexpected<G>&, )
  // NOLINTNEXTLINE(google-explicit-constructor)
  _CONSTRUCT_EXPECTED_FROM_UNEXPECTED(G, unexpected<G>&&, std::move)

  // in_place_t construction
  template <class... Args _ENABLE_IF(std::is_constructible_v<T, Args...>)>
  constexpr explicit expected(std::in_place_t, Args&&... args)
      noexcept(std::is_nothrow_constructible_v<T, Args...>)
      : var_(std::in_place_index<0>, std::forward<Args>(args)...) {}

  // in_place_t with initializer_list construction
  template <class U, class... Args _ENABLE_IF(
      std::is_constructible_v<T, std::initializer_list<U>&, Args...>)>
  constexpr explicit expected(std::in_place_t, std::initializer_list<U> il, Args&&... args)
      noexcept(std::is_nothrow_constructible_v<T, std::initializer_list<U>&, Args...>)
      : var_(std::in_place_index<0>, il, std::forward<Args>(args)...) {}

  // unexpect_t construction
  template <class... Args _ENABLE_IF(std::is_constructible_v<E, Args...>)>
  constexpr explicit expected(unexpect_t, Args&&... args)
      noexcept(std::is_nothrow_constructible_v<E, Args...>)
      : var_(std::in_place_index<1>, unexpected_type(std::forward<Args>(args)...)) {}

  // unexpect_t with initializer_list construction
  template <class U, class... Args _ENABLE_IF(
      std::is_constructible_v<E, std::initializer_list<U>&, Args...>)>
  constexpr explicit expected(unexpect_t, std::initializer_list<U> il, Args&&... args)
      noexcept(std::is_nothrow_constructible_v<E, std::initializer_list<U>&, Args...>)
      : var_(std::in_place_index<1>, unexpected_type(il, std::forward<Args>(args)...)) {}

  // Assignment from (converted) success value, using a forwarding reference.
  template <class U = T _ENABLE_IF(
                !std::is_same_v<expected, expected_internal::remove_cvref_t<U>> &&
                !expected_internal::is_unexpected_v<expected_internal::remove_cvref_t<U>> &&
                std::is_constructible_v<T, U> && std::is_assignable_v<T&, U> &&
                expected_internal::eh_assign_constraints<T, E, T, U>)>
  constexpr expected& operator=(U&& v) noexcept(std::is_nothrow_constructible_v<T, U> &&
                                                std::is_nothrow_assignable_v<T&, U>) {
    if (has_value()) {
      value() = std::forward<U>(v);
    } else {
      var_.template emplace<0>(std::forward<U>(v));
    }
    return *this;
  }

  _ASSIGN_UNEXPECTED_TO_EXPECTED(const G&, const unexpected<G>&, ,
                                 (expected_internal::eh_assign_constraints<T, E, E, const G&>))
  _ASSIGN_UNEXPECTED_TO_EXPECTED(G, unexpected<G>&&, std::move,
                                 (expected_internal::eh_assign_constraints<T, E, E, G>))

  // modifiers
  template <class... Args _ENABLE_IF(std::is_nothrow_constructible_v<T, Args...>)>
  constexpr T& emplace(Args&&... args) noexcept {
    var_.template emplace<0>(std::forward<Args>(args)...);
    return value();
  }

  template <class U, class... Args _ENABLE_IF(
                         std::is_nothrow_constructible_v<T, std::initializer_list<U>&, Args...>)>
  constexpr T& emplace(std::initializer_list<U> il, Args&&... args) noexcept {
    var_.template emplace<0>(il, std::forward<Args>(args)...);
    return value();
  }

  // Swap. This function takes a template argument so that _ENABLE_IF works.
  template <class U = T _ENABLE_IF(
                std::is_same_v<U, T> &&
                    std::is_swappable_v<T> && std::is_swappable_v<E> &&
                    std::is_move_constructible_v<T> && std::is_move_constructible_v<E> &&
                (std::is_nothrow_move_constructible_v<T> ||
                 std::is_nothrow_move_constructible_v<E>))>
  constexpr void swap(expected& rhs) noexcept(std::is_nothrow_move_constructible_v<T> &&
                                              std::is_nothrow_swappable_v<T> &&
                                              std::is_nothrow_move_constructible_v<E> &&
                                              std::is_nothrow_swappable_v<E>) {
    var_.swap(rhs.var_);
  }

  // observers
  constexpr const T* operator->() const { return std::addressof(value()); }
  constexpr T* operator->() { return std::addressof(value()); }
  constexpr const T& operator*() const& { return value(); }
  constexpr T& operator*() & { return value(); }
  constexpr const T&& operator*() const&& { return std::move(std::get<T>(var_)); }
  constexpr T&& operator*() && { return std::move(std::get<T>(var_)); }

  constexpr bool has_value() const noexcept { return var_.index() == 0; }
  constexpr bool ok() const noexcept { return has_value(); }
  constexpr explicit operator bool() const noexcept { return has_value(); }

  constexpr const T& value() const& { return std::get<T>(var_); }
  constexpr T& value() & { return std::get<T>(var_); }
  constexpr const T&& value() const&& { return std::move(std::get<T>(var_)); }
  constexpr T&& value() && { return std::move(std::get<T>(var_)); }

  constexpr const E& error() const& { return std::get<unexpected_type>(var_).error(); }
  constexpr E& error() & { return std::get<unexpected_type>(var_).error(); }
  constexpr const E&& error() const&& { return std::move(std::get<unexpected_type>(var_)).error(); }
  constexpr E&& error() && { return std::move(std::get<unexpected_type>(var_)).error(); }

  template<class U _ENABLE_IF(
    std::is_copy_constructible_v<T> &&
    std::is_convertible_v<U, T>
  )>
  constexpr T value_or(U&& v) const& {
    if (has_value()) return value();
    else return static_cast<T>(std::forward<U>(v));
  }

  template<class U _ENABLE_IF(
    std::is_move_constructible_v<T> &&
    std::is_convertible_v<U, T>
  )>
  constexpr T value_or(U&& v) && {
    if (has_value()) return std::move(value());
    else return static_cast<T>(std::forward<U>(v));
  }

  // expected equality operators
  template<class T1, class E1, class T2, class E2>
  friend constexpr bool operator==(const expected<T1, E1>& x, const expected<T2, E2>& y);
  template<class T1, class E1, class T2, class E2>
  friend constexpr bool operator!=(const expected<T1, E1>& x, const expected<T2, E2>& y);

  // Comparison with unexpected<E>
  template<class T1, class E1, class E2>
  friend constexpr bool operator==(const expected<T1, E1>&, const unexpected<E2>&);
  template<class T1, class E1, class E2>
  friend constexpr bool operator==(const unexpected<E2>&, const expected<T1, E1>&);
  template<class T1, class E1, class E2>
  friend constexpr bool operator!=(const expected<T1, E1>&, const unexpected<E2>&);
  template<class T1, class E1, class E2>
  friend constexpr bool operator!=(const unexpected<E2>&, const expected<T1, E1>&);

 private:
  using variant_type = std::variant<value_type, unexpected_type>;
  variant_type var_;
};

template<class T1, class E1, class T2, class E2>
constexpr bool operator==(const expected<T1, E1>& x, const expected<T2, E2>& y) {
  if (x.has_value() != y.has_value()) return false;
  if (!x.has_value()) return x.error() == y.error();
  return *x == *y;
}

template<class T1, class E1, class T2, class E2>
constexpr bool operator!=(const expected<T1, E1>& x, const expected<T2, E2>& y) {
  return !(x == y);
}

// Comparison with unexpected<E>
template<class T1, class E1, class E2>
constexpr bool operator==(const expected<T1, E1>& x, const unexpected<E2>& y) {
  return !x.has_value() && (x.error() == y.error());
}
template<class T1, class E1, class E2>
constexpr bool operator==(const unexpected<E2>& x, const expected<T1, E1>& y) {
  return !y.has_value() && (x.error() == y.error());
}
template<class T1, class E1, class E2>
constexpr bool operator!=(const expected<T1, E1>& x, const unexpected<E2>& y) {
  return x.has_value() || (x.error() != y.error());
}
template<class T1, class E1, class E2>
constexpr bool operator!=(const unexpected<E2>& x, const expected<T1, E1>& y) {
  return y.has_value() || (x.error() != y.error());
}

template<class E>
class _NODISCARD_ expected<void, E> {
 public:
  using value_type = void;
  using error_type = E;
  using unexpected_type = unexpected<E>;

  template <class U>
  using rebind = expected<U, error_type>;

  // Delegate simple operations to the underlying std::variant.
  constexpr expected() = default;
  constexpr expected(const expected& rhs) noexcept(std::is_nothrow_copy_constructible_v<E>) =
      default;
  constexpr expected(expected&& rhs) noexcept(std::is_nothrow_move_constructible_v<E>) = default;
  constexpr expected& operator=(const expected& rhs) noexcept(
      std::is_nothrow_copy_constructible_v<E> && std::is_nothrow_copy_assignable_v<E>) = default;
  constexpr expected& operator=(expected&& rhs) noexcept(
      std::is_nothrow_move_constructible_v<E> && std::is_nothrow_move_assignable_v<E>) = default;

  // Construct this expected<void, E> from a different expected<U, G> type.
#define _CONVERTING_CTOR(GF, ParamType, forward_func)                                 \
  template <class U, class G _ENABLE_IF(std::is_void_v<U> &&                          \
        expected_internal::convert_error_constraints<E, U, G, GF>)>                   \
  constexpr _EXPLICIT((!std::is_convertible_v<GF, E>))                                \
      expected(ParamType rhs) noexcept(std::is_nothrow_constructible_v<E, GF>)        \
      : var_(rhs.has_value() ? variant_type(std::in_place_index<0>, std::monostate()) \
                             : variant_type(std::in_place_index<1>, forward_func(rhs.error()))) {}

  // NOLINTNEXTLINE(google-explicit-constructor)
  _CONVERTING_CTOR(const G&, const expected<U _COMMA G>&, )
  // NOLINTNEXTLINE(google-explicit-constructor)
  _CONVERTING_CTOR(G, expected<U _COMMA G>&&, std::move)

#undef _CONVERTING_CTOR

  // NOLINTNEXTLINE(google-explicit-constructor)
  _CONSTRUCT_EXPECTED_FROM_UNEXPECTED(const G&, const unexpected<G>&, )
  // NOLINTNEXTLINE(google-explicit-constructor)
  _CONSTRUCT_EXPECTED_FROM_UNEXPECTED(G, unexpected<G>&&, std::move)

  // in_place_t construction
  constexpr explicit expected(std::in_place_t) noexcept {}

  // unexpect_t construction
  template <class... Args _ENABLE_IF(std::is_constructible_v<E, Args...>)>
  constexpr explicit expected(unexpect_t, Args&&... args)
      noexcept(std::is_nothrow_constructible_v<E, Args...>)
      : var_(std::in_place_index<1>, unexpected_type(std::forward<Args>(args)...)) {}

  // unexpect_t with initializer_list construction
  template <class U, class... Args _ENABLE_IF(
                         std::is_constructible_v<E, std::initializer_list<U>&, Args...>)>
  constexpr explicit expected(unexpect_t, std::initializer_list<U> il, Args&&... args)
      noexcept(std::is_nothrow_constructible_v<E, std::initializer_list<U>&, Args...>)
      : var_(std::in_place_index<1>, unexpected_type(il, std::forward<Args>(args)...)) {}

  _ASSIGN_UNEXPECTED_TO_EXPECTED(const G&, const unexpected<G>&, , true)
  _ASSIGN_UNEXPECTED_TO_EXPECTED(G, unexpected<G>&&, std::move, true)

  // modifiers
  constexpr void emplace() noexcept { var_.template emplace<0>(std::monostate()); }

  // Swap. This function takes a template argument so that _ENABLE_IF works.
  template <class G = E _ENABLE_IF(std::is_same_v<G, E> &&
                                   std::is_swappable_v<E> && std::is_move_constructible_v<E>)>
  constexpr void swap(expected& rhs) noexcept(std::is_nothrow_move_constructible_v<E> &&
                                              std::is_nothrow_swappable_v<E>) {
    var_.swap(rhs.var_);
  }

  // observers
  constexpr bool has_value() const noexcept { return var_.index() == 0; }
  constexpr bool ok() const noexcept { return has_value(); }
  constexpr explicit operator bool() const noexcept { return has_value(); }

  constexpr void value() const& { if (!has_value()) std::get<0>(var_); }

  constexpr const E& error() const& { return std::get<1>(var_).error(); }
  constexpr E& error() & { return std::get<1>(var_).error(); }
  constexpr const E&& error() const&& { return std::move(std::get<1>(var_)).error(); }
  constexpr E&& error() && { return std::move(std::get<1>(var_)).error(); }

  // expected equality operators
  template<class E1, class E2>
  friend constexpr bool operator==(const expected<void, E1>& x, const expected<void, E2>& y);

 private:
  using variant_type = std::variant<std::monostate, unexpected_type>;
  variant_type var_;
};

template<class E1, class E2>
constexpr bool operator==(const expected<void, E1>& x, const expected<void, E2>& y) {
  if (x.has_value() != y.has_value()) return false;
  if (!x.has_value()) return x.error() == y.error();
  return true;
}

template<class T1, class E1, class E2>
constexpr bool operator==(const expected<T1, E1>& x, const expected<void, E2>& y) {
  if (x.has_value() != y.has_value()) return false;
  if (!x.has_value()) return x.error() == y.error();
  return false;
}

template<class E1, class T2, class E2>
constexpr bool operator==(const expected<void, E1>& x, const expected<T2, E2>& y) {
  if (x.has_value() != y.has_value()) return false;
  if (!x.has_value()) return x.error() == y.error();
  return false;
}

template <class T, class E, typename = decltype(
    std::declval<expected<T, E>&>().swap(std::declval<expected<T, E>&>()))>
constexpr void swap(expected<T, E>& x, expected<T, E>& y) noexcept(noexcept(x.swap(y))) {
  x.swap(y);
}

template<class E>
class unexpected {
  static_assert(std::is_object_v<E> && !std::is_array_v<E> && !std::is_const_v<E> &&
                    !std::is_volatile_v<E> && !expected_internal::is_unexpected_v<E>,
                "unexpected error type cannot be a reference, a function, an array, cv-qualified, "
                "or unexpected");

 public:
  // constructors
  constexpr unexpected(const unexpected&) = default;
  constexpr unexpected(unexpected&&) = default;

  template <class Err = E _ENABLE_IF(
                !std::is_same_v<expected_internal::remove_cvref_t<Err>, unexpected> &&
                !std::is_same_v<expected_internal::remove_cvref_t<Err>, std::in_place_t> &&
                std::is_constructible_v<E, Err>)>
  constexpr explicit unexpected(Err&& e) noexcept(std::is_nothrow_constructible_v<E, Err>)
      : val_(std::forward<Err>(e)) {}

  template <class... Args _ENABLE_IF(std::is_constructible_v<E, Args...>)>
  constexpr explicit unexpected(std::in_place_t, Args&&... args)
      noexcept(std::is_nothrow_constructible_v<E, Args...>)
      : val_(std::forward<Args>(args)...) {}

  template <class U, class... Args _ENABLE_IF(
                         std::is_constructible_v<E, std::initializer_list<U>&, Args...>)>
  constexpr explicit unexpected(std::in_place_t, std::initializer_list<U> il, Args&&... args)
      noexcept(std::is_nothrow_constructible_v<E, std::initializer_list<U>&, Args...>)
      : val_(il, std::forward<Args>(args)...) {}

  constexpr unexpected& operator=(const unexpected&) = default;
  constexpr unexpected& operator=(unexpected&&) = default;

  // observer
  constexpr const E& error() const& noexcept { return val_; }
  constexpr E& error() & noexcept { return val_; }
  constexpr const E&& error() const&& noexcept { return std::move(val_); }
  constexpr E&& error() && noexcept { return std::move(val_); }

  // Swap. This function takes a template argument so that _ENABLE_IF works.
  template <typename G = E _ENABLE_IF(std::is_same_v<G, E> && std::is_swappable_v<E>)>
  void swap(unexpected& other) noexcept(std::is_nothrow_swappable_v<E>) {
    // Make std::swap visible to provide swap for STL and builtin types, but use
    // an unqualified swap to invoke argument-dependent lookup to find the swap
    // functions for user-declared types.
    using std::swap;
    swap(val_, other.val_);
  }

  template<class E1, class E2>
  friend constexpr bool
  operator==(const unexpected<E1>& e1, const unexpected<E2>& e2);
  template<class E1, class E2>
  friend constexpr bool
  operator!=(const unexpected<E1>& e1, const unexpected<E2>& e2);

 private:
  E val_;
};

template<class E1, class E2>
constexpr bool
operator==(const unexpected<E1>& e1, const unexpected<E2>& e2) {
  return e1.error() == e2.error();
}

template<class E1, class E2>
constexpr bool
operator!=(const unexpected<E1>& e1, const unexpected<E2>& e2) {
  return e1.error() != e2.error();
}

template <class E1 _ENABLE_IF(std::is_swappable_v<E1>)>
void swap(unexpected<E1>& x, unexpected<E1>& y) noexcept(noexcept(x.swap(y))) {
  x.swap(y);
}

// TODO: bad_expected_access class

#undef _ENABLE_IF
#undef _NODISCARD_
#undef _EXPLICIT
#undef _COMMA
#undef _CONSTRUCT_EXPECTED_FROM_UNEXPECTED
#undef _ASSIGN_UNEXPECTED_TO_EXPECTED

}  // namespace base
}  // namespace android