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

Files changed (1) hide show

tmp/tmpj_8xh13b/{from.md → to.md} +308 -329

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

@@ -1,20 +1,22 @@
 ## Optional objects <a id="optional">[[optional]]</a>
 ### In general <a id="optional.general">[[optional.general]]</a>
-This subclause describes class template `optional` that represents
-optional objects. An *optional object* is an object that contains the
-storage for another object and manages the lifetime of this contained
-object, if any. The contained object may be initialized after the
-optional object has been initialized, and may be destroyed before the
-optional object has been destroyed. The initialization state of the
 contained object is tracked by the optional object.
 ### Header `<optional>` synopsis <a id="optional.syn">[[optional.syn]]</a>
 ``` cpp
 namespace std {
   // [optional.optional], class template optional
   template<class T>
     class optional;
@@ -36,38 +38,35 @@ namespace std {
     constexpr bool operator>(const optional<T>&, const optional<U>&);
   template<class T, class U>
     constexpr bool operator<=(const optional<T>&, const optional<U>&);
   template<class T, class U>
     constexpr bool operator>=(const optional<T>&, const optional<U>&);
   // [optional.nullops], comparison with nullopt
   template<class T> constexpr bool operator==(const optional<T>&, nullopt_t) noexcept;
-  template <class T> constexpr bool operator==(nullopt_t, const optional<T>&) noexcept;
-  template <class T> constexpr bool operator!=(const optional<T>&, nullopt_t) noexcept;
-  template <class T> constexpr bool operator!=(nullopt_t, const optional<T>&) noexcept;
-  template <class T> constexpr bool operator<(const optional<T>&, nullopt_t) noexcept;
-  template <class T> constexpr bool operator<(nullopt_t, const optional<T>&) noexcept;
-  template <class T> constexpr bool operator<=(const optional<T>&, nullopt_t) noexcept;
-  template <class T> constexpr bool operator<=(nullopt_t, const optional<T>&) noexcept;
-  template <class T> constexpr bool operator>(const optional<T>&, nullopt_t) noexcept;
-  template <class T> constexpr bool operator>(nullopt_t, const optional<T>&) noexcept;
-  template <class T> constexpr bool operator>=(const optional<T>&, nullopt_t) noexcept;
-  template <class T> constexpr bool operator>=(nullopt_t, const optional<T>&) noexcept;
-  // [optional.comp_with_t], comparison with T
   template<class T, class U> constexpr bool operator==(const optional<T>&, const U&);
-  template <class T, class U> constexpr bool operator==(const U&, const optional<T>&);
   template<class T, class U> constexpr bool operator!=(const optional<T>&, const U&);
-  template <class T, class U> constexpr bool operator!=(const U&, const optional<T>&);
   template<class T, class U> constexpr bool operator<(const optional<T>&, const U&);
-  template <class T, class U> constexpr bool operator<(const U&, const optional<T>&);
-  template <class T, class U> constexpr bool operator<=(const optional<T>&, const U&);
-  template <class T, class U> constexpr bool operator<=(const U&, const optional<T>&);
   template<class T, class U> constexpr bool operator>(const optional<T>&, const U&);
-  template <class T, class U> constexpr bool operator>(const U&, const optional<T>&);
   template<class T, class U> constexpr bool operator>=(const optional<T>&, const U&);
-  template <class T, class U> constexpr bool operator>=(const U&, const optional<T>&);
   // [optional.specalg], specialized algorithms
   template<class T>
     void swap(optional<T>&, optional<T>&) noexcept(see below);
@@ -82,17 +81,14 @@ namespace std {
   template<class T> struct hash;
   template<class T> struct hash<optional<T>>;
 }
 ```
