[expected] - C++23 → Trunk

Files changed (1) hide show

tmp/tmphmycijtw/{from.md → to.md} +118 -110

tmp/tmphmycijtw/{from.md → to.md} RENAMED Viewed

@@ -1,17 +1,18 @@
 ## Expected objects <a id="expected">[[expected]]</a>
-### In general <a id="expected.general">[[expected.general]]</a>
 Subclause [[expected]] describes the class template `expected` that
 represents expected objects. An `expected<T, E>` object holds an object
-of type `T` or an object of type `unexpected<E>` and manages the
-lifetime of the contained objects.
 ### Header `<expected>` synopsis <a id="expected.syn">[[expected.syn]]</a>
 ``` cpp
 namespace std {
   // [expected.unexpected], class template unexpected
   template<class E> class unexpected;
   // [expected.bad], class template bad_expected_access
@@ -25,14 +26,14 @@ namespace std {
     explicit unexpect_t() = default;
   };
   inline constexpr unexpect_t unexpect{};
   // [expected.expected], class template expected
-  template<class T, class E> class expected;
   // [expected.void], partial specialization of expected for void types
-  template<class T, class E> requires is_void_v<T> class expected<T, E>;
 }
 ```
 ### Class template `unexpected` <a id="expected.unexpected">[[expected.unexpected]]</a>
@@ -179,16 +180,16 @@ its result is convertible to `bool`.
 ``` cpp
 namespace std {
   template<class E>
   class bad_expected_access : public bad_expected_access<void> {
   public:
-    explicit bad_expected_access(E);
-    const char* what() const noexcept override;
-    E& error() & noexcept;
-    const E& error() const & noexcept;
-    E&& error() && noexcept;
-    const E&& error() const && noexcept;
   private:
     E unex;             // exposition only
   };
 }
@@ -198,60 +199,62 @@ The class template `bad_expected_access` defines the type of objects
 thrown as exceptions to report the situation where an attempt is made to
 access the value of an `expected<T, E>` object for which `has_value()`
 is `false`.
 ``` cpp
-explicit bad_expected_access(E e);
 ```
 *Effects:* Initializes *unex* with `std::move(e)`.
 ``` cpp
-const E& error() const & noexcept;
-E& error() & noexcept;
 ```
 *Returns:* *unex*.
 ``` cpp
-E&& error() && noexcept;
-const E&& error() const && noexcept;
 ```
 *Returns:* `std::move(`*`unex`*`)`.
 ``` cpp
-const char* what() const noexcept override;
 ```
-*Returns:* An implementation-defined NTBS.
 ### Class template specialization `bad_expected_access<void>` <a id="expected.bad.void">[[expected.bad.void]]</a>
 ``` cpp
 namespace std {
   template<>
   class bad_expected_access<void> : public exception {
   protected:
-    bad_expected_access() noexcept;
-    bad_expected_access(const bad_expected_access&);
-    bad_expected_access(bad_expected_access&&);
-    bad_expected_access& operator=(const bad_expected_access&);
-    bad_expected_access& operator=(bad_expected_access&&);
-    ~bad_expected_access();
   public:
-    const char* what() const noexcept override;
   };
 }
 ```
 ``` cpp
-const char* what() const noexcept override;
 ```
-*Returns:* An implementation-defined NTBS.
 ### Class template `expected` <a id="expected.expected">[[expected.expected]]</a>
 #### General <a id="expected.object.general">[[expected.object.general]]</a>
@@ -274,11 +277,11 @@ namespace std {
     template<class U, class G>
       constexpr explicit(see below) expected(const expected<U, G>&);
     template<class U, class G>
       constexpr explicit(see below) expected(expected<U, G>&&);
-    template<class U = T>
       constexpr explicit(see below) expected(U&& v);
     template<class G>
       constexpr explicit(see below) expected(const unexpected<G>&);
     template<class G>
@@ -297,11 +300,11 @@ namespace std {
     constexpr ~expected();
     // [expected.object.assign], assignment
     constexpr expected& operator=(const expected&);
     constexpr expected& operator=(expected&&) noexcept(see below);
-    template<class U = T> constexpr expected& operator=(U&&);
     template<class G>
       constexpr expected& operator=(const unexpected<G>&);
     template<class G>
       constexpr expected& operator=(unexpected<G>&&);
@@ -321,20 +324,20 @@ namespace std {
     constexpr T& operator*() & noexcept;
     constexpr const T&& operator*() const && noexcept;
     constexpr T&& operator*() && noexcept;
     constexpr explicit operator bool() const noexcept;
     constexpr bool has_value() const noexcept;
-    constexpr const T& value() const &;
-    constexpr T& value() &;
-    constexpr const T&& value() const &&;
-    constexpr T&& value() &&;
     constexpr const E& error() const & noexcept;
     constexpr E& error() & noexcept;
     constexpr const E&& error() const && noexcept;
     constexpr E&& error() && noexcept;
-    template<class U> constexpr T value_or(U&&) const &;
-    template<class U> constexpr T value_or(U&&) &&;
     template<class G = E> constexpr E error_or(G&&) const &;
     template<class G = E> constexpr E error_or(G&&) &&;
     // [expected.object.monadic], monadic operations
     template<class F> constexpr auto and_then(F&& f) &;
@@ -371,15 +374,13 @@ namespace std {
   };
 }
 ```
 Any object of type `expected<T, E>` either contains a value of type `T`
-or a value of type `E` within its own storage. Implementations are not
-permitted to use additional storage, such as dynamic memory, to allocate
-the object of type `T` or the object of type `E`. Member *`has_val`*
-indicates whether the `expected<T, E>` object contains an object of type
-`T`.
 A type `T` is a *valid value type for `expected`*, if `remove_cv_t<T>`
 is `void` or a complete non-array object type that is not `in_place_t`,
 `unexpect_t`, or a specialization of `unexpected`. A program which
 instantiates class template `expected<T, E>` with an argument `T` that
