[optional] - C++20 → C++23

Files changed (1) hide show

tmp/tmpidzua3wb/{from.md → to.md} +316 -187

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

@@ -18,10 +18,15 @@ contained object is tracked by the optional object.
 namespace std {
   // [optional.optional], class template optional
   template<class T>
     class optional;
   // [optional.nullopt], no-value state indicator
   struct nullopt_t{see below};
   inline constexpr nullopt_t nullopt(unspecified);
   // [optional.bad.access], class bad_optional_access
@@ -60,17 +65,18 @@ namespace std {
   template<class T, class U> constexpr bool operator>(const T&, const optional<U>&);
   template<class T, class U> constexpr bool operator<=(const optional<T>&, const U&);
   template<class T, class U> constexpr bool operator<=(const T&, const optional<U>&);
   template<class T, class U> constexpr bool operator>=(const optional<T>&, const U&);
   template<class T, class U> constexpr bool operator>=(const T&, const optional<U>&);
-  template<class T, three_way_comparable_with<T> U>
     constexpr compare_three_way_result_t<T, U>
       operator<=>(const optional<T>&, const U&);
   // [optional.specalg], specialized algorithms
   template<class T>
-    void swap(optional<T>&, optional<T>&) noexcept(see below);
   template<class T>
     constexpr optional<see below> make_optional(T&&);
   template<class T, class... Args>
     constexpr optional<T> make_optional(Args&&... args);
@@ -83,10 +89,12 @@ namespace std {
 }
 ```
 ### Class template `optional` <a id="optional.optional">[[optional.optional]]</a>
 ``` cpp
 namespace std {
   template<class T>
   class optional {
   public:
@@ -102,48 +110,60 @@ namespace std {
     template<class U, class... Args>
       constexpr explicit optional(in_place_t, initializer_list<U>, Args&&...);
     template<class U = T>
       constexpr explicit(see below) optional(U&&);
     template<class U>
-      explicit(see below) optional(const optional<U>&);
     template<class U>
-      explicit(see below) optional(optional<U>&&);
     // [optional.dtor], destructor
-    ~optional();
     // [optional.assign], assignment
-    optional& operator=(nullopt_t) noexcept;
     constexpr optional& operator=(const optional&);
     constexpr optional& operator=(optional&&) noexcept(see below);
-    template<class U = T> optional& operator=(U&&);
-    template<class U> optional& operator=(const optional<U>&);
-    template<class U> optional& operator=(optional<U>&&);
-    template<class... Args> T& emplace(Args&&...);
-    template<class U, class... Args> T& emplace(initializer_list<U>, Args&&...);
     // [optional.swap], swap
-    void swap(optional&) noexcept(see below);
     // [optional.observe], observers
-    constexpr const T* operator->() const;
-    constexpr T* operator->();
-    constexpr const T& operator*() const&;
-    constexpr T& operator*() &;
-    constexpr T&& operator*() &&;
-    constexpr const T&& operator*() const&&;
     constexpr explicit operator bool() const noexcept;
     constexpr bool has_value() const noexcept;
     constexpr const T& value() const &;
     constexpr T& value() &;
     constexpr T&& value() &&;
     constexpr const T&& value() const &&;
     template<class U> constexpr T value_or(U&&) const &;
     template<class U> constexpr T value_or(U&&) &&;
     // [optional.mod], modifiers
-    void reset() noexcept;
   private:
     T *val;         // exposition only
   };
@@ -155,25 +175,35 @@ namespace std {
 Any instance of `optional<T>` at any given time either contains a value
 or does not contain a value. When an instance of `optional<T>` *contains
 a value*, it means that an object of type `T`, referred to as the
 optional object’s *contained value*, is allocated within the storage of
 the optional object. Implementations are not permitted to use additional
-storage, such as dynamic memory, to allocate its contained value. The
-contained value shall be allocated in a region of the `optional<T>`
-storage suitably aligned for the type `T`. When an object of type
-`optional<T>` is contextually converted to `bool`, the conversion
-returns `true` if the object contains a value; otherwise the conversion
-returns `false`.
-Member `val` is provided for exposition only. When an `optional<T>`
-object contains a value, `val` points to the contained value.
 `T` shall be a type other than cv `in_place_t` or cv `nullopt_t` that
 meets the *Cpp17Destructible* requirements ([[cpp17.destructible]]).
 #### Constructors <a id="optional.ctor">[[optional.ctor]]</a>
 ``` cpp
 constexpr optional() noexcept;
 constexpr optional(nullopt_t) noexcept;
 ```
@@ -184,15 +214,14 @@ these constructors are constexpr constructors [[dcl.constexpr]].
 ``` cpp
 constexpr optional(const optional& rhs);
 ```
-*Effects:* If `rhs` contains a value, initializes the contained value as
-if direct-non-list-initializing an object of type `T` with the
-expression `*rhs`.
-*Ensures:* `bool(rhs) == bool(*this)`.
 *Throws:* Any exception thrown by the selected constructor of `T`.
 *Remarks:* This constructor is defined as deleted unless
 `is_copy_constructible_v<T>` is `true`. If
@@ -203,31 +232,29 @@ trivial.
 constexpr optional(optional&& rhs) noexcept(see below);
 ```
 *Constraints:* `is_move_constructible_v<T>` is `true`.
-*Effects:* If `rhs` contains a value, initializes the contained value as
-if direct-non-list-initializing an object of type `T` with the
-expression `std::move(*rhs)`. `bool(rhs)` is unchanged.
-*Ensures:* `bool(rhs) == bool(*this)`.
 *Throws:* Any exception thrown by the selected constructor of `T`.
-*Remarks:* The expression inside `noexcept` is equivalent to
 `is_nothrow_move_constructible_v<T>`. If
 `is_trivially_move_constructible_v<T>` is `true`, this constructor is
 trivial.
 ``` cpp
 template<class... Args> constexpr explicit optional(in_place_t, Args&&... args);
 ```
 *Constraints:* `is_constructible_v<T, Args...>` is `true`.
-*Effects:* Initializes the contained value as if
-direct-non-list-initializing an object of type `T` with the arguments
 `std::forward<Args>(args)...`.
 *Ensures:* `*this` contains a value.
 *Throws:* Any exception thrown by the selected constructor of `T`.
@@ -241,12 +268,11 @@ template<class U, class... Args>
 ```
 *Constraints:* `is_constructible_v<T, initializer_list<U>&, Args...>` is
 `true`.
-*Effects:* Initializes the contained value as if
-direct-non-list-initializing an object of type `T` with the arguments
 `il, std::forward<Args>(args)...`.
 *Ensures:* `*this` contains a value.
 *Throws:* Any exception thrown by the selected constructor of `T`.
@@ -256,16 +282,19 @@ constexpr constructor, this constructor is a constexpr constructor.
 ``` cpp
 template<class U = T> constexpr explicit(see below) optional(U&& v);
 ```
-*Constraints:* `is_constructible_v<T, U>` is `true`,
-`is_same_v<remove_cvref_t<U>, in_place_t>` is `false`, and
-`is_same_v<remove_cvref_t<U>, optional>` is `false`.
-*Effects:* Initializes the contained value as if
-direct-non-list-initializing an object of type `T` with the expression
 `std::forward<U>(v)`.
 *Ensures:* `*this` contains a value.
 *Throws:* Any exception thrown by the selected constructor of `T`.
@@ -277,60 +306,46 @@ this constructor is a constexpr constructor. The expression inside
 ``` cpp
 !is_convertible_v<U, T>
 ```
 ``` cpp
-template<class U> explicit(see below) optional(const optional<U>& rhs);
 ```
 *Constraints:*
-- `is_constructible_v<T, const U&>` is `true`,
-- `is_constructible_v<T, optional<U>&>` is `false`,
-- `is_constructible_v<T, optional<U>&&>` is `false`,
-- `is_constructible_v<T, const optional<U>&>` is `false`,
-- `is_constructible_v<T, const optional<U>&&>` is `false`,
-- `is_convertible_v<optional<U>&, T>` is `false`,
-- `is_convertible_v<optional<U>&&, T>` is `false`,
-- `is_convertible_v<const optional<U>&, T>` is `false`, and
-- `is_convertible_v<const optional<U>&&, T>` is `false`.
-*Effects:* If `rhs` contains a value, initializes the contained value as
-if direct-non-list-initializing an object of type `T` with the
-expression `*rhs`.
-*Ensures:* `bool(rhs)` == `bool(*this)`.
 *Throws:* Any exception thrown by the selected constructor of `T`.
 *Remarks:* The expression inside `explicit` is equivalent to:
 ``` cpp
 !is_convertible_v<const U&, T>
 ```
 ``` cpp
-template<class U> explicit(see below) optional(optional<U>&& rhs);
 ```
 *Constraints:*
-- `is_constructible_v<T, U>` is true,
-- `is_constructible_v<T, optional<U>&>` is `false`,
-- `is_constructible_v<T, optional<U>&&>` is `false`,
-- `is_constructible_v<T, const optional<U>&>` is `false`,
-- `is_constructible_v<T, const optional<U>&&>` is `false`,
-- `is_convertible_v<optional<U>&, T>` is `false`,
-- `is_convertible_v<optional<U>&&, T>` is `false`,
-- `is_convertible_v<const optional<U>&, T>` is `false`, and
-- `is_convertible_v<const optional<U>&&, T>` is `false`.
-*Effects:* If `rhs` contains a value, initializes the contained value as
-if direct-non-list-initializing an object of type `T` with the
-expression `std::move(*rhs)`. `bool(rhs)` is unchanged.
-*Ensures:* `bool(rhs)` == `bool(*this)`.
 *Throws:* Any exception thrown by the selected constructor of `T`.
 *Remarks:* The expression inside `explicit` is equivalent to:
@@ -339,11 +354,11 @@ expression `std::move(*rhs)`. `bool(rhs)` is unchanged.
 ```
 #### Destructor <a id="optional.dtor">[[optional.dtor]]</a>
 ``` cpp
-~optional();
 ```
 *Effects:* If `is_trivially_destructible_v<T> != true` and `*this`
 contains a value, calls
@@ -355,11 +370,11 @@ val->T::~T()
 destructor is trivial.
 #### Assignment <a id="optional.assign">[[optional.assign]]</a>
 ``` cpp
-optional<T>& operator=(nullopt_t) noexcept;
 ```
 *Effects:* If `*this` contains a value, calls `val->T::T̃()` to destroy
 the contained value; otherwise no effect.
@@ -374,22 +389,22 @@ constexpr optional<T>& operator=(const optional& rhs);
 *Effects:* See [[optional.assign.copy]].
 **Table: `optional::operator=(const optional&)` effects** <a id="optional.assign.copy">[optional.assign.copy]</a>
 |                                | `*this` contains a value                               | `*this` does not contain a value                            |
-| ------------------------------ | ------------------------------------------------------ | ---------------------------------------------------------------------------------------------------- |
-| `rhs` contains a value         | assigns `*rhs` to the contained value                  | initializes the contained value as if direct-non-list-initializing an object of type `T` with `*rhs` |
 | `rhs` does not contain a value | destroys the contained value by calling `val->T::~T()` | no effect                                                   |
-*Ensures:* `bool(rhs) == bool(*this)`.
 *Returns:* `*this`.
 *Remarks:* If any exception is thrown, the result of the expression
-`bool(*this)` remains unchanged. If an exception is thrown during the
-call to `T`’s copy constructor, no effect. If an exception is thrown
 during the call to `T`’s copy assignment, the state of its contained
 value is as defined by the exception safety guarantee of `T`’s copy
 assignment. This operator is defined as deleted unless
 `is_copy_constructible_v<T>` is `true` and `is_copy_assignable_v<T>` is
 `true`. If `is_trivially_copy_constructible_v<T> &&`
@@ -402,161 +417,146 @@ constexpr optional& operator=(optional&& rhs) noexcept(see below);
 *Constraints:* `is_move_constructible_v<T>` is `true` and
 `is_move_assignable_v<T>` is `true`.
 *Effects:* See [[optional.assign.move]]. The result of the expression
-`bool(rhs)` remains unchanged.
 **Table: `optional::operator=(optional&&)` effects** <a id="optional.assign.move">[optional.assign.move]</a>
 |                                | `*this` contains a value                               | `*this` does not contain a value                                       |
-| ------------------------------ | ------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------- |
-| `rhs` contains a value         | assigns `std::move(*rhs)` to the contained value       | initializes the contained value as if direct-non-list-initializing an object of type `T` with `std::move(*rhs)` |
 | `rhs` does not contain a value | destroys the contained value by calling `val->T::~T()` | no effect                                                              |
-*Ensures:* `bool(rhs) == bool(*this)`.
 *Returns:* `*this`.
-*Remarks:* The expression inside `noexcept` is equivalent to:
 ``` cpp
 is_nothrow_move_assignable_v<T> && is_nothrow_move_constructible_v<T>
 ```
-If any exception is thrown, the result of the expression `bool(*this)`
-remains unchanged. If an exception is thrown during the call to `T`’s
-move constructor, the state of `*rhs.val` is determined by the exception
-safety guarantee of `T`’s move constructor. If an exception is thrown
-during the call to `T`’s move assignment, the state of `*val` and
-`*rhs.val` is determined by the exception safety guarantee of `T`’s move
-assignment. If `is_trivially_move_constructible_v<T> &&`
 `is_trivially_move_assignable_v<T> &&` `is_trivially_destructible_v<T>`
 is `true`, this assignment operator is trivial.
 ``` cpp
-template<class U = T> optional<T>& operator=(U&& v);
 ```
 *Constraints:* `is_same_v<remove_cvref_t<U>, optional>` is `false`,
 `conjunction_v<is_scalar<T>, is_same<T, decay_t<U>>>` is `false`,
 `is_constructible_v<T, U>` is `true`, and `is_assignable_v<T&, U>` is
 `true`.
 *Effects:* If `*this` contains a value, assigns `std::forward<U>(v)` to
-the contained value; otherwise initializes the contained value as if
-direct-non-list-initializing object of type `T` with
-`std::forward<U>(v)`.
 *Ensures:* `*this` contains a value.
 *Returns:* `*this`.
 *Remarks:* If any exception is thrown, the result of the expression
-`bool(*this)` remains unchanged. If an exception is thrown during the
-call to `T`’s constructor, the state of `v` is determined by the
 exception safety guarantee of `T`’s constructor. If an exception is
 thrown during the call to `T`’s assignment, the state of `*val` and `v`
 is determined by the exception safety guarantee of `T`’s assignment.
 ``` cpp
-template<class U> optional<T>& operator=(const optional<U>& rhs);
 ```
 *Constraints:*
 - `is_constructible_v<T, const U&>` is `true`,
 - `is_assignable_v<T&, const U&>` is `true`,
-- `is_constructible_v<T, optional<U>&>` is `false`,
-- `is_constructible_v<T, optional<U>&&>` is `false`,
-- `is_constructible_v<T, const optional<U>&>` is `false`,
-- `is_constructible_v<T, const optional<U>&&>` is `false`,
-- `is_convertible_v<optional<U>&, T>` is `false`,
-- `is_convertible_v<optional<U>&&, T>` is `false`,
-- `is_convertible_v<const optional<U>&, T>` is `false`,
-- `is_convertible_v<const optional<U>&&, T>` is `false`,
 - `is_assignable_v<T&, optional<U>&>` is `false`,
 - `is_assignable_v<T&, optional<U>&&>` is `false`,
 - `is_assignable_v<T&, const optional<U>&>` is `false`, and
 - `is_assignable_v<T&, const optional<U>&&>` is `false`.
 *Effects:* See [[optional.assign.copy.templ]].
 **Table: `optional::operator=(const optional<U>&)` effects** <a id="optional.assign.copy.templ">[optional.assign.copy.templ]</a>
 |                                | `*this` contains a value                               | `*this` does not contain a value                            |
-| ------------------------------ | ------------------------------------------------------ | ---------------------------------------------------------------------------------------------------- |
-| `rhs` contains a value         | assigns `*rhs` to the contained value                  | initializes the contained value as if direct-non-list-initializing an object of type `T` with `*rhs` |
 | `rhs` does not contain a value | destroys the contained value by calling `val->T::~T()` | no effect                                                   |
-*Ensures:* `bool(rhs) == bool(*this)`.
 *Returns:* `*this`.
 *Remarks:* If any exception is thrown, the result of the expression
-`bool(*this)` remains unchanged. If an exception is thrown during the
-call to `T`’s constructor, the state of `*rhs.val` is determined by the
-exception safety guarantee of `T`’s constructor. If an exception is
 thrown during the call to `T`’s assignment, the state of `*val` and
 `*rhs.val` is determined by the exception safety guarantee of `T`’s
 assignment.
 ``` cpp
-template<class U> optional<T>& operator=(optional<U>&& rhs);
 ```
 *Constraints:*
 - `is_constructible_v<T, U>` is `true`,
 - `is_assignable_v<T&, U>` is `true`,
-- `is_constructible_v<T, optional<U>&>` is `false`,
-- `is_constructible_v<T, optional<U>&&>` is `false`,
-- `is_constructible_v<T, const optional<U>&>` is `false`,
-- `is_constructible_v<T, const optional<U>&&>` is `false`,
-- `is_convertible_v<optional<U>&, T>` is `false`,
-- `is_convertible_v<optional<U>&&, T>` is `false`,
-- `is_convertible_v<const optional<U>&, T>` is `false`,
-- `is_convertible_v<const optional<U>&&, T>` is `false`,
 - `is_assignable_v<T&, optional<U>&>` is `false`,
 - `is_assignable_v<T&, optional<U>&&>` is `false`,
 - `is_assignable_v<T&, const optional<U>&>` is `false`, and
 - `is_assignable_v<T&, const optional<U>&&>` is `false`.
 *Effects:* See [[optional.assign.move.templ]]. The result of the
-expression `bool(rhs)` remains unchanged.
 **Table: `optional::operator=(optional<U>&&)` effects** <a id="optional.assign.move.templ">[optional.assign.move.templ]</a>
 |                                | `*this` contains a value                               | `*this` does not contain a value                                       |
-| ------------------------------ | ------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------- |
-| `rhs` contains a value         | assigns `std::move(*rhs)` to the contained value       | initializes the contained value as if direct-non-list-initializing an object of type `T` with `std::move(*rhs)` |
 | `rhs` does not contain a value | destroys the contained value by calling `val->T::~T()` | no effect                                                              |
-*Ensures:* `bool(rhs) == bool(*this)`.
 *Returns:* `*this`.
 *Remarks:* If any exception is thrown, the result of the expression
-`bool(*this)` remains unchanged. If an exception is thrown during the
-call to `T`’s constructor, the state of `*rhs.val` is determined by the
-exception safety guarantee of `T`’s constructor. If an exception is
 thrown during the call to `T`’s assignment, the state of `*val` and
 `*rhs.val` is determined by the exception safety guarantee of `T`’s
 assignment.
 ``` cpp
-template<class... Args> T& emplace(Args&&... args);
 ```
 *Mandates:* `is_constructible_v<T, Args...>` is `true`.
-*Effects:* Calls `*this = nullopt`. Then initializes the contained value
-as if direct-non-list-initializing an object of type `T` with the
-arguments `std::forward<Args>(args)...`.
 *Ensures:* `*this` contains a value.
 *Returns:* A reference to the new contained value.
@@ -565,19 +565,18 @@ arguments `std::forward<Args>(args)...`.
 *Remarks:* If an exception is thrown during the call to `T`’s
 constructor, `*this` does not contain a value, and the previous `*val`
 (if any) has been destroyed.
 ``` cpp
-template<class U, class... Args> T& emplace(initializer_list<U> il, Args&&... args);
 ```
 *Constraints:* `is_constructible_v<T, initializer_list<U>&, Args...>` is
 `true`.
-*Effects:* Calls `*this = nullopt`. Then initializes the contained value
-as if direct-non-list-initializing an object of type `T` with the
-arguments `il, std::forward<Args>(args)...`.
 *Ensures:* `*this` contains a value.
 *Returns:* A reference to the new contained value.
@@ -588,75 +587,72 @@ constructor, `*this` does not contain a value, and the previous `*val`
 (if any) has been destroyed.
 #### Swap <a id="optional.swap">[[optional.swap]]</a>
 ``` cpp
-void swap(optional& rhs) noexcept(see below);
 ```
 *Mandates:* `is_move_constructible_v<T>` is `true`.
-*Preconditions:* Lvalues of type `T` are swappable.
 *Effects:* See [[optional.swap]].
 **Table: `optional::swap(optional&)` effects** <a id="optional.swap">[optional.swap]</a>
 |                                | `*this` contains a value                                                                                                                                                                           | `*this` does not contain a value                                                                                                                                                                     |
-| ------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `rhs` contains a value         | calls `swap(*(*this), *rhs)` | initializes the contained value of `*this` as if direct-non-list-initializing an object of type `T` with the expression `std::move(*rhs)`, followed by `rhs.val->T::~T()`; postcondition is that `*this` contains a value and `rhs` does not contain a value |
-| `rhs` does not contain a value | initializes the contained value of `rhs` as if direct-non-list-initializing an object of type `T` with the expression `std::move(*(*this))`, followed by `val->T::~T()`; postcondition is that `*this` does not contain a value and `rhs` contains a value | no effect |
 *Throws:* Any exceptions thrown by the operations in the relevant part
 of [[optional.swap]].
-*Remarks:* The expression inside `noexcept` is equivalent to:
 ``` cpp
 is_nothrow_move_constructible_v<T> && is_nothrow_swappable_v<T>
 ```
-If any exception is thrown, the results of the expressions `bool(*this)`
-and `bool(rhs)` remain unchanged. If an exception is thrown during the
-call to function `swap`, the state of `*val` and `*rhs.val` is
-determined by the exception safety guarantee of `swap` for lvalues of
-`T`. If an exception is thrown during the call to `T`’s move
-constructor, the state of `*val` and `*rhs.val` is determined by the
-exception safety guarantee of `T`’s move constructor.
 #### Observers <a id="optional.observe">[[optional.observe]]</a>
 ``` cpp
-constexpr const T* operator->() const;
-constexpr T* operator->();
 ```
 *Preconditions:* `*this` contains a value.
 *Returns:* `val`.
-*Throws:* Nothing.
 *Remarks:* These functions are constexpr functions.
 ``` cpp
-constexpr const T& operator*() const&;
-constexpr T& operator*() &;
 ```
 *Preconditions:* `*this` contains a value.
 *Returns:* `*val`.
-*Throws:* Nothing.
 *Remarks:* These functions are constexpr functions.
 ``` cpp
-constexpr T&& operator*() &&;
-constexpr const T&& operator*() const&&;
 ```
 *Preconditions:* `*this` contains a value.
 *Effects:* Equivalent to: `return std::move(*val);`
@@ -683,22 +679,22 @@ constexpr T& value() &;
 ```
 *Effects:* Equivalent to:
 ``` cpp
-return bool(*this) ? *val : throw bad_optional_access();
 ```
 ``` cpp
 constexpr T&& value() &&;
 constexpr const T&& value() const &&;
 ```
 *Effects:* Equivalent to:
 ``` cpp
-return bool(*this) ? std::move(*val) : throw bad_optional_access();
 ```
 ``` cpp
 template<class U> constexpr T value_or(U&& v) const &;
 ```
@@ -707,11 +703,11 @@ template<class U> constexpr T value_or(U&& v) const&;
 `true`.
 *Effects:* Equivalent to:
 ``` cpp
-return bool(*this) ? **this : static_cast<T>(std::forward<U>(v));
 ```
 ``` cpp
 template<class U> constexpr T value_or(U&& v) &&;
 ```
@@ -720,17 +716,145 @@ template<class U> constexpr T value_or(U&& v) &&;
 `true`.
 *Effects:* Equivalent to:
 ``` cpp
-return bool(*this) ? std::move(**this) : static_cast<T>(std::forward<U>(v));
 ```
 #### Modifiers <a id="optional.mod">[[optional.mod]]</a>
 ``` cpp
-void reset() noexcept;
 ```
 *Effects:* If `*this` contains a value, calls `val->T::T̃()` to destroy
 the contained value; otherwise no effect.
@@ -753,15 +877,17 @@ Type `nullopt_t` shall not have a default constructor or an
 initializer-list constructor, and shall not be an aggregate.
 ### Class `bad_optional_access` <a id="optional.bad.access">[[optional.bad.access]]</a>
 ``` cpp
   class bad_optional_access : public exception {
   public:
     // see [exception] for the specification of the special member functions
     const char* what() const noexcept override;
   };
 ```
 The class `bad_optional_access` defines the type of objects thrown as
 exceptions to report the situation where an attempt is made to access
 the value of an optional object that does not contain a value.
@@ -781,12 +907,12 @@ template<class T, class U> constexpr bool operator==(const optional<T>& x, const
 *Mandates:* The expression `*x == *y` is well-formed and its result is
 convertible to `bool`.
 [*Note 1*: `T` need not be *Cpp17EqualityComparable*. — *end note*]
-*Returns:* If `bool(x) != bool(y)`, `false`; otherwise if
-`bool(x) == false`, `true`; otherwise `*x == *y`.
 *Remarks:* Specializations of this function template for which
 `*x == *y` is a core constant expression are constexpr functions.
 ``` cpp
@@ -794,12 +920,12 @@ template<class T, class U> constexpr bool operator!=(const optional<T>& x, const
 ```
 *Mandates:* The expression `*x != *y` is well-formed and its result is
 convertible to `bool`.
-*Returns:* If `bool(x) != bool(y)`, `true`; otherwise, if
-`bool(x) == false`, `false`; otherwise `*x != *y`.
 *Remarks:* Specializations of this function template for which
 `*x != *y` is a core constant expression are constexpr functions.
 ``` cpp
@@ -858,11 +984,12 @@ convertible to `bool`.
 template<class T, three_way_comparable_with<T> U>
   constexpr compare_three_way_result_t<T, U>
     operator<=>(const optional<T>& x, const optional<U>& y);
 ```
-*Returns:* If `x && y`, `*x <=> *y`; otherwise `bool(x) <=> bool(y)`.
 *Remarks:* Specializations of this function template for which
 `*x <=> *y` is a core constant expression are constexpr functions.
 ### Comparison with `nullopt` <a id="optional.nullops">[[optional.nullops]]</a>
@@ -875,11 +1002,11 @@ template<class T> constexpr bool operator==(const optional<T>& x, nullopt_t) noe
 ``` cpp
 template<class T> constexpr strong_ordering operator<=>(const optional<T>& x, nullopt_t) noexcept;
 ```
-*Returns:* `bool(x) <=> false`.
 ### Comparison with `T` <a id="optional.comp.with.t">[[optional.comp.with.t]]</a>
 ``` cpp
 template<class T, class U> constexpr bool operator==(const optional<T>& x, const U& v);
@@ -888,124 +1015,126 @@ template<class T, class U> constexpr bool operator==(const optional<T>& x, const
 *Mandates:* The expression `*x == v` is well-formed and its result is
 convertible to `bool`.
 [*Note 1*: `T` need not be *Cpp17EqualityComparable*. — *end note*]
-*Effects:* Equivalent to: `return bool(x) ? *x == v : false;`
 ``` cpp
 template<class T, class U> constexpr bool operator==(const T& v, const optional<U>& x);
 ```
 *Mandates:* The expression `v == *x` is well-formed and its result is
 convertible to `bool`.
-*Effects:* Equivalent to: `return bool(x) ? v == *x : false;`
 ``` cpp
 template<class T, class U> constexpr bool operator!=(const optional<T>& x, const U& v);
 ```
 *Mandates:* The expression `*x != v` is well-formed and its result is
 convertible to `bool`.
-*Effects:* Equivalent to: `return bool(x) ? *x != v : true;`
 ``` cpp
 template<class T, class U> constexpr bool operator!=(const T& v, const optional<U>& x);
 ```
 *Mandates:* The expression `v != *x` is well-formed and its result is
 convertible to `bool`.
-*Effects:* Equivalent to: `return bool(x) ? v != *x : true;`
 ``` cpp
 template<class T, class U> constexpr bool operator<(const optional<T>& x, const U& v);
 ```
 *Mandates:* The expression `*x < v` is well-formed and its result is
 convertible to `bool`.
-*Effects:* Equivalent to: `return bool(x) ? *x < v : true;`
 ``` cpp
 template<class T, class U> constexpr bool operator<(const T& v, const optional<U>& x);
 ```
 *Mandates:* The expression `v < *x` is well-formed and its result is
 convertible to `bool`.
-*Effects:* Equivalent to: `return bool(x) ? v < *x : false;`
 ``` cpp
 template<class T, class U> constexpr bool operator>(const optional<T>& x, const U& v);
 ```
 *Mandates:* The expression `*x > v` is well-formed and its result is
 convertible to `bool`.
-*Effects:* Equivalent to: `return bool(x) ? *x > v : false;`
 ``` cpp
 template<class T, class U> constexpr bool operator>(const T& v, const optional<U>& x);
 ```
 *Mandates:* The expression `v > *x` is well-formed and its result is
 convertible to `bool`.
-*Effects:* Equivalent to: `return bool(x) ? v > *x : true;`
 ``` cpp
 template<class T, class U> constexpr bool operator<=(const optional<T>& x, const U& v);
 ```
 *Mandates:* The expression `*x <= v` is well-formed and its result is
 convertible to `bool`.
-*Effects:* Equivalent to: `return bool(x) ? *x <= v : true;`
 ``` cpp
 template<class T, class U> constexpr bool operator<=(const T& v, const optional<U>& x);
 ```
 *Mandates:* The expression `v <= *x` is well-formed and its result is
 convertible to `bool`.
-*Effects:* Equivalent to: `return bool(x) ? v <= *x : false;`
 ``` cpp
 template<class T, class U> constexpr bool operator>=(const optional<T>& x, const U& v);
 ```
 *Mandates:* The expression `*x >= v` is well-formed and its result is
 convertible to `bool`.
-*Effects:* Equivalent to: `return bool(x) ? *x >= v : false;`
 ``` cpp
 template<class T, class U> constexpr bool operator>=(const T& v, const optional<U>& x);
 ```
 *Mandates:* The expression `v >= *x` is well-formed and its result is
 convertible to `bool`.
-*Effects:* Equivalent to: `return bool(x) ? v >= *x : true;`
 ``` cpp
-template<class T, three_way_comparable_with<T> U>
   constexpr compare_three_way_result_t<T, U>
     operator<=>(const optional<T>& x, const U& v);
 ```
 *Effects:* Equivalent to:
-`return bool(x) ? *x <=> v : strong_ordering::less;`
 ### Specialized algorithms <a id="optional.specalg">[[optional.specalg]]</a>
 ``` cpp
-template<class T> void swap(optional<T>& x, optional<T>& y) noexcept(noexcept(x.swap(y)));
 ```
 *Constraints:* `is_move_constructible_v<T>` is `true` and
 `is_swappable_v<T>` is `true`.
@@ -1039,11 +1168,11 @@ template<class T, class U, class... Args>
 template<class T> struct hash<optional<T>>;
 ```
 The specialization `hash<optional<T>>` is enabled [[unord.hash]] if and
 only if `hash<remove_const_t<T>>` is enabled. When enabled, for an
-object `o` of type `optional<T>`, if `bool(o) == true`, then
 `hash<optional<T>>()(o)` evaluates to the same value as
 `hash<remove_const_t<T>>()(*o)`; otherwise it evaluates to an
 unspecified value. The member functions are not guaranteed to be
 `noexcept`.

 namespace std {
   // [optional.optional], class template optional
   template<class T>
     class optional;
+  template<class T>
+    concept is-derived-from-optional = requires(const T& t) {       // exposition only
+      []<class U>(const optional<U>&){ }(t);
+    };
   // [optional.nullopt], no-value state indicator
   struct nullopt_t{see below};
   inline constexpr nullopt_t nullopt(unspecified);
   // [optional.bad.access], class bad_optional_access
   template<class T, class U> constexpr bool operator>(const T&, const optional<U>&);
   template<class T, class U> constexpr bool operator<=(const optional<T>&, const U&);
   template<class T, class U> constexpr bool operator<=(const T&, const optional<U>&);
   template<class T, class U> constexpr bool operator>=(const optional<T>&, const U&);
   template<class T, class U> constexpr bool operator>=(const T&, const optional<U>&);
+  template<class T, class U>
+      requires (!is-derived-from-optional<U>) && three_way_comparable_with<T, U>
     constexpr compare_three_way_result_t<T, U>
       operator<=>(const optional<T>&, const U&);
   // [optional.specalg], specialized algorithms
   template<class T>
+ constexpr void swap(optional<T>&, optional<T>&) noexcept(see below);
   template<class T>
     constexpr optional<see below> make_optional(T&&);
   template<class T, class... Args>
     constexpr optional<T> make_optional(Args&&... args);
 }
 ```
 ### Class template `optional` <a id="optional.optional">[[optional.optional]]</a>
+#### General <a id="optional.optional.general">[[optional.optional.general]]</a>
 ``` cpp
 namespace std {
   template<class T>
   class optional {
   public:
     template<class U, class... Args>
       constexpr explicit optional(in_place_t, initializer_list<U>, Args&&...);
     template<class U = T>
       constexpr explicit(see below) optional(U&&);
     template<class U>
+ constexpr explicit(see below) optional(const optional<U>&);
     template<class U>
+ constexpr explicit(see below) optional(optional<U>&&);
     // [optional.dtor], destructor
+ constexpr ~optional();
     // [optional.assign], assignment
+ constexpr optional& operator=(nullopt_t) noexcept;
     constexpr optional& operator=(const optional&);
     constexpr optional& operator=(optional&&) noexcept(see below);
+    template<class U = T> constexpr optional& operator=(U&&);
+    template<class U> constexpr optional& operator=(const optional<U>&);
+    template<class U> constexpr optional& operator=(optional<U>&&);
+    template<class... Args> constexpr T& emplace(Args&&...);
+    template<class U, class... Args> constexpr T& emplace(initializer_list<U>, Args&&...);
     // [optional.swap], swap
+ constexpr void swap(optional&) noexcept(see below);
     // [optional.observe], observers
+    constexpr const T* operator->() const noexcept;
+    constexpr T* operator->() noexcept;
+    constexpr const T& operator*() const & noexcept;
+    constexpr T& operator*() & noexcept;
+    constexpr T&& operator*() && noexcept;
+    constexpr const T&& operator*() const && noexcept;
     constexpr explicit operator bool() const noexcept;
     constexpr bool has_value() const noexcept;
     constexpr const T& value() const &;
     constexpr T& value() &;
     constexpr T&& value() &&;
     constexpr const T&& value() const &&;
     template<class U> constexpr T value_or(U&&) const &;
     template<class U> constexpr T value_or(U&&) &&;
+    // [optional.monadic], monadic operations
+    template<class F> constexpr auto and_then(F&& f) &;
+    template<class F> constexpr auto and_then(F&& f) &&;
+    template<class F> constexpr auto and_then(F&& f) const &;
+    template<class F> constexpr auto and_then(F&& f) const &&;
+    template<class F> constexpr auto transform(F&& f) &;
+    template<class F> constexpr auto transform(F&& f) &&;
+    template<class F> constexpr auto transform(F&& f) const &;
+    template<class F> constexpr auto transform(F&& f) const &&;
+    template<class F> constexpr optional or_else(F&& f) &&;
+    template<class F> constexpr optional or_else(F&& f) const &;
     // [optional.mod], modifiers
+ constexpr void reset() noexcept;
   private:
     T *val;         // exposition only
   };
 Any instance of `optional<T>` at any given time either contains a value
 or does not contain a value. When an instance of `optional<T>` *contains
 a value*, it means that an object of type `T`, referred to as the
 optional object’s *contained value*, is allocated within the storage of
 the optional object. Implementations are not permitted to use additional
+storage, such as dynamic memory, to allocate its contained value. When
+an object of type `optional<T>` is contextually converted to `bool`, the
+conversion returns `true` if the object contains a value; otherwise the
+conversion returns `false`.
+When an `optional<T>` object contains a value, member `val` points to
+the contained value.
 `T` shall be a type other than cv `in_place_t` or cv `nullopt_t` that
 meets the *Cpp17Destructible* requirements ([[cpp17.destructible]]).
 #### Constructors <a id="optional.ctor">[[optional.ctor]]</a>
+The exposition-only variable template *`converts-from-any-cvref`* is
+used by some constructors for `optional`.
+``` cpp
+template<class T, class W>
+constexpr bool converts-from-any-cvref =  // exposition only
+  disjunction_v<is_constructible<T, W&>, is_convertible<W&, T>,
+                is_constructible<T, W>, is_convertible<W, T>,
+                is_constructible<T, const W&>, is_convertible<const W&, T>,
+                is_constructible<T, const W>, is_convertible<const W, T>>;
+```
 ``` cpp
 constexpr optional() noexcept;
 constexpr optional(nullopt_t) noexcept;
 ```
 ``` cpp
 constexpr optional(const optional& rhs);
 ```
+*Effects:* If `rhs` contains a value, direct-non-list-initializes the
+contained value with `*rhs`.
+*Ensures:* `rhs.has_value() == this->has_value()`.
 *Throws:* Any exception thrown by the selected constructor of `T`.
 *Remarks:* This constructor is defined as deleted unless
 `is_copy_constructible_v<T>` is `true`. If
 constexpr optional(optional&& rhs) noexcept(see below);
 ```
 *Constraints:* `is_move_constructible_v<T>` is `true`.
+*Effects:* If `rhs` contains a value, direct-non-list-initializes the
+contained value with `std::move(*rhs)`. `rhs.has_value()` is unchanged.
+*Ensures:* `rhs.has_value() == this->has_value()`.
 *Throws:* Any exception thrown by the selected constructor of `T`.
+*Remarks:* The exception specification is equivalent to
 `is_nothrow_move_constructible_v<T>`. If
 `is_trivially_move_constructible_v<T>` is `true`, this constructor is
 trivial.
 ``` cpp
 template<class... Args> constexpr explicit optional(in_place_t, Args&&... args);
 ```
 *Constraints:* `is_constructible_v<T, Args...>` is `true`.
+*Effects:* Direct-non-list-initializes the contained value with
 `std::forward<Args>(args)...`.
 *Ensures:* `*this` contains a value.
 *Throws:* Any exception thrown by the selected constructor of `T`.
 ```
 *Constraints:* `is_constructible_v<T, initializer_list<U>&, Args...>` is
 `true`.
+*Effects:* Direct-non-list-initializes the contained value with
 `il, std::forward<Args>(args)...`.
 *Ensures:* `*this` contains a value.
 *Throws:* Any exception thrown by the selected constructor of `T`.
 ``` cpp
 template<class U = T> constexpr explicit(see below) optional(U&& v);
 ```
+*Constraints:*
+- `is_constructible_v<T, U>` is `true`,
+- `is_same_v<remove_cvref_t<U>, in_place_t>` is `false`,
+- `is_same_v<remove_cvref_t<U>, optional>` is `false`, and
+- if `T` is cv `bool`, `remove_cvref_t<U>` is not a specialization of
+  `optional`.
+*Effects:* Direct-non-list-initializes the contained value with
 `std::forward<U>(v)`.
 *Ensures:* `*this` contains a value.
 *Throws:* Any exception thrown by the selected constructor of `T`.
 ``` cpp
 !is_convertible_v<U, T>
 ```
 ``` cpp
+template<class U> constexpr explicit(see below) optional(const optional<U>& rhs);
 ```
 *Constraints:*
+- `is_constructible_v<T, const U&>` is `true`, and
+- if `T` is not cv `bool`, *`converts-from-any-cvref`*`<T, optional<U>>`
+ is `false`.
+*Effects:* If `rhs` contains a value, direct-non-list-initializes the
+contained value with `*rhs`.
+*Ensures:* `rhs.has_value() == this->has_value()`.
 *Throws:* Any exception thrown by the selected constructor of `T`.
 *Remarks:* The expression inside `explicit` is equivalent to:
 ``` cpp
 !is_convertible_v<const U&, T>
 ```
 ``` cpp
+template<class U> constexpr explicit(see below) optional(optional<U>&& rhs);
 ```
 *Constraints:*
+- `is_constructible_v<T, U>` is `true`, and
+- if `T` is not cv `bool`, *`converts-from-any-cvref`*`<T, optional<U>>`
+ is `false`.
+*Effects:* If `rhs` contains a value, direct-non-list-initializes the
+contained value with `std::move(*rhs)`. `rhs.has_value()` is unchanged.
+*Ensures:* `rhs.has_value() == this->has_value()`.
 *Throws:* Any exception thrown by the selected constructor of `T`.
 *Remarks:* The expression inside `explicit` is equivalent to:
 ```
 #### Destructor <a id="optional.dtor">[[optional.dtor]]</a>
 ``` cpp
+constexpr ~optional();
 ```
 *Effects:* If `is_trivially_destructible_v<T> != true` and `*this`
 contains a value, calls
 destructor is trivial.
 #### Assignment <a id="optional.assign">[[optional.assign]]</a>
 ``` cpp
+constexpr optional<T>& operator=(nullopt_t) noexcept;
 ```
 *Effects:* If `*this` contains a value, calls `val->T::T̃()` to destroy
 the contained value; otherwise no effect.
 *Effects:* See [[optional.assign.copy]].
 **Table: `optional::operator=(const optional&)` effects** <a id="optional.assign.copy">[optional.assign.copy]</a>
 |                                | `*this` contains a value                               | `*this` does not contain a value                            |
+| ------------------------------ | ------------------------------------------------------ | ----------------------------------------------------------- |
+| `rhs` contains a value         | assigns `*rhs` to the contained value                  | direct-non-list-initializes the contained value with `*rhs` |
 | `rhs` does not contain a value | destroys the contained value by calling `val->T::~T()` | no effect                                                   |
+*Ensures:* `rhs.has_value() == this->has_value()`.
 *Returns:* `*this`.
 *Remarks:* If any exception is thrown, the result of the expression
+`this->has_value()` remains unchanged. If an exception is thrown during
+the call to `T`’s copy constructor, no effect. If an exception is thrown
 during the call to `T`’s copy assignment, the state of its contained
 value is as defined by the exception safety guarantee of `T`’s copy
 assignment. This operator is defined as deleted unless
 `is_copy_constructible_v<T>` is `true` and `is_copy_assignable_v<T>` is
 `true`. If `is_trivially_copy_constructible_v<T> &&`
 *Constraints:* `is_move_constructible_v<T>` is `true` and
 `is_move_assignable_v<T>` is `true`.
 *Effects:* See [[optional.assign.move]]. The result of the expression
+`rhs.has_value()` remains unchanged.
 **Table: `optional::operator=(optional&&)` effects** <a id="optional.assign.move">[optional.assign.move]</a>
 |                                | `*this` contains a value                               | `*this` does not contain a value                                       |
+| ------------------------------ | ------------------------------------------------------ | ---------------------------------------------------------------------- |
+| `rhs` contains a value         | assigns `std::move(*rhs)` to the contained value       | direct-non-list-initializes the contained value with `std::move(*rhs)` |
 | `rhs` does not contain a value | destroys the contained value by calling `val->T::~T()` | no effect                                                              |
+*Ensures:* `rhs.has_value() == this->has_value()`.
 *Returns:* `*this`.
+*Remarks:* The exception specification is equivalent to:
 ``` cpp
 is_nothrow_move_assignable_v<T> && is_nothrow_move_constructible_v<T>
 ```
+If any exception is thrown, the result of the expression
+`this->has_value()` remains unchanged. If an exception is thrown during
+the call to `T`’s move constructor, the state of `*rhs.val` is
+determined by the exception safety guarantee of `T`’s move constructor.
+If an exception is thrown during the call to `T`’s move assignment, the
+state of `*val` and `*rhs.val` is determined by the exception safety
+guarantee of `T`’s move assignment. If
+`is_trivially_move_constructible_v<T> &&`
 `is_trivially_move_assignable_v<T> &&` `is_trivially_destructible_v<T>`
 is `true`, this assignment operator is trivial.
 ``` cpp
+template<class U = T> constexpr optional<T>& operator=(U&& v);
 ```
 *Constraints:* `is_same_v<remove_cvref_t<U>, optional>` is `false`,
 `conjunction_v<is_scalar<T>, is_same<T, decay_t<U>>>` is `false`,
 `is_constructible_v<T, U>` is `true`, and `is_assignable_v<T&, U>` is
 `true`.
 *Effects:* If `*this` contains a value, assigns `std::forward<U>(v)` to
+the contained value; otherwise direct-non-list-initializes the contained
+value with `std::forward<U>(v)`.
 *Ensures:* `*this` contains a value.
 *Returns:* `*this`.
 *Remarks:* If any exception is thrown, the result of the expression
+`this->has_value()` remains unchanged. If an exception is thrown during
+the call to `T`’s constructor, the state of `v` is determined by the
 exception safety guarantee of `T`’s constructor. If an exception is
 thrown during the call to `T`’s assignment, the state of `*val` and `v`
 is determined by the exception safety guarantee of `T`’s assignment.
 ``` cpp
+template<class U> constexpr optional<T>& operator=(const optional<U>& rhs);
 ```
 *Constraints:*
 - `is_constructible_v<T, const U&>` is `true`,
 - `is_assignable_v<T&, const U&>` is `true`,
+- *`converts-from-any-cvref`*`<T, optional<U>>` is `false`,
 - `is_assignable_v<T&, optional<U>&>` is `false`,
 - `is_assignable_v<T&, optional<U>&&>` is `false`,
 - `is_assignable_v<T&, const optional<U>&>` is `false`, and
 - `is_assignable_v<T&, const optional<U>&&>` is `false`.
 *Effects:* See [[optional.assign.copy.templ]].
 **Table: `optional::operator=(const optional<U>&)` effects** <a id="optional.assign.copy.templ">[optional.assign.copy.templ]</a>
 |                                | `*this` contains a value                               | `*this` does not contain a value                            |
+| ------------------------------ | ------------------------------------------------------ | ----------------------------------------------------------- |
+| `rhs` contains a value         | assigns `*rhs` to the contained value                  | direct-non-list-initializes the contained value with `*rhs` |
 | `rhs` does not contain a value | destroys the contained value by calling `val->T::~T()` | no effect                                                   |
+*Ensures:* `rhs.has_value() == this->has_value()`.
 *Returns:* `*this`.
 *Remarks:* If any exception is thrown, the result of the expression
+`this->has_value()` remains unchanged. If an exception is thrown during
+the call to `T`’s constructor, the state of `*rhs.val` is determined by
+the exception safety guarantee of `T`’s constructor. If an exception is
 thrown during the call to `T`’s assignment, the state of `*val` and
 `*rhs.val` is determined by the exception safety guarantee of `T`’s
 assignment.
 ``` cpp
+template<class U> constexpr optional<T>& operator=(optional<U>&& rhs);
 ```
 *Constraints:*
 - `is_constructible_v<T, U>` is `true`,
 - `is_assignable_v<T&, U>` is `true`,
+- *`converts-from-any-cvref`*`<T, optional<U>>` is `false`,
 - `is_assignable_v<T&, optional<U>&>` is `false`,
 - `is_assignable_v<T&, optional<U>&&>` is `false`,
 - `is_assignable_v<T&, const optional<U>&>` is `false`, and
 - `is_assignable_v<T&, const optional<U>&&>` is `false`.
 *Effects:* See [[optional.assign.move.templ]]. The result of the
+expression `rhs.has_value()` remains unchanged.
 **Table: `optional::operator=(optional<U>&&)` effects** <a id="optional.assign.move.templ">[optional.assign.move.templ]</a>
 |                                | `*this` contains a value                               | `*this` does not contain a value                                       |
+| ------------------------------ | ------------------------------------------------------ | ---------------------------------------------------------------------- |
+| `rhs` contains a value         | assigns `std::move(*rhs)` to the contained value       | direct-non-list-initializes the contained value with `std::move(*rhs)` |
 | `rhs` does not contain a value | destroys the contained value by calling `val->T::~T()` | no effect                                                              |
+*Ensures:* `rhs.has_value() == this->has_value()`.
 *Returns:* `*this`.
 *Remarks:* If any exception is thrown, the result of the expression
+`this->has_value()` remains unchanged. If an exception is thrown during
+the call to `T`’s constructor, the state of `*rhs.val` is determined by
+the exception safety guarantee of `T`’s constructor. If an exception is
 thrown during the call to `T`’s assignment, the state of `*val` and
 `*rhs.val` is determined by the exception safety guarantee of `T`’s
 assignment.
 ``` cpp
+template<class... Args> constexpr T& emplace(Args&&... args);
 ```
 *Mandates:* `is_constructible_v<T, Args...>` is `true`.
+*Effects:* Calls `*this = nullopt`. Then direct-non-list-initializes the
+contained value with `std::forward<Args>(args)...`.
 *Ensures:* `*this` contains a value.
 *Returns:* A reference to the new contained value.
 *Remarks:* If an exception is thrown during the call to `T`’s
 constructor, `*this` does not contain a value, and the previous `*val`
 (if any) has been destroyed.
 ``` cpp
+template<class U, class... Args> constexpr T& emplace(initializer_list<U> il, Args&&... args);
 ```
 *Constraints:* `is_constructible_v<T, initializer_list<U>&, Args...>` is
 `true`.
+*Effects:* Calls `*this = nullopt`. Then direct-non-list-initializes the
+contained value with `il, std::forward<Args>(args)...`.
 *Ensures:* `*this` contains a value.
 *Returns:* A reference to the new contained value.
 (if any) has been destroyed.
 #### Swap <a id="optional.swap">[[optional.swap]]</a>
 ``` cpp
+constexpr void swap(optional& rhs) noexcept(see below);
 ```
 *Mandates:* `is_move_constructible_v<T>` is `true`.
+*Preconditions:* `T` meets the *Cpp17Swappable*
+requirements [[swappable.requirements]].
 *Effects:* See [[optional.swap]].
 **Table: `optional::swap(optional&)` effects** <a id="optional.swap">[optional.swap]</a>
 |                                | `*this` contains a value                                                                                                                                                                           | `*this` does not contain a value                                                                                                                                                                     |
+| ------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `rhs` contains a value         | calls `swap(*(*this), *rhs)` | direct-non-list-initializes the contained value of `*this` with `std::move(*rhs)`, followed by `rhs.val->T::~T()`; postcondition is that `*this` contains a value and `rhs` does not contain a value |
+| `rhs` does not contain a value | direct-non-list-initializes the contained value of `rhs` with `std::move(*(*this))`, followed by `val->T::~T()`; postcondition is that `*this` does not contain a value and `rhs` contains a value | no effect |
 *Throws:* Any exceptions thrown by the operations in the relevant part
 of [[optional.swap]].
+*Remarks:* The exception specification is equivalent to:
 ``` cpp
 is_nothrow_move_constructible_v<T> && is_nothrow_swappable_v<T>
 ```
+If any exception is thrown, the results of the expressions
+`this->has_value()` and `rhs.has_value()` remain unchanged. If an
+exception is thrown during the call to function `swap`, the state of
+`*val` and `*rhs.val` is determined by the exception safety guarantee of
+`swap` for lvalues of `T`. If an exception is thrown during the call to
+`T`’s move constructor, the state of `*val` and `*rhs.val` is determined
+by the exception safety guarantee of `T`’s move constructor.
 #### Observers <a id="optional.observe">[[optional.observe]]</a>
 ``` cpp
+constexpr const T* operator->() const noexcept;
+constexpr T* operator->() noexcept;
 ```
 *Preconditions:* `*this` contains a value.
 *Returns:* `val`.
 *Remarks:* These functions are constexpr functions.
 ``` cpp
+constexpr const T& operator*() const & noexcept;
+constexpr T& operator*() & noexcept;
 ```
 *Preconditions:* `*this` contains a value.
 *Returns:* `*val`.
 *Remarks:* These functions are constexpr functions.
 ``` cpp
+constexpr T&& operator*() && noexcept;
+constexpr const T&& operator*() const && noexcept;
 ```
 *Preconditions:* `*this` contains a value.
 *Effects:* Equivalent to: `return std::move(*val);`
 ```
 *Effects:* Equivalent to:
 ``` cpp
+return has_value() ? *val : throw bad_optional_access();
 ```
 ``` cpp
 constexpr T&& value() &&;
 constexpr const T&& value() const &&;
 ```
 *Effects:* Equivalent to:
 ``` cpp
+return has_value() ? std::move(*val) : throw bad_optional_access();
 ```
 ``` cpp
 template<class U> constexpr T value_or(U&& v) const &;
 ```
 `true`.
 *Effects:* Equivalent to:
 ``` cpp
+return has_value() ? **this : static_cast<T>(std::forward<U>(v));
 ```
 ``` cpp
 template<class U> constexpr T value_or(U&& v) &&;
 ```
 `true`.
 *Effects:* Equivalent to:
 ``` cpp
+return has_value() ? std::move(**this) : static_cast<T>(std::forward<U>(v));
+```
+#### Monadic operations <a id="optional.monadic">[[optional.monadic]]</a>
+``` cpp
+template<class F> constexpr auto and_then(F&& f) &;
+template<class F> constexpr auto and_then(F&& f) const &;
+```
+Let `U` be `invoke_result_t<F, decltype(value())>`.
+*Mandates:* `remove_cvref_t<U>` is a specialization of `optional`.
+*Effects:* Equivalent to:
+``` cpp
+if (*this) {
+  return invoke(std::forward<F>(f), value());
+} else {
+  return remove_cvref_t<U>();
+}
+```
+``` cpp
+template<class F> constexpr auto and_then(F&& f) &&;
+template<class F> constexpr auto and_then(F&& f) const &&;
+```
+Let `U` be `invoke_result_t<F, decltype(std::move(value()))>`.
+*Mandates:* `remove_cvref_t<U>` is a specialization of `optional`.
+*Effects:* Equivalent to:
+``` cpp
+if (*this) {
+  return invoke(std::forward<F>(f), std::move(value()));
+} else {
+  return remove_cvref_t<U>();
+}
+```
+``` 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())>>`.
+*Mandates:* `U` is a non-array object type other than `in_place_t` or
+`nullopt_t`. The declaration
+``` cpp
+U u(invoke(std::forward<F>(f), value()));
+```
+is well-formed for some invented variable `u`.
+[*Note 1*: There is no requirement that `U` is
+movable [[dcl.init.general]]. — *end note*]
+*Returns:* If `*this` contains a value, an `optional<U>` object whose
+contained value is direct-non-list-initialized with
+`invoke(std::forward<F>(f), value())`; otherwise, `optional<U>()`.
+``` 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()))>>`.
+*Mandates:* `U` is a non-array object type other than `in_place_t` or
+`nullopt_t`. The declaration
+``` cpp
+U u(invoke(std::forward<F>(f), std::move(value())));
+```
+is well-formed for some invented variable `u`.
+[*Note 2*: There is no requirement that `U` is
+movable [[dcl.init.general]]. — *end note*]
+*Returns:* If `*this` contains a value, an `optional<U>` object whose
+contained value is direct-non-list-initialized with
+`invoke(std::forward<F>(f), std::move(value()))`; otherwise,
+`optional<U>()`.
+``` cpp
+template<class F> constexpr optional or_else(F&& f) const &;
+```
+*Constraints:* `F` models `invocable<>` and `T` models
+`copy_constructible`.
+*Mandates:* `is_same_v<remove_cvref_t<invoke_result_t<F>>, optional>` is
+`true`.
+*Effects:* Equivalent to:
+``` cpp
+if (*this) {
+  return *this;
+} else {
+  return std::forward<F>(f)();
+}
+```
+``` cpp
+template<class F> constexpr optional or_else(F&& f) &&;
+```
+*Constraints:* `F` models `invocable<>` and `T` models
+`move_constructible`.
+*Mandates:* `is_same_v<remove_cvref_t<invoke_result_t<F>>, optional>` is
+`true`.
+*Effects:* Equivalent to:
+``` cpp
+if (*this) {
+  return std::move(*this);
+} else {
+  return std::forward<F>(f)();
+}
 ```
 #### Modifiers <a id="optional.mod">[[optional.mod]]</a>
 ``` cpp
+constexpr void reset() noexcept;
 ```
 *Effects:* If `*this` contains a value, calls `val->T::T̃()` to destroy
 the contained value; otherwise no effect.
 initializer-list constructor, and shall not be an aggregate.
 ### Class `bad_optional_access` <a id="optional.bad.access">[[optional.bad.access]]</a>
 ``` cpp
+namespace std {
   class bad_optional_access : public exception {
   public:
     // see [exception] for the specification of the special member functions
     const char* what() const noexcept override;
   };
+}
 ```
 The class `bad_optional_access` defines the type of objects thrown as
 exceptions to report the situation where an attempt is made to access
 the value of an optional object that does not contain a value.
 *Mandates:* The expression `*x == *y` is well-formed and its result is
 convertible to `bool`.
 [*Note 1*: `T` need not be *Cpp17EqualityComparable*. — *end note*]
+*Returns:* If `x.has_value() != y.has_value()`, `false`; otherwise if
+`x.has_value() == false`, `true`; otherwise `*x == *y`.
 *Remarks:* Specializations of this function template for which
 `*x == *y` is a core constant expression are constexpr functions.
 ``` cpp
 ```
 *Mandates:* The expression `*x != *y` is well-formed and its result is
 convertible to `bool`.
+*Returns:* If `x.has_value() != y.has_value()`, `true`; otherwise, if
+`x.has_value() == false`, `false`; otherwise `*x != *y`.
 *Remarks:* Specializations of this function template for which
 `*x != *y` is a core constant expression are constexpr functions.
 ``` cpp
 template<class T, three_way_comparable_with<T> U>
   constexpr compare_three_way_result_t<T, U>
     operator<=>(const optional<T>& x, const optional<U>& y);
 ```
+*Returns:* If `x && y`, `*x <=> *y`; otherwise
+`x.has_value() <=> y.has_value()`.
 *Remarks:* Specializations of this function template for which
 `*x <=> *y` is a core constant expression are constexpr functions.
 ### Comparison with `nullopt` <a id="optional.nullops">[[optional.nullops]]</a>
 ``` cpp
 template<class T> constexpr strong_ordering operator<=>(const optional<T>& x, nullopt_t) noexcept;
 ```
+*Returns:* `x.has_value() <=> false`.
 ### Comparison with `T` <a id="optional.comp.with.t">[[optional.comp.with.t]]</a>
 ``` cpp
 template<class T, class U> constexpr bool operator==(const optional<T>& x, const U& 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*]
+*Effects:* Equivalent to: `return x.has_value() ? *x == v : false;`
 ``` cpp
 template<class T, class U> constexpr bool operator==(const T& v, const optional<U>& x);
 ```
 *Mandates:* The expression `v == *x` is well-formed and its result is
 convertible to `bool`.
+*Effects:* Equivalent to: `return x.has_value() ? v == *x : false;`
 ``` cpp
 template<class T, class U> constexpr bool operator!=(const optional<T>& x, const U& v);
 ```
 *Mandates:* The expression `*x != v` is well-formed and its result is
 convertible to `bool`.
+*Effects:* Equivalent to: `return x.has_value() ? *x != v : true;`
 ``` cpp
 template<class T, class U> constexpr bool operator!=(const T& v, const optional<U>& x);
 ```
 *Mandates:* The expression `v != *x` is well-formed and its result is
 convertible to `bool`.
+*Effects:* Equivalent to: `return x.has_value() ? v != *x : true;`
 ``` cpp
 template<class T, class U> constexpr bool operator<(const optional<T>& x, const U& v);
 ```
 *Mandates:* The expression `*x < v` is well-formed and its result is
 convertible to `bool`.
+*Effects:* Equivalent to: `return x.has_value() ? *x < v : true;`
 ``` cpp
 template<class T, class U> constexpr bool operator<(const T& v, const optional<U>& x);
 ```
 *Mandates:* The expression `v < *x` is well-formed and its result is
 convertible to `bool`.
+*Effects:* Equivalent to: `return x.has_value() ? v < *x : false;`
 ``` cpp
 template<class T, class U> constexpr bool operator>(const optional<T>& x, const U& v);
 ```
 *Mandates:* The expression `*x > v` is well-formed and its result is
 convertible to `bool`.
+*Effects:* Equivalent to: `return x.has_value() ? *x > v : false;`
 ``` cpp
 template<class T, class U> constexpr bool operator>(const T& v, const optional<U>& x);
 ```
 *Mandates:* The expression `v > *x` is well-formed and its result is
 convertible to `bool`.
+*Effects:* Equivalent to: `return x.has_value() ? v > *x : true;`
 ``` cpp
 template<class T, class U> constexpr bool operator<=(const optional<T>& x, const U& v);
 ```
 *Mandates:* The expression `*x <= v` is well-formed and its result is
 convertible to `bool`.
+*Effects:* Equivalent to: `return x.has_value() ? *x <= v : true;`
 ``` cpp
 template<class T, class U> constexpr bool operator<=(const T& v, const optional<U>& x);
 ```
 *Mandates:* The expression `v <= *x` is well-formed and its result is
 convertible to `bool`.
+*Effects:* Equivalent to: `return x.has_value() ? v <= *x : false;`
 ``` cpp
 template<class T, class U> constexpr bool operator>=(const optional<T>& x, const U& v);
 ```
 *Mandates:* The expression `*x >= v` is well-formed and its result is
 convertible to `bool`.
+*Effects:* Equivalent to: `return x.has_value() ? *x >= v : false;`
 ``` cpp
 template<class T, class U> constexpr bool operator>=(const T& v, const optional<U>& x);
 ```
 *Mandates:* The expression `v >= *x` is well-formed and its result is
 convertible to `bool`.
+*Effects:* Equivalent to: `return x.has_value() ? v >= *x : true;`
 ``` cpp
+template<class T, class U>
+    requires (!is-derived-from-optional<U>) && three_way_comparable_with<T, U>
   constexpr compare_three_way_result_t<T, U>
     operator<=>(const optional<T>& x, const U& v);
 ```
 *Effects:* Equivalent to:
+`return x.has_value() ? *x <=> v : strong_ordering::less;`
 ### Specialized algorithms <a id="optional.specalg">[[optional.specalg]]</a>
 ``` cpp
+template<class T>
+  constexpr void swap(optional<T>& x, optional<T>& y) noexcept(noexcept(x.swap(y)));
 ```
 *Constraints:* `is_move_constructible_v<T>` is `true` and
 `is_swappable_v<T>` is `true`.
 template<class T> struct hash<optional<T>>;
 ```
 The specialization `hash<optional<T>>` is enabled [[unord.hash]] if and
 only if `hash<remove_const_t<T>>` is enabled. When enabled, for an
+object `o` of type `optional<T>`, if `o.has_value() == true`, then
 `hash<optional<T>>()(o)` evaluates to the same value as
 `hash<remove_const_t<T>>()(*o)`; otherwise it evaluates to an
 unspecified value. The member functions are not guaranteed to be
 `noexcept`.

Diff to HTML by rtfpessoa