-A program that necessitates the instantiation of template `optional` for
-a reference type, or for possibly cv-qualified types `in_place_t` or
-`nullopt_t` is ill-formed.
 ### Class template `optional` <a id="optional.optional">[[optional.optional]]</a>
 ``` cpp
   template<class T>
   class optional {
   public:
     using value_type = T;
@@ -104,23 +100,23 @@ template <class T>
     template<class... Args>
       constexpr explicit optional(in_place_t, Args&&...);
     template<class U, class... Args>
       constexpr explicit optional(in_place_t, initializer_list<U>, Args&&...);
     template<class U = T>
- \EXPLICIT constexpr optional(U&&);
     template<class U>
- \EXPLICIT optional(const optional<U>&);
     template<class U>
- \EXPLICIT optional(optional<U>&&);
     // [optional.dtor], destructor
     ~optional();
     // [optional.assign], assignment
     optional& operator=(nullopt_t) noexcept;
-    optional& operator=(const optional&);
-    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&&...);
@@ -149,11 +145,13 @@ template <class T>
   private:
     T *val;         // exposition only
   };
-template<class T> optional(T) -> optional<T>;
 ```
 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
@@ -167,135 +165,126 @@ 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 an object type and shall satisfy the requirements of
-`Destructible` (Table  [[tab:destructible]]).
 #### Constructors <a id="optional.ctor">[[optional.ctor]]</a>
 ``` cpp
 constexpr optional() noexcept;
 constexpr optional(nullopt_t) noexcept;
 ```
-*Postconditions:* `*this` does not contain a value.
 *Remarks:* No contained value is initialized. For every object type `T`
-these constructors shall be 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`.
-*Postconditions:* `bool(rhs) == bool(*this)`.
 *Throws:* Any exception thrown by the selected constructor of `T`.
-*Remarks:* This constructor shall be defined as deleted unless
 `is_copy_constructible_v<T>` is `true`. If
-`is_trivially_copy_constructible_v<T>` is `true`, this constructor shall
-be a `constexpr` constructor.
 ``` cpp
 constexpr optional(optional&& rhs) noexcept(see below);
 ```
 *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.
-*Postconditions:* `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>`. This constructor shall not
-participate in overload resolution unless `is_move_constructible_v<T>`
-is `true`. If `is_trivially_move_constructible_v<T>` is `true`, this
-constructor shall be a `constexpr` constructor.
 ``` cpp
 template<class... Args> constexpr explicit optional(in_place_t, Args&&... args);
 ```
 *Effects:* Initializes the contained value as if
 direct-non-list-initializing an object of type `T` with the arguments
 `std::forward<Args>(args)...`.
-*Postconditions:* `*this` contains a value.
 *Throws:* Any exception thrown by the selected constructor of `T`.
 *Remarks:* If `T`’s constructor selected for the initialization is a
-constexpr constructor, this constructor shall be a constexpr
-constructor. This constructor shall not participate in overload
-resolution unless `is_constructible_v<T, Args...>` is `true`.
 ``` cpp
 template<class U, class... Args>
   constexpr explicit optional(in_place_t, initializer_list<U> il, Args&&... args);
 ```
 *Effects:* Initializes the contained value as if
 direct-non-list-initializing an object of type `T` with the arguments
 `il, std::forward<Args>(args)...`.
-*Postconditions:* `*this` contains a value.
 *Throws:* Any exception thrown by the selected constructor of `T`.
-*Remarks:* This constructor shall not participate in overload resolution
-unless `is_constructible_v<T, initializer_list<U>&, Args&&...>` is
-`true`. If `T`’s constructor selected for the initialization is a
-constexpr constructor, this constructor shall be a constexpr
-constructor.
-[*Note 1*: The following constructors are conditionally specified as
-explicit. This is typically implemented by declaring two such
-constructors, of which at most one participates in overload
-resolution. — *end note*]
 ``` cpp