@@ -495,18 +496,19 @@ with `std::forward<GF>(rhs.error())`.
 *Remarks:* The expression inside `explicit` is equivalent to
 `!is_convertible_v<UF, T> || !is_convertible_v<GF, E>`.
 ``` cpp
-template<class U = T>
   constexpr explicit(!is_convertible_v<U, T>) expected(U&& v);
 ```
 *Constraints:*
 - `is_same_v<remove_cvref_t<U>, in_place_t>` is `false`; and
-- `is_same_v<expected, remove_cvref_t<U>>` is `false`; and
 - `remove_cvref_t<U>` is not a specialization of `unexpected`; and
 - `is_constructible_v<T, U>` is `true`; and
 - if `T` is cv `bool`, `remove_cvref_t<U>` is not a specialization of
   `expected`.
@@ -606,11 +608,12 @@ destroys *unex*.
 `is_trivially_destructible_v<E>` is `true`, then this destructor is a
 trivial destructor.
 #### Assignment <a id="expected.object.assign">[[expected.object.assign]]</a>
-This subclause makes use of the following exposition-only function:
 ``` cpp
 template<class T, class U, class... Args>
 constexpr void reinit-expected(T& newval, U& oldval, Args&&... args) {  // exposition only
   if constexpr (is_nothrow_constructible_v<T, Args...>) {
@@ -703,11 +706,11 @@ Then, if no exception was thrown, equivalent to:
 is_nothrow_move_assignable_v<T> && is_nothrow_move_constructible_v<T> &&
 is_nothrow_move_assignable_v<E> && is_nothrow_move_constructible_v<E>
 ```
 ``` cpp
-template<class U = T>
   constexpr expected& operator=(U&& v);
 ```
 *Constraints:*
@@ -819,12 +822,12 @@ constexpr void swap(expected& rhs) noexcept(see below);
 | \topline | `this->has_value()` | `!this->has_value()` |
 | -------- | ------------------- | -------------------- |
-For the case where `rhs.value()` is `false` and `this->has_value()` is
-`true`, equivalent to:
 ``` cpp
 if constexpr (is_nothrow_move_constructible_v<E>) {
   E tmp(std::move(rhs.unex));
   destroy_at(addressof(rhs.unex));
@@ -872,29 +875,29 @@ friend constexpr void swap(expected& x, expected& y) noexcept(noexcept(x.swap(y)
 ``` cpp
 constexpr const T* operator->() const noexcept;
 constexpr T* operator->() noexcept;
 ```
-*Preconditions:* `has_value()` is `true`.
 *Returns:* `addressof(`*`val`*`)`.
 ``` cpp
 constexpr const T& operator*() const & noexcept;
 constexpr T& operator*() & noexcept;
 ```
-*Preconditions:* `has_value()` is `true`.
 *Returns:* *val*.
 ``` cpp
 constexpr T&& operator*() && noexcept;
 constexpr const T&& operator*() const && noexcept;
 ```
-*Preconditions:* `has_value()` is `true`.
 *Returns:* `std::move(`*`val`*`)`.
 ``` cpp
 constexpr explicit operator bool() const noexcept;
@@ -931,34 +934,34 @@ constexpr const T&& value() const &&;
 ``` cpp
 constexpr const E& error() const & noexcept;
 constexpr E& error() & noexcept;
 ```
-*Preconditions:* `has_value()` is `false`.
 *Returns:* *unex*.
 ``` cpp
 constexpr E&& error() && noexcept;
 constexpr const E&& error() const && noexcept;
 ```
-*Preconditions:* `has_value()` is `false`.
 *Returns:* `std::move(`*`unex`*`)`.
 ``` cpp
-template<class U> constexpr T value_or(U&& v) const &;
 ```
 *Mandates:* `is_copy_constructible_v<T>` is `true` and
 `is_convertible_v<U, T>` is `true`.
 *Returns:* `has_value() ? **this : static_cast<T>(std::forward<U>(v))`.
 ``` cpp
-template<class U> constexpr T value_or(U&& v) &&;
 ```
 *Mandates:* `is_move_constructible_v<T>` is `true` and
 `is_convertible_v<U, T>` is `true`.
@@ -990,45 +993,45 @@ template<class G = E> constexpr E error_or(G&& e) &&;
 ``` cpp
 template<class F> constexpr auto and_then(F&& f) &;
 template<class F> constexpr auto and_then(F&& f) const &;
 ```
-Let `U` be `remove_cvref_t<invoke_result_t<F, decltype(value())>>`.
 *Constraints:* `is_constructible_v<E, decltype(error())>` is `true`.
 *Mandates:* `U` is a specialization of `expected` and
-`is_same_v<U::error_type, E>` is `true`.
 *Effects:* Equivalent to:
 ``` cpp
 if (has_value())
-  return invoke(std::forward<F>(f), value());
 else
   return U(unexpect, error());
 ```
 ``` cpp
 template<class F> constexpr auto and_then(F&& f) &&;
 template<class F> constexpr auto and_then(F&& f) const &&;
 ```
 Let `U` be
-`remove_cvref_t<invoke_result_t<F, decltype(std::move(value()))>>`.
 *Constraints:* `is_constructible_v<E, decltype(std::move(error()))>` is
 `true`.
 *Mandates:* `U` is a specialization of `expected` and
-`is_same_v<U::error_type, E>` is `true`.
 *Effects:* Equivalent to:
 ``` cpp
 if (has_value())
-  return invoke(std::forward<F>(f), std::move(value()));
 else
   return U(unexpect, std::move(error()));
 ```
 ``` cpp
@@ -1036,20 +1039,20 @@ template<class F> constexpr auto or_else(F&& f) &;
 template<class F> constexpr auto or_else(F&& f) const &;
 ```
 Let `G` be `remove_cvref_t<invoke_result_t<F, decltype(error())>>`.
