[optional] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpv8q148a5/{from.md → to.md} +586 -94

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

@@ -1,8 +1,8 @@
 ## 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
@@ -11,16 +11,28 @@ 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;
   template<class T>
     concept is-derived-from-optional = requires(const T& t) {   // exposition only
       []<class U>(const optional<U>&){ }(t);
     };
@@ -75,11 +87,11 @@ namespace std {
   // [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);
   template<class T, class U, class... Args>
     constexpr optional<T> make_optional(initializer_list<U> il, Args&&... args);
@@ -97,21 +109,23 @@ namespace std {
 namespace std {
   template<class T>
   class optional {
   public:
     using value_type     = T;
     // [optional.ctor], constructors
     constexpr optional() noexcept;
     constexpr optional(nullopt_t) noexcept;
     constexpr optional(const optional&);
     constexpr optional(optional&&) noexcept(see below);
     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>
       constexpr explicit(see below) optional(const optional<U>&);
     template<class U>
       constexpr explicit(see below) optional(optional<U>&&);
@@ -121,34 +135,40 @@ namespace std {
     // [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 &;
@@ -170,25 +190,29 @@ namespace std {
   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
-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`.
@@ -233,11 +257,11 @@ 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`.
@@ -279,11 +303,11 @@ template<class U, class... Args>
 *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`,
@@ -339,11 +363,11 @@ template<class U> constexpr explicit(see below) optional(optional<U>&& rhs);
 - `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`.
@@ -423,11 +447,11 @@ constexpr optional& operator=(optional&& rhs) noexcept(see below);
 **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()`.
@@ -449,17 +473,19 @@ 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)`.
@@ -529,11 +555,11 @@ 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()`.
@@ -622,40 +648,75 @@ 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);`
 ``` cpp
 constexpr explicit operator bool() const noexcept;
@@ -694,11 +755,11 @@ constexpr const T&& value() const &&;
 ``` cpp
 return has_value() ? std::move(*val) : throw bad_optional_access();
 ```
 ``` cpp
-template<class U> constexpr T value_or(U&& v) const &;
 ```
 *Mandates:* `is_copy_constructible_v<T> && is_convertible_v<U&&, T>` is
 `true`.
@@ -707,11 +768,11 @@ template<class U> constexpr T value_or(U&& v) const &;
 ``` cpp
 return has_value() ? **this : static_cast<T>(std::forward<U>(v));
 ```
 ``` cpp
-template<class U> constexpr T value_or(U&& v) &&;
 ```
 *Mandates:* `is_move_constructible_v<T> && is_convertible_v<U&&, T>` is
 `true`.
@@ -726,96 +787,96 @@ return has_value() ? std::move(**this) : static_cast<T>(std::forward<U>(v));
 ``` 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`.
@@ -831,11 +892,11 @@ if (*this) {
 ``` 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`.
@@ -858,10 +919,432 @@ constexpr 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);
@@ -881,33 +1364,34 @@ initializer-list constructor, and shall not be an aggregate.
 ``` 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.
 ``` 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 `x.has_value() != y.has_value()`, `false`; otherwise if
 `x.has_value() == false`, `true`; otherwise `*x == *y`.
@@ -917,12 +1401,12 @@ convertible to `bool`.
 ``` 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.has_value() != y.has_value()`, `true`; otherwise, if
 `x.has_value() == false`, `false`; otherwise `*x != *y`.
 *Remarks:* Specializations of this function template for which
@@ -930,11 +1414,11 @@ convertible to `bool`.
 ``` 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`.
@@ -943,11 +1427,11 @@ 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`.
@@ -956,12 +1440,12 @@ 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
@@ -969,12 +1453,12 @@ convertible to `bool`.
 ``` 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
@@ -1010,113 +1494,113 @@ template<class T> constexpr strong_ordering operator<=>(const optional<T>& x, nu
 ``` 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>
@@ -1133,19 +1617,27 @@ template<class T, class U>
 ``` 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`.
 *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, class...Args>
   constexpr optional<T> make_optional(Args&&... args);

 ## Optional objects <a id="optional">[[optional]]</a>
+### 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
 contained object is tracked by the optional object.
 ### Header `<optional>` synopsis <a id="optional.syn">[[optional.syn]]</a>
 ``` cpp
+// mostly freestanding
 #include <compare>              // see [compare.syn]
 namespace std {
   // [optional.optional], class template optional
   template<class T>
+    class optional;                                             // partially freestanding
+  // [optional.optional.ref], partial specialization of optional for lvalue reference types
+  template<class T>
+    class optional<T&>;                                         // partially freestanding
+  template<class T>
+    constexpr bool ranges::enable_view<optional<T>> = true;
+  template<class T>
+    constexpr auto format_kind<optional<T>> = range_format::disabled;
+  template<class T>
+    constexpr bool ranges::enable_borrowed_range<optional<T&>> = true;
   template<class T>
     concept is-derived-from-optional = requires(const T& t) {   // exposition only
       []<class U>(const optional<U>&){ }(t);
     };
   // [optional.specalg], specialized algorithms
   template<class T>
     constexpr void swap(optional<T>&, optional<T>&) noexcept(see below);
   template<class T>
+    constexpr optional<decay_t<T>> make_optional(T&&);
   template<class T, class... Args>
     constexpr optional<T> make_optional(Args&&... args);
   template<class T, class U, class... Args>
     constexpr optional<T> make_optional(initializer_list<U> il, Args&&... args);
 namespace std {
   template<class T>
   class optional {
   public:
     using value_type     = T;
+    using iterator       = implementation-defined;              // see~[optional.iterators]
+    using const_iterator = implementation-defined;              // see~[optional.iterators]
     // [optional.ctor], constructors
     constexpr optional() noexcept;
     constexpr optional(nullopt_t) noexcept;
     constexpr optional(const optional&);
     constexpr optional(optional&&) noexcept(see below);
     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 = remove_cv_t<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.assign], assignment
     constexpr optional& operator=(nullopt_t) noexcept;
     constexpr optional& operator=(const optional&);
     constexpr optional& operator=(optional&&) noexcept(see below);
+    template<class U = remove_cv_t<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.iterators], iterator support
+    constexpr iterator begin() noexcept;
+    constexpr const_iterator begin() const noexcept;
+    constexpr iterator end() noexcept;
+    constexpr const_iterator end() const noexcept;
     // [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 &;                                 // freestanding-deleted
+    constexpr T& value() &;                                             // freestanding-deleted
+    constexpr T&& value() &&;                                           // freestanding-deleted
+    constexpr const T&& value() const &&;                               // freestanding-deleted
+    template<class U = remove_cv_t<T>> constexpr T value_or(U&&) const &;
+    template<class U = remove_cv_t<T>> constexpr T value_or(U&&) &&;
     // [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 T>
     optional(T) -> optional<T>;
 }
 ```
+An object of type `optional<T>` at any given time either contains a
+value or does not contain a value. When an object of type `optional<T>`
+*contains a value*, it means that an object of type `T`, referred to as
+the optional object’s *contained value*, is nested within
+[[intro.object]] the optional object. 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 object of type `optional<T>` contains a value, member `val`
+points to the contained value.
+A type `X` is a *valid contained type* for `optional` if `X` is an
+lvalue reference type or a complete non-array object type, and
+`remove_cvref_t<X>` is a type other than `in_place_t` or `nullopt_t`. If
+a specialization of `optional` is instantiated with a type `T` that is
+not a valid contained type for `optional`, the program is ill-formed. If
+`T` is an object type, `T` shall meet 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`.
 ```
 *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:* If `T`’s constructor selected for the initialization is a
 constexpr constructor, this constructor is a constexpr constructor.
 ``` cpp
+template<class U = remove_cv_t<T>> constexpr explicit(see below) optional(U&& v);
 ```
 *Constraints:*
 - `is_constructible_v<T, U>` is `true`,
 - `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`.
 **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()`.
 `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 = remove_cv_t<T>> constexpr optional& 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)`.
 **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()`.
 `*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.
+#### Iterator support <a id="optional.iterators">[[optional.iterators]]</a>
+``` cpp
+using iterator       = implementation-defined;
+using const_iterator = implementation-defined;
+```
+These types model `contiguous_iterator` [[iterator.concept.contiguous]],
+meet the *Cpp17RandomAccessIterator*
+requirements [[random.access.iterators]], and meet the requirements for
+constexpr iterators [[iterator.requirements.general]], with value type
+`remove_cv_t<T>`. The reference type is `T&` for `iterator` and
+`const T&` for `const_iterator`.
+All requirements on container iterators [[container.reqmts]] apply to
+`optional::iterator` and `optional::const_iterator` as well.
+Any operation that initializes or destroys the contained value of an
+optional object invalidates all iterators into that object.
+``` cpp
+constexpr iterator begin() noexcept;
+constexpr const_iterator begin() const noexcept;
+```
+*Returns:* If `has_value()` is `true`, an iterator referring to the
+contained value. Otherwise, a past-the-end iterator value.
+``` cpp
+constexpr iterator end() noexcept;
+constexpr const_iterator end() const noexcept;
+```
+*Returns:* `begin() + has_value()`.
 #### Observers <a id="optional.observe">[[optional.observe]]</a>
 ``` cpp
 constexpr const T* operator->() const noexcept;
 constexpr T* operator->() noexcept;
 ```
+`has_value()` is `true`.
 *Returns:* `val`.
 *Remarks:* These functions are constexpr functions.
 ``` cpp
 constexpr const T& operator*() const & noexcept;
 constexpr T& operator*() & noexcept;
 ```
+`has_value()` is `true`.
 *Returns:* `*val`.
 *Remarks:* These functions are constexpr functions.
 ``` cpp
 constexpr T&& operator*() && noexcept;
 constexpr const T&& operator*() const && noexcept;
 ```
+`has_value()` is `true`.
 *Effects:* Equivalent to: `return std::move(*val);`
 ``` cpp
 constexpr explicit operator bool() const noexcept;
 ``` cpp
 return has_value() ? std::move(*val) : throw bad_optional_access();
 ```
 ``` cpp
+template<class U = remove_cv_t<T>> constexpr T value_or(U&& v) const &;
 ```
 *Mandates:* `is_copy_constructible_v<T> && is_convertible_v<U&&, T>` is
 `true`.
 ``` cpp
 return has_value() ? **this : static_cast<T>(std::forward<U>(v));
 ```
 ``` cpp
+template<class U = remove_cv_t<T>> constexpr T value_or(U&& v) &&;
 ```
 *Mandates:* `is_move_constructible_v<T> && is_convertible_v<U&&, T>` is
 `true`.
 ``` cpp
 template<class F> constexpr auto and_then(F&& f) &;
 template<class F> constexpr auto and_then(F&& f) const &;
 ```
+Let `U` be `invoke_result_t<F, decltype(*`*`val`*`)>`.
 *Mandates:* `remove_cvref_t<U>` is a specialization of `optional`.
 *Effects:* Equivalent to:
 ``` cpp
 if (*this) {
+  return invoke(std::forward<F>(f), *val);
 } 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(*`*`val`*`))>`.
 *Mandates:* `remove_cvref_t<U>` is a specialization of `optional`.
 *Effects:* Equivalent to:
 ``` cpp
 if (*this) {
+  return invoke(std::forward<F>(f), std::move(*val));
 } 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(*`*`val`*`)>>`.
+*Mandates:* `U` is a valid contained type for `optional`. The
+declaration
 ``` cpp
+U u(invoke(std::forward<F>(f), *val));
 ```
 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), *`*`val`*`)`; 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(*`*`val`*`))>>`.
+*Mandates:* `U` is a valid contained type for `optional`. The
+declaration
 ``` cpp
+U u(invoke(std::forward<F>(f), std::move(*val)));
 ```
 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(*`*`val`*`))`; 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`.
 ``` 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:* If `*this` contains a value, calls `val->T::T̃()` to destroy
 the contained value; otherwise no effect.
 *Ensures:* `*this` does not contain a value.
+### Partial specialization of `optional` for reference types <a id="optional.optional.ref">[[optional.optional.ref]]</a>
+#### General <a id="optional.optional.ref.general">[[optional.optional.ref.general]]</a>
+``` cpp
+namespace std {
+  template<class T>
+  class optional<T&> {
+  public:
+    using value_type     = T;
+    using iterator       = implementation-defined;              // see~[optional.ref.iterators]
+  public:
+    // [optional.ref.ctor], constructors
+    constexpr optional() noexcept = default;
+    constexpr optional(nullopt_t) noexcept : optional() {}
+    constexpr optional(const optional& rhs) noexcept = default;
+    template<class Arg>
+      constexpr explicit optional(in_place_t, Arg&& arg);
+    template<class U>
+      constexpr explicit(see below) optional(U&& u) noexcept(see below);
+    template<class U>
+      constexpr explicit(see below) optional(optional<U>& rhs) noexcept(see below);
+    template<class U>
+      constexpr explicit(see below) optional(const optional<U>& rhs) noexcept(see below);
+    template<class U>
+      constexpr explicit(see below) optional(optional<U>&& rhs) noexcept(see below);
+    template<class U>
+      constexpr explicit(see below) optional(const optional<U>&& rhs) noexcept(see below);
+    constexpr ~optional() = default;
+    // [optional.ref.assign], assignment
+    constexpr optional& operator=(nullopt_t) noexcept;
+    constexpr optional& operator=(const optional& rhs) noexcept = default;
+    template<class U> constexpr T& emplace(U&& u) noexcept(see below);
+    // [optional.ref.swap], swap
+    constexpr void swap(optional& rhs) noexcept;
+    // [optional.ref.iterators], iterator support
+    constexpr iterator begin() const noexcept;
+    constexpr iterator end() const noexcept;
+    // [optional.ref.observe], observers
+    constexpr T*       operator->() const noexcept;
+    constexpr T&       operator*() const noexcept;
+    constexpr explicit operator bool() const noexcept;
+    constexpr bool     has_value() const noexcept;
+    constexpr T&       value() const;                           // freestanding-deleted
+    template<class U = remove_cv_t<T>>
+      constexpr remove_cv_t<T> value_or(U&& u) const;
+    // [optional.ref.monadic], monadic operations
+    template<class F> constexpr auto and_then(F&& f) const;
+    template<class F> constexpr optional<invoke_result_t<F, T&>> transform(F&& f) const;
+    template<class F> constexpr optional or_else(F&& f) const;
+    // [optional.ref.mod], modifiers
+    constexpr void reset() noexcept;
+  private:
+    T* val = nullptr;                                           // exposition only
+    // [optional.ref.expos], exposition only helper functions
+    template<class U>
+      constexpr void convert-ref-init-val(U&& u);               // exposition only
+  };
+}
+```
+An object of type `optional<T&>` *contains a value* if and only if
+`val != nullptr` is `true`. When an `optional<T&>` contains a value, the
+*contained value* is a reference to `*val`.
+#### Constructors <a id="optional.ref.ctor">[[optional.ref.ctor]]</a>
+``` cpp
+template<class Arg>
+  constexpr explicit optional(in_place_t, Arg&& arg);
+```
+*Constraints:*
+- `is_constructible_v<T&, Arg>` is `true`, and
+- `reference_constructs_from_temporary_v<T&, Arg>` is `false`.
+*Effects:* Equivalent to:
+*`convert-ref-init-val`*`(std::forward<Arg>(arg))`.
+*Ensures:* `*this` contains a value.
+``` cpp
+template<class U>
+  constexpr explicit(!is_convertible_v<U, T&>)
+  optional(U&& u) noexcept(is_nothrow_constructible_v<T&, U>);
+```
+*Constraints:*
+- `is_same_v<remove_cvref_t<U>, optional>` is `false`,
+- `is_same_v<remove_cvref_t<U>, in_place_t>` is `false`, and
+- `is_constructible_v<T&, U>` is `true`.
+*Effects:* Equivalent to:
+*`convert-ref-init-val`*`(std::forward<U>(u))`.
+*Ensures:* `*this` contains a value.
+*Remarks:* This constructor is defined as deleted if
+``` cpp
+reference_constructs_from_temporary_v<T&, U>
+```
+is `true`.
+``` cpp
+template<class U>
+  constexpr explicit(!is_convertible_v<U&, T&>)
+  optional(optional<U>& rhs) noexcept(is_nothrow_constructible_v<T&, U&>);
+```
+*Constraints:*
+- `is_same_v<remove_cv_t<T>, optional<U>>` is `false`,
+- `is_same_v<T&, U>` is `false`, and
+- `is_constructible_v<T&, U&>` is `true`.
+*Effects:* Equivalent to:
+``` cpp
+if (rhs.has_value()) convert-ref-init-val(*rhs);
+```
+*Remarks:* This constructor is defined as deleted if
+``` cpp
+reference_constructs_from_temporary_v<T&, U&>
+```
+is `true`.
+``` cpp
+template<class U>
+  constexpr explicit(!is_convertible_v<const U&, T&>)
+  optional(const optional<U>& rhs) noexcept(is_nothrow_constructible_v<T&, const U&>);
+```
+*Constraints:*
+- `is_same_v<remove_cv_t<T>, optional<U>>` is `false`,
+- `is_same_v<T&, U>` is `false`, and
+- `is_constructible_v<T&, const U&>` is `true`.
+*Effects:* Equivalent to:
+``` cpp
+if (rhs.has_value()) convert-ref-init-val(*rhs);
+```
+*Remarks:* This constructor is defined as deleted if
+``` cpp
+reference_constructs_from_temporary_v<T&, const U&>
+```
+is `true`.
+``` cpp
+template<class U>
+  constexpr explicit(!is_convertible_v<U, T&>)
+  optional(optional<U>&& rhs) noexcept(is_nothrow_constructible_v<T&, U>);
+```
+*Constraints:*
+- `is_same_v<remove_cv_t<T>, optional<U>>` is `false`,
+- `is_same_v<T&, U>` is `false`, and
+- `is_constructible_v<T&, U>` is `true`.
+*Effects:* Equivalent to:
+``` cpp
+if (rhs.has_value()) convert-ref-init-val(*std::move(rhs));
+```
+*Remarks:* This constructor is defined as deleted if
+``` cpp
+reference_constructs_from_temporary_v<T&, U>
+```
+is `true`.
+``` cpp
+template<class U>
+  constexpr explicit(!is_convertible_v<const U, T&>)
+  optional(const optional<U>&& rhs) noexcept(is_nothrow_constructible_v<T&, const U>);
+```
+*Constraints:*
+- `is_same_v<remove_cv_t<T>, optional<U>>` is `false`,
+- `is_same_v<T&, U>` is `false`, and
+- `is_constructible_v<T&, const U>` is `true`.
+*Effects:* Equivalent to:
+``` cpp
+if (rhs.has_value()) convert-ref-init-val(*std::move(rhs));
+```
+*Remarks:* This constructor is defined as deleted if
+``` cpp
+reference_constructs_from_temporary_v<T&, const U>
+```
+is `true`.
+#### Assignment <a id="optional.ref.assign">[[optional.ref.assign]]</a>
+``` cpp
+constexpr optional& operator=(nullopt_t) noexcept;
+```
+*Effects:* Assigns `nullptr` to *val*.
+*Ensures:* `*this` does not contain a value.
+*Returns:* `*this`.
+``` cpp
+template<class U>
+  constexpr T& emplace(U&& u) noexcept(is_nothrow_constructible_v<T&, U>);
+```
+*Constraints:*
+- `is_constructible_v<T&, U>` is `true`, and
+- `reference_constructs_from_temporary_v<T&, U>` is `false`.
+*Effects:* Equivalent to:
+*`convert-ref-init-val`*`(std::forward<U>(u))`.
+*Returns:* `*`*`val`*.
+#### Swap <a id="optional.ref.swap">[[optional.ref.swap]]</a>
+``` cpp
+constexpr void swap(optional& rhs) noexcept;
+```
+*Effects:* Equivalent to: `swap(`*`val`*`, rhs.`*`val`*`)`.
+#### Iterator support <a id="optional.ref.iterators">[[optional.ref.iterators]]</a>
+``` cpp
+using iterator = implementation-defined;
+```
+This type models `contiguous_iterator` [[iterator.concept.contiguous]],
+meets the *Cpp17RandomAccessIterator*
+requirements [[random.access.iterators]], and meets the requirements for
+constexpr iterators [[iterator.requirements.general]], with value type
+`remove_cv_t<T>`. The reference type is `T&` for `iterator`.
+All requirements on container iterators [[container.reqmts]] apply to
+`optional::iterator`.
+``` cpp
+constexpr iterator begin() const noexcept;
+```
+*Returns:* If `has_value()` is `true`, an iterator referring to
+`*`*`val`*. Otherwise, a past-the-end iterator value.
+``` cpp
+constexpr iterator end() const noexcept;
+```
+*Returns:* `begin() + has_value()`.
+#### Observers <a id="optional.ref.observe">[[optional.ref.observe]]</a>
+``` cpp
+constexpr T* operator->() const noexcept;
+```
+`has_value()` is `true`.
+*Returns:* *val*.
+``` cpp
+constexpr T& operator*() const noexcept;
+```
+`has_value()` is `true`.
+*Returns:* `*`*`val`*.
+``` cpp
+constexpr explicit operator bool() const noexcept;
+```
+*Returns:* *`val`*` != nullptr`.
+``` cpp
+constexpr bool has_value() const noexcept;
+```
+*Returns:* *`val`*` != nullptr`.
+``` cpp
+constexpr T& value() const;
+```
+*Effects:* Equivalent to:
+``` cpp
+return has_value() ? *val : throw bad_optional_access();
+```
+``` cpp
+template<class U = remove_cv_t<T>> constexpr remove_cv_t<T> value_or(U&& u) const;
+```
+Let `X` be `remove_cv_t<T>`.
+*Mandates:* `is_constructible_v<X, T&> && is_convertible_v<U, X>` is
+`true`.
+*Effects:* Equivalent to:
+``` cpp
+return has_value() ? *val : static_cast<X>(std::forward<U>(u));
+```
+#### Monadic operations <a id="optional.ref.monadic">[[optional.ref.monadic]]</a>
+``` cpp
+template<class F> constexpr auto and_then(F&& f) const;
+```
+Let `U` be `invoke_result_t<F, T&>`.
+*Mandates:* `remove_cvref_t<U>` is a specialization of `optional`.
+*Effects:* Equivalent to:
+``` cpp
+if (has_value()) {
+  return invoke(std::forward<F>(f), *val);
+} else {
+  return remove_cvref_t<U>();
+}
+```
+``` cpp
+template<class F>
+  constexpr optional<remove_cv_t<invoke_result_t<F, T&>>> transform(F&& f) const;
+```
+Let `U` be `remove_cv_t<invoke_result_t<F, T&>>`.
+*Mandates:* The declaration
+``` cpp
+U u(invoke(std::forward<F>(f), *val));
+```
+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), *`*`val`*`)`; otherwise, `optional<U>()`.
+``` cpp
+template<class F> constexpr optional or_else(F&& f) const;
+```
+*Constraints:* `F` models `invocable`.
+*Mandates:* `is_same_v<remove_cvref_t<invoke_result_t<F>>, optional>` is
+`true`.
+*Effects:* Equivalent to:
+``` cpp
+if (has_value()) {
+  return *val;
+} else {
+  return std::forward<F>(f)();
+}
+```
+#### Modifiers <a id="optional.ref.mod">[[optional.ref.mod]]</a>
+``` cpp
+constexpr void reset() noexcept;
+```
+*Effects:* Assigns `nullptr` to *val*.
+*Ensures:* `*this` does not contain a value.
+#### Exposition only helper functions <a id="optional.ref.expos">[[optional.ref.expos]]</a>
+``` cpp
+template<class U>
+  constexpr void convert-ref-init-val(U&& u);  // exposition only
+```
+*Effects:* Creates a variable `r` as if by `T& r(std::forward<U>(u));`
+and then initializes *val* with `addressof(r)`.
 ### No-value state indicator <a id="optional.nullopt">[[optional.nullopt]]</a>
 ``` cpp
 struct nullopt_t{see below};
 inline constexpr nullopt_t nullopt(unspecified);
 ``` cpp
 namespace std {
   class bad_optional_access : public exception {
   public:
     // see [exception] for the specification of the special member functions
+ constexpr 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
+constexpr const char* what() const noexcept override;
 ```
+*Returns:* An *implementation-defined* NTBS, which during constant
+evaluation is encoded with the ordinary literal encoding [[lex.ccon]].
 ### 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);
 ```
+*Constraints:* 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`.
 ``` cpp
 template<class T, class U> constexpr bool operator!=(const optional<T>& x, const optional<U>& y);
 ```
+*Constraints:* 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
 ``` cpp
 template<class T, class U> constexpr bool operator<(const optional<T>& x, const optional<U>& y);
 ```
+*Constraints:* `*x < *y` is well-formed and its result is convertible to
 `bool`.
 *Returns:* If `!y`, `false`; otherwise, if `!x`, `true`; otherwise
 `*x < *y`.
 ``` cpp
 template<class T, class U> constexpr bool operator>(const optional<T>& x, const optional<U>& y);
 ```
+*Constraints:* 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`.
 ``` cpp
 template<class T, class U> constexpr bool operator<=(const optional<T>& x, const optional<U>& y);
 ```
+*Constraints:* 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
 ``` cpp
 template<class T, class U> constexpr bool operator>=(const optional<T>& x, const optional<U>& y);
 ```
+*Constraints:* 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
 ``` cpp
 template<class T, class U> constexpr bool operator==(const optional<T>& x, const U& v);
 ```
+*Constraints:* `U` is not a specialization of `optional`. 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);
 ```
+*Constraints:* `T` is not a specialization of `optional`. 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);
 ```
+*Constraints:* `U` is not a specialization of `optional`. 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);
 ```