-template <class U = T> \EXPLICIT constexpr optional(U&& v);
 ```
 *Effects:* Initializes the contained value as if
 direct-non-list-initializing an object of type `T` with the expression
 `std::forward<U>(v)`.
-*Postconditions:* `*this` contains a value.
 *Throws:* Any exception thrown by the selected constructor of `T`.
 *Remarks:* If `T`’s selected constructor is a constexpr constructor,
-this constructor shall be a constexpr constructor. This constructor
-shall not participate in overload resolution unless
-`is_constructible_v<T, U&&>` is `true`,
-`is_same_v<decay_t<U>, in_place_t>` is `false`, and
-`is_same_v<optional<T>, decay_t<U>>` is `false`. The constructor is
-explicit if and only if `is_convertible_v<U&&, T>` is `false`.
 ``` cpp
-template <class U> \EXPLICIT optional(const optional<U>& 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`.
-*Postconditions:* `bool(rhs)` == `bool(*this)`.
-*Throws:* Any exception thrown by the selected constructor of `T`.
-*Remarks:* This constructor shall not participate in overload resolution
-unless
 - `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`,
@@ -303,40 +292,53 @@ unless
 - `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`.
-The constructor is explicit if and only if
-`is_convertible_v<const U&, T>` is `false`.
 ``` cpp
-template <class U> \EXPLICIT optional(optional<U>&& 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 `std::move(*rhs)`. `bool(rhs)` is unchanged.
-*Postconditions:* `bool(rhs)` == `bool(*this)`.
 *Throws:* Any exception thrown by the selected constructor of `T`.
-*Remarks:* This constructor shall not participate in overload resolution
-unless
-- `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`.
-The constructor is explicit if and only if `is_convertible_v<U&&, T>` is
-`false`.
 #### Destructor <a id="optional.dtor">[[optional.dtor]]</a>
 ``` cpp
 ~optional();
@@ -347,72 +349,77 @@ contains a value, calls
 ``` cpp
 val->T::~T()
 ```
-*Remarks:* If `is_trivially_destructible_v<T> == true` then this
-destructor shall be a trivial destructor.
 #### 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.
-*Returns:* `*this`.
-*Postconditions:* `*this` does not contain a value.
 ``` cpp
-optional<T>& operator=(const optional& rhs);
 ```
-*Effects:* See Table  [[tab:optional.assign.copy]].
-**Table: `optional::operator=(const optional&)` effects** <a id="tab:optional.assign.copy">[tab: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                                                                                            |
-*Returns:* `*this`.
-*Postconditions:* `bool(rhs) == bool(*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 shall be defined as deleted unless
 `is_copy_constructible_v<T>` is `true` and `is_copy_assignable_v<T>` is
-`true`.
 ``` cpp
-optional<T>& operator=(optional&& rhs) noexcept(see below);
 ```
-*Effects:* See Table  [[tab:optional.assign.move]]. The result of the
-expression `bool(rhs)` remains unchanged.
-**Table: `optional::operator=(optional&&)` effects** <a id="tab:optional.assign.move">[tab: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                                                                                                       |
 *Returns:* `*this`.
-*Postconditions:* `bool(rhs) == bool(*this)`.
 *Remarks:* The expression inside `noexcept` is equivalent to:
 ``` cpp
 is_nothrow_move_assignable_v<T> && is_nothrow_move_constructible_v<T>
 ```
@@ -421,65 +428,44 @@ 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. This operator shall not participate in overload resolution
-unless `is_move_constructible_v<T>` is `true` and
-`is_move_assignable_v<T>` is `true`.
 ``` cpp
 template<class U = T> optional<T>& operator=(U&& v);
 ```
 *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)`.
-*Returns:* `*this`.
-*Postconditions:* `*this` contains a value.
 *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.
-This function shall not participate in overload resolution unless
-`is_same_v<optional<T>, decay_t<U>>` 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`.
 ``` cpp
 template<class U> optional<T>& operator=(const optional<U>& rhs);
 ```
-*Effects:* See Table  [[tab:optional.assign.copy.templ]].
-**Table: `optional::operator=(const optional<U>&)` effects** <a id="tab:optional.assign.copy.templ">[tab: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                                                                                            |
-*Returns:* `*this`.
-*Postconditions:* `bool(rhs) == bool(*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. This function shall not participate in overload resolution
-unless
 - `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`,
@@ -492,37 +478,37 @@ unless
 - `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`.
 ``` cpp
 template<class U> optional<T>& operator=(optional<U>&& rhs);
 ```
-*Effects:* See Table  [[tab:optional.assign.move.templ]]. The result of
-the expression `bool(rhs)` remains unchanged.
-**Table: `optional::operator=(optional<U>&&)` effects** <a id="tab:optional.assign.move.templ">[tab: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                                                                                                       |
-*Returns:* `*this`.
-*Postconditions:* `bool(rhs) == bool(*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. This function shall not participate in overload resolution
-unless
 - `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`,
@@ -535,21 +521,44 @@ unless
 - `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`.
 ``` cpp
 template<class... Args> T& emplace(Args&&... args);
 ```
-*Requires:* `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)...`.
-*Postconditions:* `*this` contains a value.
 *Returns:* A reference to the new contained value.
 *Throws:* Any exception thrown by the selected constructor of `T`.
@@ -559,47 +568,49 @@ constructor, `*this` does not contain a value, and the previous `*val`
 ``` cpp
 template<class U, class... Args> T& emplace(initializer_list<U> il, Args&&... args);
 ```
 *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)...`.
-*Postconditions:* `*this` contains a value.
 *Returns:* A reference to the new contained value.
 *Throws:* Any exception thrown by the selected constructor of `T`.
 *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. This function shall not participate in
-overload resolution unless
-`is_constructible_v<T, initializer_list<U>&, Args&&...>` is `true`.
 #### Swap <a id="optional.swap">[[optional.swap]]</a>
 ``` cpp
 void swap(optional& rhs) noexcept(see below);
 ```
-*Requires:* Lvalues of type `T` shall be swappable and
-`is_move_constructible_v<T>` is `true`.
-*Effects:* See Table  [[tab:optional.swap]].
-**Table: `optional::swap(optional&)` effects** <a id="tab:optional.swap">[tab: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 Table  [[tab:optional.swap]].
 *Remarks:* The expression inside `noexcept` is equivalent to:
 ``` cpp
 is_nothrow_move_constructible_v<T> && is_nothrow_swappable_v<T>
@@ -618,55 +629,55 @@ exception safety guarantee of `T`’s move constructor.
 ``` cpp
 constexpr const T* operator->() const;
 constexpr T* operator->();
 ```
-*Requires:* `*this` contains a value.
 *Returns:* `val`.
 *Throws:* Nothing.
-*Remarks:* These functions shall be constexpr functions.
 ``` cpp
 constexpr const T& operator*() const&;
 constexpr T& operator*() &;
 ```
-*Requires:* `*this` contains a value.
 *Returns:* `*val`.
 *Throws:* Nothing.
-*Remarks:* These functions shall be constexpr functions.
 ``` cpp
 constexpr T&& operator*() &&;
 constexpr const T&& operator*() const&&;
 ```
-*Requires:* `*this` contains a value.
 *Effects:* Equivalent to: `return std::move(*val);`
 ``` cpp
 constexpr explicit operator bool() const noexcept;
 ```
 *Returns:* `true` if and only if `*this` contains a value.
-*Remarks:* This function shall be a constexpr function.
 ``` cpp
 constexpr bool has_value() const noexcept;
 ```
 *Returns:* `true` if and only if `*this` contains a value.
-*Remarks:* This function shall be a constexpr function.
 ``` cpp
 constexpr const T& value() const&;
 constexpr T& value() &;
 ```
@@ -690,350 +701,318 @@ return bool(*this) ? std::move(*val) : throw bad_optional_access();
 ``` cpp
 template<class U> constexpr T value_or(U&& v) const&;
 ```
 *Effects:* Equivalent to:
 ``` cpp
 return bool(*this) ? **this : static_cast<T>(std::forward<U>(v));
 ```
-*Remarks:* If `is_copy_constructible_v<T> && is_convertible_v<U&&, T>`
-is `false`, the program is ill-formed.
 ``` cpp
 template<class U> constexpr T value_or(U&& v) &&;
 ```
 *Effects:* Equivalent to:
 ``` cpp
 return bool(*this) ? std::move(**this) : static_cast<T>(std::forward<U>(v));
 ```
-*Remarks:* If `is_move_constructible_v<T> && is_convertible_v<U&&, T>`
-is `false`, the program is ill-formed.
 #### 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.
-*Postconditions:* `*this` does not contain a value.
 ### No-value state indicator <a id="optional.nullopt">[[optional.nullopt]]</a>
 ``` cpp
 struct nullopt_t{see below};
 inline constexpr nullopt_t nullopt(unspecified);
 ```
-The struct `nullopt_t` is an empty structure type used as a unique type
-to indicate the state of not containing a value for `optional` objects.
-In particular, `optional<T>` has a constructor with `nullopt_t` as a
-single argument; this indicates that an optional object not containing a
-value shall be constructed.
 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:
- bad_optional_access();
 };
 ```
 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.
 ``` cpp
-bad_optional_access();
 ```
-*Effects:* Constructs an object of class `bad_optional_access`.
-*Postconditions:* `what()` returns an *implementation-defined* NTBS.
 ### Relational operators <a id="optional.relops">[[optional.relops]]</a>
 ``` cpp
 template<class T, class U> constexpr bool operator==(const optional<T>& x, const optional<U>& y);
 ```
-*Requires:* The expression `*x == *y` shall be well-formed and its
-result shall be convertible to `bool`.
-[*Note 1*: `T` need not be `EqualityComparable`. — *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 shall be constexpr functions.
 ``` cpp
 template<class T, class U> constexpr bool operator!=(const optional<T>& x, const optional<U>& y);
 ```
-*Requires:* The expression `*x != *y` shall be well-formed and its
-result shall be 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 shall be constexpr functions.
 ``` cpp
 template<class T, class U> constexpr bool operator<(const optional<T>& x, const optional<U>& y);
 ```
-*Requires:* `*x < *y` shall be well-formed and its result shall be
-convertible to `bool`.
 *Returns:* If `!y`, `false`; otherwise, if `!x`, `true`; otherwise
 `*x < *y`.
 *Remarks:* Specializations of this function template for which `*x < *y`
-is a core constant expression shall be constexpr functions.
 ``` cpp
 template<class T, class U> constexpr bool operator>(const optional<T>& x, const optional<U>& y);
 ```
-*Requires:* The expression `*x > *y` shall be well-formed and its result
-shall be convertible to `bool`.
 *Returns:* If `!x`, `false`; otherwise, if `!y`, `true`; otherwise
 `*x > *y`.
 *Remarks:* Specializations of this function template for which `*x > *y`
-is a core constant expression shall be constexpr functions.
 ``` cpp
 template<class T, class U> constexpr bool operator<=(const optional<T>& x, const optional<U>& y);
 ```
-*Requires:* The expression `*x <= *y` shall be well-formed and its
-result shall be convertible to `bool`.
 *Returns:* If `!x`, `true`; otherwise, if `!y`, `false`; otherwise
 `*x <= *y`.
 *Remarks:* Specializations of this function template for which
-`*x <= *y` is a core constant expression shall be constexpr functions.
 ``` cpp
 template<class T, class U> constexpr bool operator>=(const optional<T>& x, const optional<U>& y);
 ```
-*Requires:* The expression `*x >= *y` shall be well-formed and its
-result shall be convertible to `bool`.
 *Returns:* If `!y`, `true`; otherwise, if `!x`, `false`; otherwise
 `*x >= *y`.
 *Remarks:* Specializations of this function template for which
-`*x >= *y` is a core constant expression shall be constexpr functions.
 ### Comparison with `nullopt` <a id="optional.nullops">[[optional.nullops]]</a>
 ``` cpp
 template<class T> constexpr bool operator==(const optional<T>& x, nullopt_t) noexcept;
-template <class T> constexpr bool operator==(nullopt_t, const optional<T>& x) noexcept;
 ```
 *Returns:* `!x`.
 ``` cpp
-template <class T> constexpr bool operator!=(const optional<T>& x, nullopt_t) noexcept;
-template <class T> constexpr bool operator!=(nullopt_t, const optional<T>& x) noexcept;
 ```
-*Returns:* `bool(x)`.
-``` cpp
-template <class T> constexpr bool operator<(const optional<T>& x, nullopt_t) noexcept;
-```
-*Returns:* `false`.
-``` cpp
-template <class T> constexpr bool operator<(nullopt_t, const optional<T>& x) noexcept;
-```
-*Returns:* `bool(x)`.
-``` cpp
-template <class T> constexpr bool operator<=(const optional<T>& x, nullopt_t) noexcept;
-```
-*Returns:* `!x`.
-``` cpp
-template <class T> constexpr bool operator<=(nullopt_t, const optional<T>& x) noexcept;
-```
-*Returns:* `true`.
-``` cpp
-template <class T> constexpr bool operator>(const optional<T>& x, nullopt_t) noexcept;
-```
-*Returns:* `bool(x)`.
-``` cpp
-template <class T> constexpr bool operator>(nullopt_t, const optional<T>& x) noexcept;
-```
-*Returns:* `false`.
-``` cpp
-template <class T> constexpr bool operator>=(const optional<T>& x, nullopt_t) noexcept;
-```
-*Returns:* `true`.
-``` cpp
-template <class T> constexpr bool operator>=(nullopt_t, const optional<T>& x) noexcept;
-```
-*Returns:* `!x`.
-### 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);
 ```
-*Requires:* The expression `*x == v` shall be well-formed and its result
-shall be convertible to `bool`.
-[*Note 1*: `T` need not be `EqualityComparable`. — *end note*]
 *Effects:* Equivalent to: `return bool(x) ? *x == v : false;`
 ``` cpp
-template <class T, class U> constexpr bool operator==(const U& v, const optional<T>& x);
 ```
-*Requires:* The expression `v == *x` shall be well-formed and its result
-shall be 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);
 ```
-*Requires:* The expression `*x != v` shall be well-formed and its result
-shall be convertible to `bool`.
 *Effects:* Equivalent to: `return bool(x) ? *x != v : true;`
 ``` cpp
-template <class T, class U> constexpr bool operator!=(const U& v, const optional<T>& x);
 ```
-*Requires:* The expression `v != *x` shall be well-formed and its result
-shall be 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);
 ```
-*Requires:* The expression `*x < v` shall be well-formed and its result
-shall be convertible to `bool`.
 *Effects:* Equivalent to: `return bool(x) ? *x < v : true;`
 ``` cpp
-template <class T, class U> constexpr bool operator<(const U& v, const optional<T>& x);
 ```
-*Requires:* The expression `v < *x` shall be well-formed and its result
-shall be 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);
-```
-*Requires:* The expression `*x <= v` shall be well-formed and its result
-shall be convertible to `bool`.
-*Effects:* Equivalent to: `return bool(x) ? *x <= v : true;`
-``` cpp
-template <class T, class U> constexpr bool operator<=(const U& v, const optional<T>& x);
-```
-*Requires:* The expression `v <= *x` shall be well-formed and its result
-shall be 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);
 ```
-*Requires:* The expression `*x > v` shall be well-formed and its result
-shall be convertible to `bool`.
 *Effects:* Equivalent to: `return bool(x) ? *x > v : false;`
 ``` cpp
-template <class T, class U> constexpr bool operator>(const U& v, const optional<T>& x);
 ```
-*Requires:* The expression `v > *x` shall be well-formed and its result
-shall be 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);
 ```
-*Requires:* The expression `*x >= v` shall be well-formed and its result
-shall be convertible to `bool`.
 *Effects:* Equivalent to: `return bool(x) ? *x >= v : false;`
 ``` cpp