-*Constraints:* `is_constructible_v<T, decltype(value())>` is `true`.
 *Mandates:* `G` is a specialization of `expected` and
-`is_same_v<G::value_type, T>` is `true`.
 *Effects:* Equivalent to:
 ``` cpp
 if (has_value())
-  return G(in_place, value());
 else
   return invoke(std::forward<F>(f), error());
 ```
 ``` cpp
@@ -1058,39 +1061,39 @@ template<class F> constexpr auto or_else(F&& f) const &&;
 ```
 Let `G` be
 `remove_cvref_t<invoke_result_t<F, decltype(std::move(error()))>>`.
-*Constraints:* `is_constructible_v<T, decltype(std::move(value()))>` is
-`true`.
 *Mandates:* `G` is a specialization of `expected` and
-`is_same_v<G::value_type, T>` is `true`.
 *Effects:* Equivalent to:
 ``` cpp
 if (has_value())
-  return G(in_place, std::move(value()));
 else
   return invoke(std::forward<F>(f), std::move(error()));
 ```
 ``` cpp
 template<class F> constexpr auto transform(F&& f) &;
 template<class F> constexpr auto transform(F&& f) const &;
 ```
-Let `U` be `remove_cv_t<invoke_result_t<F, decltype(value())>>`.
 *Constraints:* `is_constructible_v<E, decltype(error())>` is `true`.
 *Mandates:* `U` is a valid value type for `expected`. If `is_void_v<U>`
 is `false`, the declaration
 ``` cpp
-U u(invoke(std::forward<F>(f), value()));
 ```
 is well-formed.
 *Effects:*
@@ -1098,53 +1101,54 @@ is well-formed.
 - If `has_value()` is `false`, returns
   `expected<U, E>(unexpect, error())`.
 - Otherwise, if `is_void_v<U>` is `false`, returns an `expected<U, E>`
   object whose *has_val* member is `true` and *val* member is
   direct-non-list-initialized with
-  `invoke(std::forward<F>(f), value())`.
-- Otherwise, evaluates `invoke(std::forward<F>(f), value())` and then
   returns `expected<U, E>()`.
 ``` cpp
 template<class F> constexpr auto transform(F&& f) &&;
 template<class F> constexpr auto transform(F&& f) const &&;
 ```
 Let `U` be
-`remove_cv_t<invoke_result_t<F, decltype(std::move(value()))>>`.
 *Constraints:* `is_constructible_v<E, decltype(std::move(error()))>` is
 `true`.
 *Mandates:* `U` is a valid value type for `expected`. If `is_void_v<U>`
 is `false`, the declaration
 ``` cpp
-U u(invoke(std::forward<F>(f), std::move(value())));
 ```
-is well-formed for some invented variable `u`.
 *Effects:*
 - If `has_value()` is `false`, returns
   `expected<U, E>(unexpect, std::move(error()))`.
 - Otherwise, if `is_void_v<U>` is `false`, returns an `expected<U, E>`
   object whose *has_val* member is `true` and *val* member is
   direct-non-list-initialized with
-  `invoke(std::forward<F>(f), std::move(value()))`.
-- Otherwise, evaluates `invoke(std::forward<F>(f), std::move(value()))`
- and then returns `expected<U, E>()`.
 ``` cpp
 template<class F> constexpr auto transform_error(F&& f) &;
 template<class F> constexpr auto transform_error(F&& f) const &;
 ```
 Let `G` be `remove_cv_t<invoke_result_t<F, decltype(error())>>`.
-*Constraints:* `is_constructible_v<T, decltype(value())>` is `true`.
 *Mandates:* `G` is a valid template argument for `unexpected`
 [[expected.un.general]] and the declaration
 ``` cpp
@@ -1152,11 +1156,11 @@ G g(invoke(std::forward<F>(f), error()));
 ```
 is well-formed.
 *Returns:* If `has_value()` is `true`,
-`expected<T, G>(in_place, value())`; otherwise, an `expected<T, G>`
 object whose *has_val* member is `false` and *unex* member is
 direct-non-list-initialized with `invoke(std::forward<F>(f), error())`.
 ``` cpp
 template<class F> constexpr auto transform_error(F&& f) &&;
@@ -1164,12 +1168,12 @@ template<class F> constexpr auto transform_error(F&& f) const &&;
 ```
 Let `G` be
 `remove_cv_t<invoke_result_t<F, decltype(std::move(error()))>>`.
-*Constraints:* `is_constructible_v<T, decltype(std::move(value()))>` is
-`true`.
 *Mandates:* `G` is a valid template argument for `unexpected`
 [[expected.un.general]] and the declaration
 ``` cpp
@@ -1177,11 +1181,11 @@ G g(invoke(std::forward<F>(f), std::move(error())));
 ```
 is well-formed.
 *Returns:* If `has_value()` is `true`,
-`expected<T, G>(in_place, std::move(value()))`; otherwise, an
 `expected<T, G>` object whose *has_val* member is `false` and *unex*
 member is direct-non-list-initialized with
 `invoke(std::forward<F>(f), std::move(error()))`.
 #### Equality operators <a id="expected.object.eq">[[expected.object.eq]]</a>
@@ -1189,34 +1193,35 @@ member is direct-non-list-initialized with
 ``` cpp
 template<class T2, class E2> requires (!is_void_v<T2>)
   friend constexpr bool operator==(const expected& x, const expected<T2, E2>& y);
 ```
-*Mandates:* The expressions `*x == *y` and `x.error() == y.error()` are
-well-formed and their results are convertible to `bool`.
 *Returns:* If `x.has_value()` does not equal `y.has_value()`, `false`;
 otherwise if `x.has_value()` is `true`, `*x == *y`; otherwise
 `x.error() == y.error()`.
 ``` cpp
 template<class T2> friend constexpr bool operator==(const expected& x, const T2& v);
 ```