+*Constraints:* `T` is not a specialization of `optional`. 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);
 ```
+*Constraints:* `U` is not a specialization of `optional`. 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);
 ```
+*Constraints:* `T` is not a specialization of `optional`. 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);
 ```
+*Constraints:* `U` is not a specialization of `optional`. 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);
 ```
+*Constraints:* `T` is not a specialization of `optional`. 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);
 ```
+*Constraints:* `U` is not a specialization of `optional`. 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);
 ```
+*Constraints:* `T` is not a specialization of `optional`. 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);
 ```
+*Constraints:* `U` is not a specialization of `optional`. 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);
 ```
+*Constraints:* `T` is not a specialization of `optional`. 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>
 ``` cpp
 template<class T>
   constexpr void swap(optional<T>& x, optional<T>& y) noexcept(noexcept(x.swap(y)));
 ```
+*Constraints:*
+``` cpp
+is_reference_v<T> || (is_move_constructible_v<T> && is_swappable_v<T>)
+```
+is `true`.
 *Effects:* Calls `x.swap(y)`.
 ``` cpp
 template<class T> constexpr optional<decay_t<T>> make_optional(T&& v);
 ```
+*Constraints:* The call to `make_optional` does not use an explicit
+*template-argument-list* that begins with a type *template-argument*.
 *Returns:* `optional<decay_t<T>>(std::forward<T>(v))`.
 ``` cpp
 template<class T, class...Args>
   constexpr optional<T> make_optional(Args&&... args);

Diff to HTML by rtfpessoa