-template <class T, class U> constexpr bool operator>=(const U& v, const optional<T>& x);
 ```
-*Requires:* The expression `v >= *x` shall be well-formed and its result
-shall be convertible to `bool`.
 *Effects:* Equivalent to: `return bool(x) ? v >= *x : true;`
 ### 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)));
 ```
 *Effects:* Calls `x.swap(y)`.
-*Remarks:* This function shall not participate in overload resolution
-unless `is_move_constructible_v<T>` is `true` and `is_swappable_v<T>` is
-`true`.
 ``` cpp
 template<class T> constexpr optional<decay_t<T>> make_optional(T&& v);
 ```
 *Returns:* `optional<decay_t<T>>(std::forward<T>(v))`.
@@ -1058,13 +1037,13 @@ template <class T, class U, class... Args>
 ``` cpp
 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)` shall evaluate 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`.

 ## Optional objects <a id="optional">[[optional]]</a>
 ### In general <a id="optional.general">[[optional.general]]</a>
+Subclause  [[optional]] describes class template `optional` that
+represents optional objects. An *optional object* is an object that
+contains the storage for another object and manages the lifetime of this
+contained object, if any. The contained object may be initialized after
+the optional object has been initialized, and may be destroyed before
+the optional object has been destroyed. The initialization state of the
 contained object is tracked by the optional object.
 ### Header `<optional>` synopsis <a id="optional.syn">[[optional.syn]]</a>
 ``` cpp