-*Mandates:* The expression `*x == v` is well-formed and its result is
-convertible to `bool`.
 [*Note 1*: `T` need not be *Cpp17EqualityComparable*. — *end note*]
 *Returns:* `x.has_value() && static_cast<bool>(*x == v)`.
 ``` cpp
 template<class E2> friend constexpr bool operator==(const expected& x, const unexpected<E2>& e);
 ```
-*Mandates:* The expression `x.error() == e.error()` is well-formed and
-its result is convertible to `bool`.
 *Returns:*
 `!x.has_value() && static_cast<bool>(x.error() == e.error())`.
 ### Partial specialization of `expected` for `void` types <a id="expected.void">[[expected.void]]</a>
@@ -1273,12 +1278,12 @@ public:
   // [expected.void.obs], observers
   constexpr explicit operator bool() const noexcept;
   constexpr bool has_value() const noexcept;
   constexpr void operator*() const noexcept;
-  constexpr void value() const &;
-  constexpr void value() &&;
   constexpr const E& error() const & noexcept;
   constexpr E& error() & noexcept;
   constexpr const E&& error() const && noexcept;
   constexpr E&& error() && noexcept;
   template<class G = E> constexpr E error_or(G&&) const &;
@@ -1315,15 +1320,13 @@ private:
   };
 };
 ```
 Any object of type `expected<T, E>` either represents a value of type
-`T`, or contains a value of type `E` within its own storage.
-Implementations are not permitted to use additional storage, such as
-dynamic memory, to allocate the object of type `E`. Member *`has_val`*
-indicates whether the `expected<T, E>` object represents a value of type
-`T`.
 A program that instantiates the definition of the template
 `expected<T, E>` with a type for the `E` parameter that is not a valid
 template argument for `unexpected` is ill-formed.
@@ -1488,10 +1491,13 @@ constexpr expected& operator=(const expected& rhs);
 ``` cpp
 constexpr expected& operator=(expected&& rhs) noexcept(see below);
 ```
 *Effects:*
 - If `this->has_value() && rhs.has_value()` is `true`, no effects.
 - Otherwise, if `this->has_value()` is `true`, equivalent to:
   ``` cpp
@@ -1505,13 +1511,10 @@ constexpr expected& operator=(expected&& rhs) noexcept(see below);
 *Returns:* `*this`.
 *Remarks:* The exception specification is equivalent to
 `is_nothrow_move_constructible_v<E> && is_nothrow_move_assignable_v<E>`.
-This operator is defined as deleted unless `is_move_constructible_v<E>`
-is `true` and `is_move_assignable_v<E>` is `true`.
 ``` cpp
 template<class G>
   constexpr expected& operator=(const unexpected<G>& e);
 template<class G>
   constexpr expected& operator=(unexpected<G>&& e);
@@ -1556,12 +1559,12 @@ constexpr void swap(expected& rhs) noexcept(see below);
 | \topline | `this->has_value()` | `!this->has_value()` |
 | -------- | ------------------- | -------------------- |
-For the case where `rhs.value()` is `false` and `this->has_value()` is
-`true`, equivalent to:
 ``` cpp
 construct_at(addressof(unex), std::move(rhs.unex));
 destroy_at(addressof(rhs.unex));
 has_val = false;
@@ -1590,40 +1593,45 @@ constexpr bool has_value() const noexcept;
 ``` cpp
 constexpr void operator*() const noexcept;
 ```
-*Preconditions:* `has_value()` is `true`.
 ``` cpp
 constexpr void value() const &;
 ```
 *Throws:* `bad_expected_access(error())` if `has_value()` is `false`.
 ``` cpp
 constexpr void value() &&;
 ```
 *Throws:* `bad_expected_access(std::move(error()))` if `has_value()` is
 `false`.
 ``` cpp
 constexpr const E& error() const & noexcept;
 constexpr E& error() & noexcept;
 ```
-*Preconditions:* `has_value()` is `false`.
 *Returns:* *unex*.
 ``` cpp
 constexpr E&& error() && noexcept;
 constexpr const E&& error() const && noexcept;
 ```
-*Preconditions:* `has_value()` is `false`.
 *Returns:* `std::move(`*`unex`*`)`.
 ``` cpp
 template<class G = E> constexpr E error_or(G&& e) const &;
@@ -1655,11 +1663,11 @@ template<class F> constexpr auto and_then(F&& f) const &;
 Let `U` be `remove_cvref_t<invoke_result_t<F>>`.
 *Constraints:* `is_constructible_v<E, decltype(error())>>` is `true`.
 *Mandates:* `U` is a specialization of `expected` and
-`is_same_v<U::error_type, E>` is `true`.
 *Effects:* Equivalent to:
 ``` cpp
 if (has_value())
@@ -1677,11 +1685,11 @@ Let `U` be `remove_cvref_t<invoke_result_t<F>>`.
 *Constraints:* `is_constructible_v<E, decltype(std::move(error()))>` is
 `true`.
 *Mandates:* `U` is a specialization of `expected` and
-`is_same_v<U::error_type, E>` is `true`.
 *Effects:* Equivalent to:
 ``` cpp
 if (has_value())
@@ -1696,11 +1704,11 @@ template<class F> constexpr auto or_else(F&& f) const &;
 ```
 Let `G` be `remove_cvref_t<invoke_result_t<F, decltype(error())>>`.
 *Mandates:* `G` is a specialization of `expected` and
-`is_same_v<G::value_type, T>` is `true`.
 *Effects:* Equivalent to:
 ``` cpp
 if (has_value())
@@ -1716,11 +1724,11 @@ template<class F> constexpr auto or_else(F&& f) const &&;
 Let `G` be
 `remove_cvref_t<invoke_result_t<F, decltype(std::move(error()))>>`.
 *Mandates:* `G` is a specialization of `expected` and
-`is_same_v<G::value_type, T>` is `true`.
 *Effects:* Equivalent to:
 ``` cpp
 if (has_value())