+#include <compare>              // see [compare.syn]
 namespace std {
   // [optional.optional], class template optional
   template<class T>
     class optional;
     constexpr bool operator>(const optional<T>&, const optional<U>&);
   template<class T, class U>
     constexpr bool operator<=(const optional<T>&, const optional<U>&);
   template<class T, class U>
     constexpr bool operator>=(const optional<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 optional<U>&);
   // [optional.nullops], comparison with nullopt
   template<class T> constexpr bool operator==(const optional<T>&, nullopt_t) noexcept;
+  template<class T>
+ constexpr strong_ordering operator<=>(const optional<T>&, nullopt_t) noexcept;
+  // [optional.comp.with.t], comparison with T
   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> 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> 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> struct hash;
   template<class T> struct hash<optional<T>>;
 }
 ```
 ### Class template `optional` <a id="optional.optional">[[optional.optional]]</a>
 ``` cpp
+namespace std {
   template<class T>
   class optional {
   public:
     using value_type = T;
     template<class... Args>
       constexpr explicit optional(in_place_t, Args&&...);
     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&&...);
   private:
     T *val;         // exposition only
   };
+ template<class T>
+    optional(T) -> optional<T>;
+}
 ```
 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
 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;
 ```
+*Ensures:* `*this` does not contain a value.
 *Remarks:* No contained value is initialized. For every object type `T`
+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
+`is_trivially_copy_constructible_v<T>` is `true`, this constructor is
+trivial.
 ``` cpp
 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`.
 *Remarks:* If `T`’s constructor selected for the initialization is a
+constexpr constructor, this constructor is a constexpr constructor.
 ``` cpp
 template<class U, class... Args>
   constexpr explicit optional(in_place_t, initializer_list<U> il, Args&&... 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`.
+*Remarks:* If `T`’s constructor selected for the initialization is a
+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`.
 *Remarks:* If `T`’s selected constructor is a constexpr constructor,
+this constructor is a constexpr constructor. The expression inside
+`explicit` is equivalent to:
 ``` 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_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:
+``` cpp
+!is_convertible_v<U, T>
+```
 #### Destructor <a id="optional.dtor">[[optional.dtor]]</a>
 ``` cpp
 ~optional();
 ``` cpp
 val->T::~T()
 ```
+*Remarks:* If `is_trivially_destructible_v<T>` is `true`, then this
+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.
+*Ensures:* `*this` does not contain a value.
+*Returns:* `*this`.
 ``` cpp
+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> &&`
+`is_trivially_copy_assignable_v<T> &&` `is_trivially_destructible_v<T>`
+is `true`, this assignment operator is trivial.
 ``` cpp
+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>
 ```
 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_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_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.
 *Throws:* Any exception thrown by the selected constructor of `T`.
 ``` 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.
 *Throws:* Any exception thrown by the selected constructor of `T`.
 *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.
 #### 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>
 ``` 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);`
 ``` cpp
 constexpr explicit operator bool() const noexcept;
 ```
 *Returns:* `true` if and only if `*this` contains a value.