@@ -1834,22 +1842,22 @@ member is direct-non-list-initialized with
 ``` cpp
 template<class T2, class E2> requires is_void_v<T2>
   friend constexpr bool operator==(const expected& x, const expected<T2, E2>& y);
 ```
-*Mandates:* The expression `x.error() == y.error()` is well-formed and
-its result is convertible to `bool`.
 *Returns:* If `x.has_value()` does not equal `y.has_value()`, `false`;
 otherwise `x.has_value() || static_cast<bool>(x.error() == y.error())`.
 ``` cpp
 template<class E2>
   friend constexpr bool operator==(const expected& x, const unexpected<E2>& e);
 ```
-*Mandates:* The expression `x.error() == e.error()` is well-formed and
-its result is convertible to `bool`.
 *Returns:*
 `!x.has_value() && static_cast<bool>(x.error() == e.error())`.

 ## Expected objects <a id="expected">[[expected]]</a>
+### General <a id="expected.general">[[expected.general]]</a>
 Subclause [[expected]] describes the class template `expected` that
 represents expected objects. An `expected<T, E>` object holds an object
+of type `T` or an object of type `E` and manages the lifetime of the
+contained objects.
 ### Header `<expected>` synopsis <a id="expected.syn">[[expected.syn]]</a>
 ``` cpp
+// mostly freestanding
 namespace std {
   // [expected.unexpected], class template unexpected
   template<class E> class unexpected;
   // [expected.bad], class template bad_expected_access
     explicit unexpect_t() = default;
   };
   inline constexpr unexpect_t unexpect{};
   // [expected.expected], class template expected
+  template<class T, class E> class expected;                                // partially freestanding
   // [expected.void], partial specialization of expected for void types
+  template<class T, class E> requires is_void_v<T> class expected<T, E>;    // partially freestanding
 }
 ```
 ### Class template `unexpected` <a id="expected.unexpected">[[expected.unexpected]]</a>
 ``` cpp
 namespace std {
   template<class E>
   class bad_expected_access : public bad_expected_access<void> {
   public:
+ constexpr explicit bad_expected_access(E);
+ constexpr const char* what() const noexcept override;
+ constexpr E& error() & noexcept;
+ constexpr const E& error() const & noexcept;
+ constexpr E&& error() && noexcept;
+ constexpr const E&& error() const && noexcept;
   private:
     E unex;             // exposition only
   };
 }
 thrown as exceptions to report the situation where an attempt is made to
 access the value of an `expected<T, E>` object for which `has_value()`
 is `false`.
 ``` cpp
+constexpr explicit bad_expected_access(E e);
 ```
 *Effects:* Initializes *unex* with `std::move(e)`.
 ``` cpp
+constexpr const E& error() const & noexcept;
+constexpr E& error() & noexcept;
 ```
 *Returns:* *unex*.
 ``` cpp
+constexpr E&& error() && noexcept;
+constexpr const E&& error() const && noexcept;
 ```
 *Returns:* `std::move(`*`unex`*`)`.
 ``` cpp
+constexpr const char* what() const noexcept override;
 ```
+*Returns:* An *implementation-defined* NTBS, which during constant
+evaluation is encoded with the ordinary literal encoding [[lex.ccon]].
 ### Class template specialization `bad_expected_access<void>` <a id="expected.bad.void">[[expected.bad.void]]</a>
 ``` cpp
 namespace std {
   template<>
   class bad_expected_access<void> : public exception {
   protected:
+ constexpr bad_expected_access() noexcept;
+ constexpr bad_expected_access(const bad_expected_access&) noexcept;
+ constexpr bad_expected_access(bad_expected_access&&) noexcept;
+ constexpr bad_expected_access& operator=(const bad_expected_access&) noexcept;
+ constexpr bad_expected_access& operator=(bad_expected_access&&) noexcept;
+ constexpr ~bad_expected_access();
   public:
+ constexpr const char* what() const noexcept override;
   };
 }
 ```
 ``` cpp
+constexpr const char* what() const noexcept override;
 ```
+*Returns:* An *implementation-defined* NTBS, which during constant
+evaluation is encoded with the ordinary literal encoding [[lex.ccon]].
 ### Class template `expected` <a id="expected.expected">[[expected.expected]]</a>
 #### General <a id="expected.object.general">[[expected.object.general]]</a>
     template<class U, class G>
       constexpr explicit(see below) expected(const expected<U, G>&);
     template<class U, class G>
       constexpr explicit(see below) expected(expected<U, G>&&);
+    template<class U = remove_cv_t<T>>
       constexpr explicit(see below) expected(U&& v);
     template<class G>
       constexpr explicit(see below) expected(const unexpected<G>&);
     template<class G>
     constexpr ~expected();
     // [expected.object.assign], assignment
     constexpr expected& operator=(const expected&);
     constexpr expected& operator=(expected&&) noexcept(see below);
+    template<class U = remove_cv_t<T>> constexpr expected& operator=(U&&);
     template<class G>
       constexpr expected& operator=(const unexpected<G>&);
     template<class G>
       constexpr expected& operator=(unexpected<G>&&);
     constexpr T& operator*() & noexcept;
     constexpr const T&& operator*() const && noexcept;
     constexpr T&& operator*() && noexcept;
     constexpr explicit operator bool() const noexcept;
     constexpr bool has_value() const noexcept;
+    constexpr const T& value() const &;                                     // freestanding-deleted
+    constexpr T& value() &;                                                 // freestanding-deleted
+    constexpr const T&& value() const &&;                                   // freestanding-deleted
+    constexpr T&& value() &&;                                               // freestanding-deleted
     constexpr const E& error() const & noexcept;
     constexpr E& error() & noexcept;
     constexpr const E&& error() const && noexcept;
     constexpr E&& error() && noexcept;
+    template<class U = remove_cv_t<T>> constexpr T value_or(U&&) const &;
+    template<class U = remove_cv_t<T>> constexpr T value_or(U&&) &&;
     template<class G = E> constexpr E error_or(G&&) const &;
     template<class G = E> constexpr E error_or(G&&) &&;
     // [expected.object.monadic], monadic operations
     template<class F> constexpr auto and_then(F&& f) &;
   };
 }
 ```
 Any object of type `expected<T, E>` either contains a value of type `T`