+*Remarks:* This function is a constexpr function.
 ``` cpp
 constexpr bool has_value() const noexcept;
 ```
 *Returns:* `true` if and only if `*this` contains a value.
+*Remarks:* This function is a constexpr function.
 ``` cpp
 constexpr const T& value() const&;
 constexpr T& value() &;
 ```
 ``` cpp
 template<class U> constexpr T value_or(U&& v) const&;
 ```
+*Mandates:* `is_copy_constructible_v<T> && is_convertible_v<U&&, T>` is
+`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) &&;
 ```
+*Mandates:* `is_move_constructible_v<T> && is_convertible_v<U&&, T>` is
+`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.
+*Ensures:* `*this` does not contain a value.
 ### No-value state indicator <a id="optional.nullopt">[[optional.nullopt]]</a>
 ``` cpp
 struct nullopt_t{see below};
 inline constexpr nullopt_t nullopt(unspecified);
 ```
+The struct `nullopt_t` is an empty class type used as a unique type to
+indicate the state of not containing a value for `optional` objects. In
+particular, `optional<T>` has a constructor with `nullopt_t` as a single
+argument; this indicates that an optional object not containing a value
+shall be constructed.
 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.
 ``` cpp
+const char* what() const noexcept override;
 ```
+*Returns:* An *implementation-defined* NTBS.
 ### Relational operators <a id="optional.relops">[[optional.relops]]</a>
 ``` cpp
 template<class T, class U> constexpr bool operator==(const optional<T>& x, const optional<U>& y);
 ```
+*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
 template<class T, class U> constexpr bool operator!=(const optional<T>& x, const optional<U>& y);
 ```