+or a value of type `E` nested within [[intro.object]] it. Member
+*`has_val`* indicates whether the `expected<T, E>` object contains an
+object of type `T`.
 A type `T` is a *valid value type for `expected`*, if `remove_cv_t<T>`
 is `void` or a complete non-array object type that is not `in_place_t`,
 `unexpect_t`, or a specialization of `unexpected`. A program which
 instantiates class template `expected<T, E>` with an argument `T` that
 *Remarks:* The expression inside `explicit` is equivalent to
 `!is_convertible_v<UF, T> || !is_convertible_v<GF, E>`.
 ``` cpp
+template<class U = remove_cv_t<T>>
   constexpr explicit(!is_convertible_v<U, T>) expected(U&& v);
 ```
 *Constraints:*
 - `is_same_v<remove_cvref_t<U>, in_place_t>` is `false`; and
+- `is_same_v<remove_cvref_t<U>, expected>` is `false`; and
+- `is_same_v<remove_cvref_t<U>, unexpect_t>` is `false`; and
 - `remove_cvref_t<U>` is not a specialization of `unexpected`; and
 - `is_constructible_v<T, U>` is `true`; and
 - if `T` is cv `bool`, `remove_cvref_t<U>` is not a specialization of
   `expected`.
 `is_trivially_destructible_v<E>` is `true`, then this destructor is a
 trivial destructor.
 #### Assignment <a id="expected.object.assign">[[expected.object.assign]]</a>
+This subclause makes use of the following exposition-only function
+template:
 ``` cpp
 template<class T, class U, class... Args>
 constexpr void reinit-expected(T& newval, U& oldval, Args&&... args) {  // exposition only
   if constexpr (is_nothrow_constructible_v<T, Args...>) {
 is_nothrow_move_assignable_v<T> && is_nothrow_move_constructible_v<T> &&
 is_nothrow_move_assignable_v<E> && is_nothrow_move_constructible_v<E>
 ```
 ``` cpp
+template<class U = remove_cv_t<T>>
   constexpr expected& operator=(U&& v);
 ```
 *Constraints:*
 | \topline | `this->has_value()` | `!this->has_value()` |
 | -------- | ------------------- | -------------------- |
+For the case where `rhs.has_value()` is `false` and `this->has_value()`
+is `true`, equivalent to:
 ``` cpp
 if constexpr (is_nothrow_move_constructible_v<E>) {
   E tmp(std::move(rhs.unex));
   destroy_at(addressof(rhs.unex));
 ``` cpp
 constexpr const T* operator->() const noexcept;
 constexpr T* operator->() noexcept;
 ```
+`has_value()` is `true`.
 *Returns:* `addressof(`*`val`*`)`.
 ``` cpp
 constexpr const T& operator*() const & noexcept;
 constexpr T& operator*() & noexcept;
 ```
+`has_value()` is `true`.
 *Returns:* *val*.
 ``` cpp
 constexpr T&& operator*() && noexcept;
 constexpr const T&& operator*() const && noexcept;
 ```
+`has_value()` is `true`.
 *Returns:* `std::move(`*`val`*`)`.
 ``` cpp
 constexpr explicit operator bool() const noexcept;
 ``` cpp
 constexpr const E& error() const & noexcept;
 constexpr E& error() & noexcept;
 ```
+`has_value()` is `false`.
 *Returns:* *unex*.
 ``` cpp
 constexpr E&& error() && noexcept;
 constexpr const E&& error() const && noexcept;
 ```
+`has_value()` is `false`.
 *Returns:* `std::move(`*`unex`*`)`.
 ``` cpp
+template<class U = remove_cv_t<T>> constexpr T value_or(U&& v) const &;
 ```
 *Mandates:* `is_copy_constructible_v<T>` is `true` and
 `is_convertible_v<U, T>` is `true`.
 *Returns:* `has_value() ? **this : static_cast<T>(std::forward<U>(v))`.
 ``` cpp
+template<class U = remove_cv_t<T>> constexpr T value_or(U&& v) &&;
 ```
 *Mandates:* `is_move_constructible_v<T>` is `true` and
 `is_convertible_v<U, T>` is `true`.
 ``` cpp
 template<class F> constexpr auto and_then(F&& f) &;
 template<class F> constexpr auto and_then(F&& f) const &;
 ```
+Let `U` be `remove_cvref_t<invoke_result_t<F, decltype((`*`val`*`))>>`.
 *Constraints:* `is_constructible_v<E, decltype(error())>` is `true`.
 *Mandates:* `U` is a specialization of `expected` and
+`is_same_v<typename U::error_type, E>` is `true`.
 *Effects:* Equivalent to:
 ``` cpp
 if (has_value())
+  return invoke(std::forward<F>(f), val);
 else
   return U(unexpect, error());
 ```
 ``` cpp
 template<class F> constexpr auto and_then(F&& f) &&;
 template<class F> constexpr auto and_then(F&& f) const &&;
 ```
 Let `U` be
+`remove_cvref_t<invoke_result_t<F, decltype(std::move(`*`val`*`))>>`.
 *Constraints:* `is_constructible_v<E, decltype(std::move(error()))>` is
 `true`.
 *Mandates:* `U` is a specialization of `expected` and