+*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
 template<class T, class U> constexpr bool operator<(const optional<T>& x, const optional<U>& y);
 ```
+*Mandates:* `*x < *y` is well-formed and its result is convertible to
+`bool`.
 *Returns:* If `!y`, `false`; otherwise, if `!x`, `true`; 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, class U> constexpr bool operator>(const optional<T>& x, const optional<U>& y);
 ```
+*Mandates:* The expression `*x > *y` is well-formed and its result is
+convertible to `bool`.
 *Returns:* If `!x`, `false`; otherwise, if `!y`, `true`; 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, class U> constexpr bool operator<=(const optional<T>& x, const optional<U>& y);
 ```
+*Mandates:* The expression `*x <= *y` is well-formed and its result is
+convertible to `bool`.
 *Returns:* If `!x`, `true`; otherwise, if `!y`, `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, class U> constexpr bool operator>=(const optional<T>& x, const optional<U>& y);
 ```
+*Mandates:* The expression `*x >= *y` is well-formed and its result is
+convertible to `bool`.
 *Returns:* If `!y`, `true`; otherwise, if `!x`, `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 `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>
 ``` cpp
 template<class T> constexpr bool operator==(const optional<T>& x, nullopt_t) noexcept;
 ```
 *Returns:* `!x`.
 ``` 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);
 ```
+*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`.
 *Effects:* Calls `x.swap(y)`.
 ``` cpp
 template<class T> constexpr optional<decay_t<T>> make_optional(T&& v);
 ```
 *Returns:* `optional<decay_t<T>>(std::forward<T>(v))`.
 ``` cpp
 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`.

Diff to HTML by rtfpessoa