+`is_same_v<typename U::error_type, E>` is `true`.
 *Effects:* Equivalent to:
 ``` cpp
 if (has_value())
+  return invoke(std::forward<F>(f), std::move(val));
 else
   return U(unexpect, std::move(error()));
 ```
 ``` cpp
 template<class F> constexpr auto or_else(F&& f) const &;
 ```
 Let `G` be `remove_cvref_t<invoke_result_t<F, decltype(error())>>`.
+*Constraints:* `is_constructible_v<T, decltype((`*`val`*`))>` is `true`.
 *Mandates:* `G` is a specialization of `expected` and
+`is_same_v<typename G::value_type, T>` is `true`.
 *Effects:* Equivalent to:
 ``` cpp
 if (has_value())
+  return G(in_place, val);
 else
   return invoke(std::forward<F>(f), error());
 ```
 ``` cpp
 ```
 Let `G` be
 `remove_cvref_t<invoke_result_t<F, decltype(std::move(error()))>>`.
+*Constraints:* `is_constructible_v<T, decltype(std::move(`*`val`*`))>`
+is `true`.
 *Mandates:* `G` is a specialization of `expected` and
+`is_same_v<typename G::value_type, T>` is `true`.
 *Effects:* Equivalent to:
 ``` cpp
 if (has_value())
+  return G(in_place, std::move(val));
 else
   return invoke(std::forward<F>(f), std::move(error()));
 ```
 ``` cpp
 template<class F> constexpr auto transform(F&& f) &;
 template<class F> constexpr auto transform(F&& f) const &;
 ```
+Let `U` be `remove_cv_t<invoke_result_t<F, decltype((`*`val`*`))>>`.
 *Constraints:* `is_constructible_v<E, decltype(error())>` is `true`.
 *Mandates:* `U` is a valid value type for `expected`. If `is_void_v<U>`
 is `false`, the declaration
 ``` cpp
+U u(invoke(std::forward<F>(f), val));
 ```
 is well-formed.
 *Effects:*
 - If `has_value()` is `false`, returns
   `expected<U, E>(unexpect, error())`.
 - Otherwise, if `is_void_v<U>` is `false`, returns an `expected<U, E>`
   object whose *has_val* member is `true` and *val* member is
   direct-non-list-initialized with
+  `invoke(std::forward<F>(f), `*`val`*`)`.
+- Otherwise, evaluates `invoke(std::forward<F>(f), `*`val`*`)` and then
   returns `expected<U, E>()`.
 ``` cpp
 template<class F> constexpr auto transform(F&& f) &&;
 template<class F> constexpr auto transform(F&& f) const &&;
 ```
 Let `U` be
+`remove_cv_t<invoke_result_t<F, decltype(std::move(`*`val`*`))>>`.
 *Constraints:* `is_constructible_v<E, decltype(std::move(error()))>` is
 `true`.
 *Mandates:* `U` is a valid value type for `expected`. If `is_void_v<U>`
 is `false`, the declaration
 ``` cpp
+U u(invoke(std::forward<F>(f), std::move(val)));
 ```
+is well-formed.
 *Effects:*
 - If `has_value()` is `false`, returns
   `expected<U, E>(unexpect, std::move(error()))`.
 - Otherwise, if `is_void_v<U>` is `false`, returns an `expected<U, E>`
   object whose *has_val* member is `true` and *val* member is
   direct-non-list-initialized with
+  `invoke(std::forward<F>(f), std::move(`*`val`*`))`.
+- Otherwise, evaluates
+  `invoke(std::forward<F>(f), std::move(`*`val`*`))` and then returns
+  `expected<U, E>()`.
 ``` cpp
 template<class F> constexpr auto transform_error(F&& f) &;
 template<class F> constexpr auto transform_error(F&& f) const &;
 ```
 Let `G` be `remove_cv_t<invoke_result_t<F, decltype(error())>>`.
+*Constraints:* `is_constructible_v<T, decltype((`*`val`*`))>` is `true`.
 *Mandates:* `G` is a valid template argument for `unexpected`
 [[expected.un.general]] and the declaration
 ``` cpp
 ```
 is well-formed.
 *Returns:* If `has_value()` is `true`,
+`expected<T, G>(in_place, `*`val`*`)`; otherwise, an `expected<T, G>`
 object whose *has_val* member is `false` and *unex* member is
 direct-non-list-initialized with `invoke(std::forward<F>(f), error())`.
 ``` cpp
 template<class F> constexpr auto transform_error(F&& f) &&;
 ```
 Let `G` be
 `remove_cv_t<invoke_result_t<F, decltype(std::move(error()))>>`.
+*Constraints:* `is_constructible_v<T, decltype(std::move(`*`val`*`))>`
+is `true`.
 *Mandates:* `G` is a valid template argument for `unexpected`
 [[expected.un.general]] and the declaration
 ``` cpp
 ```
 is well-formed.
 *Returns:* If `has_value()` is `true`,
+`expected<T, G>(in_place, std::move(`*`val`*`))`; otherwise, an
 `expected<T, G>` object whose *has_val* member is `false` and *unex*
 member is direct-non-list-initialized with
 `invoke(std::forward<F>(f), std::move(error()))`.
 #### Equality operators <a id="expected.object.eq">[[expected.object.eq]]</a>
 ``` cpp
 template<class T2, class E2> requires (!is_void_v<T2>)
   friend constexpr bool operator==(const expected& x, const expected<T2, E2>& y);
 ```
+*Constraints:* The expressions `*x == *y` and `x.error() == y.error()`
+are well-formed and their results are convertible to `bool`.
 *Returns:* If `x.has_value()` does not equal `y.has_value()`, `false`;
 otherwise if `x.has_value()` is `true`, `*x == *y`; otherwise
 `x.error() == y.error()`.
 ``` cpp
 template<class T2> friend constexpr bool operator==(const expected& x, const T2& v);
 ```
+*Constraints:* `T2` is not a specialization of `expected`. The
+expression `*x == v` is well-formed and its result is convertible to
+`bool`.
 [*Note 1*: `T` need not be *Cpp17EqualityComparable*. — *end note*]
 *Returns:* `x.has_value() && static_cast<bool>(*x == v)`.
 ``` cpp
 template<class E2> friend constexpr bool operator==(const expected& x, const unexpected<E2>& e);
 ```
+*Constraints:* The expression `x.error() == e.error()` is well-formed
+and its result is convertible to `bool`.
 *Returns:*
 `!x.has_value() && static_cast<bool>(x.error() == e.error())`.
 ### Partial specialization of `expected` for `void` types <a id="expected.void">[[expected.void]]</a>
   // [expected.void.obs], observers
   constexpr explicit operator bool() const noexcept;
   constexpr bool has_value() const noexcept;
   constexpr void operator*() const noexcept;
+  constexpr void value() const &;                                           // freestanding-deleted
+  constexpr void value() &&;                                                // freestanding-deleted
   constexpr const E& error() const & noexcept;
   constexpr E& error() & noexcept;
   constexpr const E&& error() const && noexcept;
   constexpr E&& error() && noexcept;
   template<class G = E> constexpr E error_or(G&&) const &;
   };
 };
 ```
 Any object of type `expected<T, E>` either represents a value of type
+`T`, or contains a value of type `E` nested within [[intro.object]] it.
+Member *`has_val`* indicates whether the `expected<T, E>` object
+represents a value of type `T`.
 A program that instantiates the definition of the template
 `expected<T, E>` with a type for the `E` parameter that is not a valid
 template argument for `unexpected` is ill-formed.
 ``` cpp
 constexpr expected& operator=(expected&& rhs) noexcept(see below);
 ```
+*Constraints:* `is_move_constructible_v<E>` is `true` and
+`is_move_assignable_v<E>` is `true`.
 *Effects:*
 - If `this->has_value() && rhs.has_value()` is `true`, no effects.
 - Otherwise, if `this->has_value()` is `true`, equivalent to:
   ``` cpp
 *Returns:* `*this`.
 *Remarks:* The exception specification is equivalent to
 `is_nothrow_move_constructible_v<E> && is_nothrow_move_assignable_v<E>`.
 ``` cpp
 template<class G>
   constexpr expected& operator=(const unexpected<G>& e);
 template<class G>
   constexpr expected& operator=(unexpected<G>&& e);
 | \topline | `this->has_value()` | `!this->has_value()` |
 | -------- | ------------------- | -------------------- |
+For the case where `rhs.has_value()` is `false` and `this->has_value()`
+is `true`, equivalent to:
 ``` cpp
 construct_at(addressof(unex), std::move(rhs.unex));
 destroy_at(addressof(rhs.unex));
 has_val = false;
 ``` cpp
 constexpr void operator*() const noexcept;
 ```
+`has_value()` is `true`.
 ``` cpp
 constexpr void value() const &;
 ```
+*Mandates:* `is_copy_constructible_v<E>` is `true`.
 *Throws:* `bad_expected_access(error())` if `has_value()` is `false`.
 ``` cpp
 constexpr void value() &&;
 ```
+*Mandates:* `is_copy_constructible_v<E>` is `true` and
+`is_move_constructible_v<E>` is `true`.
 *Throws:* `bad_expected_access(std::move(error()))` if `has_value()` is
 `false`.
 ``` cpp
 constexpr const E& error() const & noexcept;
 constexpr E& error() & noexcept;
 ```
+`has_value()` is `false`.
 *Returns:* *unex*.
 ``` cpp
 constexpr E&& error() && noexcept;
 constexpr const E&& error() const && noexcept;
 ```
+`has_value()` is `false`.
 *Returns:* `std::move(`*`unex`*`)`.
 ``` cpp
 template<class G = E> constexpr E error_or(G&& e) const &;
 Let `U` be `remove_cvref_t<invoke_result_t<F>>`.
 *Constraints:* `is_constructible_v<E, decltype(error())>>` is `true`.
 *Mandates:* `U` is a specialization of `expected` and
+`is_same_v<typename U::error_type, E>` is `true`.
 *Effects:* Equivalent to:
 ``` cpp
 if (has_value())
 *Constraints:* `is_constructible_v<E, decltype(std::move(error()))>` is
 `true`.
 *Mandates:* `U` is a specialization of `expected` and
+`is_same_v<typename U::error_type, E>` is `true`.
 *Effects:* Equivalent to:
 ``` cpp
 if (has_value())
 ```
 Let `G` be `remove_cvref_t<invoke_result_t<F, decltype(error())>>`.
 *Mandates:* `G` is a specialization of `expected` and
+`is_same_v<typename G::value_type, T>` is `true`.
 *Effects:* Equivalent to:
 ``` cpp
 if (has_value())
 Let `G` be
 `remove_cvref_t<invoke_result_t<F, decltype(std::move(error()))>>`.
 *Mandates:* `G` is a specialization of `expected` and
+`is_same_v<typename G::value_type, T>` is `true`.
 *Effects:* Equivalent to:
 ``` cpp
 if (has_value())
 ``` cpp
 template<class T2, class E2> requires is_void_v<T2>
   friend constexpr bool operator==(const expected& x, const expected<T2, E2>& y);
 ```
+*Constraints:* The expression `x.error() == y.error()` is well-formed
+and its result is convertible to `bool`.
 *Returns:* If `x.has_value()` does not equal `y.has_value()`, `false`;
 otherwise `x.has_value() || static_cast<bool>(x.error() == y.error())`.
 ``` cpp
 template<class E2>
   friend constexpr bool operator==(const expected& x, const unexpected<E2>& e);
 ```
+*Constraints:* The expression `x.error() == e.error()` is well-formed
+and its result is convertible to `bool`.
 *Returns:*
 `!x.has_value() && static_cast<bool>(x.error() == e.error())`.

Diff to HTML by rtfpessoa