Issue 2756: C++ WP optional<T> should 'forward' T's implicit conversions

This page is a snapshot from the LWG issues list, see the Library Active Issues List for more information and the meaning of C++17 status.

2756. C++ WP `optional<T>` should 'forward' `T`'s implicit conversions

Section: 22.5.3 [optional.optional] Status: C++17 Submitter: Casey Carter Opened: 2016-07-26 Last modified: 2017-07-30

Priority: 1

View all other issues in [optional.optional].

View all issues with C++17 status.

Discussion:

LWG 2451 adds converting constructors and assignment operators to optional. The committee voted to apply it to the Library Fundamentals 2 TS WP in Oulu as part of LWG Motion 3. In both LWG and LEWG discussion of this issue, it was considered to be critical to apply to the specification of optional before shipping C++17 — it was an oversight on the part of LWG that there was no motion brought to apply this resolution to the C++ WP.

LWG 2745 proposes removal of the constexpr specifier from the declarations of the converting constructors from const optional& and optional&& since they are not implementable as constexpr constructors in C++17.

This issue proposes application of the resolution of LWG 2451 as amended by LWG 2745 to the specification of optional in the C++ WP.

[2016-07 — Chicago]

Monday: Priority set to 1; will re-review later in the week

[2016-08-03, Tomasz comments]

Value forwarding constructor (template<typename U> optional(U&&)) is underspecified.

For the following use code:
```
optional<T> o1;
optional<T> o2(o1);
```
The second constructor will invoke value forwarding (U = optional<T>&) constructor (better match) instead of the optional<T> copy constructor, in case if T can be constructed from optional<T>. This happens for any type T that has unconstrained perfect forwarding constructor, especially optional<any>.
The behavior of the construction of the optional<T> ot from optional ou is inconsistent for classes T than can be constructed both from optional and U. There are two possible semantics for such operation:
- unwrapping: if ou is initialized (bool(ou)), initialize contained value of ot from *ou, otherwise make ot uninitialized (!bool(ot))
- value forwarding: initialize contained value of ot from ou, ot is always initialized (bool(ot)).
 With the proposed resolution, construction is preferring value forwarding, while assignment is always using unwrapping.
For example, if we consider following class:
```
struct Widget
{
 Widget(int);
 Widget(optional<int>);
};
```
Notice, that such set of constructor is pretty common in situation when the construction of the Widget from known value is common and usage of optional version is rare. In such situation, presence of Widget(int) construction is an optimization used to avoid unnecessary empty checks and construction optional<int>.
For the following declarations:
```
optional<Widget> w1(make_optional(10));
optional<Widget> w2;
w2 = make_optional(10);
```
The w1 will contain a value created using Widget(optional<int>) constructor, as corresponding unwrapping constructor (optional const&) is eliminated by is_constructible_v<T, const optional&> (is_constructible_v<Widget, const optional<int>&>) having a true value. In contrast w2 will contain a value created using Widget(int) constructor, as corresponding value forwarding assignment (U&&) is eliminated by the fact that std::decay_t (optional<int>) is specialization of optional.
In addition, the construction is having a preference for value forwarding and assignment is always using unwrapping. That means that for the following class:
```
struct Thingy
{
 Thingy(optional<string>);
};

optional<Thingy> t1(optional<string>("test"));
```
The t1 has a contained value constructed from using Thingy(optional<std::string>), as unwrapping constructor (optional const&) are eliminated by the is_constructible<T, U const&> (is_constructible<Thingy, std::string const&>) being false. However the following:
```
t1 = optional<std::string>("test2");
```
will not compile, because, the value forwarding assignment (U&&) is eliminated by std::decay_t (optional<std::string>) being optional specialization and the unwrapping assignment (optional const&) is ill-formed because is_constructible<T, U const&> (is_constructible<Thingy, std::string const&>) is false.
The semantics of construction and assignment, of optional<optional<V>> from optional where U is convertible to/ same as T is also inconsistent. Firstly, in this situation the optional<V> is a type that can be constructed both from optional and U so it fails into set of problem described above. However in addition we have following non-template constructor in optional<T>:
```
optional(T const&);
```
Which for optional<optional<V>> is equivalent to:
```
optional(optional<V> const&);
```
While there is no corresponding non-template assignment from T const&, to make sure that o = {}; always clear an optional o.
So for the following declarations:
```
optional<int> oi;
optional<short> os;

optional<optional<int>> ooi1(oi);
optional<optional<int>> ooi2(os);
```
The ooi1 uses from-T constructor, while ooi2 uses value forwarding constructor. In this case both ooi1 and ooi2 are initialized and their contained values *ooi1, *ooi2 are uninitialized optionals. However, if we will attempt to make construction consistent with assignment, by preferring unwrapping (optional const&), then ooi2 will end up being uninitialized.
In summary, I believe that relation between unwrapping, value forwarding and from-T construction/assignment is to subtle to being handled as defect report and requires a full paper analyzing possible design and their pros/cons.

Tuesday PM: Ville and Eric to implement and report back in Issaquah. Moved to Open

Ville notes that 2746, 2754 and 2756 all go together.

Previous resolution [SUPERSEDED]:

This wording is relative to N4606.
Modify 22.5.3 [optional.optional] as indicated:
template <class T> class optional
{
public:
 using value_type = T;
 
 // 20.6.3.1, Constructors
 constexpr optional() noexcept;
 constexpr optional(nullopt_t) noexcept;
 optional(const optional &);
 optional(optional &&) noexcept(see below);
 constexpr optional(const T &);
 constexpr optional(T &&);
 template <class... Args> constexpr explicit optional(in_place_t, Args &&...);
 template <class U, class... Args>
 constexpr explicit optional(in_place_t, initializer_list, Args &&...);
 template <class U> constexpr optional(U &&);
 template <class U> optional(const optional &);
 template <class U> optional(optional &&);
 
 […]
 
 // 20.6.3.3, Assignment
 optional &operator=(nullopt_t) noexcept;
 optional &operator=(const optional &);
 optional &operator=(optional &&) noexcept(see below);
 template <class U> optional &operator=(U &&);
 template <class U> optional& operator=(const optional &);
 template <class U> optional& operator=(optional &&);
 template <class... Args> void emplace(Args &&...);
 template <class U, class... Args>
 void emplace(initializer_list, Args &&...);

 […]
 
};
In [optional.object.ctor], insert new signature specifications after p31:
[Note: 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]
template <class U>
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(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 and U is not the same type as T. The constructor is explicit if and only if is_convertible_v<U&&, T> is false.
template <class U>
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 not participate in overload resolution unless is_constructible_v<T, const U&> is true, is_same<decay_t, T> is false, is_constructible_v<T, const optional&> is false and is_convertible_v<const optional&, T> is false. The constructor is explicit if and only if is_convertible_v<const U&, T> is false.
template <class U>
optional(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 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_same<decay_t, T> is false, is_constructible_v<T, optional&&> is false and is_convertible_v<optional&&, T> is false and U is not the same type as T. The constructor is explicit if and only if is_convertible_v<U&&, T> is false.
In [optional.object.assign], change as indicated:
template <class U> optional<T>& operator=(U&& v);
-22- 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. The function shall not participate in overload resolution unless decay_t is not nullopt_t and decay_t is not a specialization of optional~~is_same_v<decay_t, T> is true~~.
~~-23- Notes: The reason for providing such generic assignment and then constraining it so that effectively T == U is to guarantee that assignment of the form o = {} is unambiguous.~~
template <class U> optional<T>& operator=(const optional& rhs);
-?- Requires: is_constructible_v<T, const U&> is true and is_assignable_v<T&, const U&> is true.
-?- Effects:

Table ? — optional::operator=(const optional&) effects
*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. The function shall not participate in overload resolution unless is_same_v<decay_t, T> is false.
template <class U> optional<T>& operator=(optional&& rhs);
-?- Requires: is_constructible_v<T, U> is true and is_assignable_v<T&, U> is true.
-?- Effects: The result of the expression bool(rhs) remains unchanged.

Table ? — optional::operator=(optional&&) effects
*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. The function shall not participate in overload resolution unless is_same_v<decay_t, T> is false.

Table ? — `optional::operator=(const optional<U>&)` effects
	*`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

Table ? — `optional::operator=(optional<U>&&)` effects
	*`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

[2016-08-05 Chicago LWG]

Ville provides revised wording, that also fixes LWG 2753.

Rationale:

The resolution of LWG 2753 makes special member functions defined as deleted in case the desired constraints aren't met.
There is no decay for the converting constructor optional(U&&), there is a remove_reference instead. The target type may hold a cv-qualified type, and the incoming type may hold a cv-qualified type, but neither can hold a reference. Thus, remove_reference is what we need, remove_cv would be wrong, and decay would be wrong.
There is no decay or remove_reference for converting constructors like optional(optional), because none is needed.
For optional(U&&), an added constraint is that U is not a specialization of optional

[2016-08, Chicago]

Fri PM: Move to Tentatively Ready

Previous resolution [SUPERSEDED]:

This wording is relative to N4606.
Modify 22.5.3 [optional.optional] as indicated:
template <class T> class optional
{
public:
 using value_type = T;
 
 // 20.6.3.1, Constructors
 constexpr optional() noexcept;
 constexpr optional(nullopt_t) noexcept;
 optional(const optional &);
 optional(optional &&) noexcept(see below);
 constexpr optional(const T &);
 constexpr optional(T &&);
 template <class... Args> constexpr explicit optional(in_place_t, Args &&...);
 template <class U, class... Args>
 constexpr explicit optional(in_place_t, initializer_list, Args &&...);
 template <class U> EXPLICIT constexpr optional(U &&);
 template <class U> EXPLICIT optional(const optional &);
 template <class U> EXPLICIT optional(optional &&);
 
 […]
 
 // 20.6.3.3, Assignment
 optional &operator=(nullopt_t) noexcept;
 optional &operator=(const optional &);
 optional &operator=(optional &&) noexcept(see below);
 template <class U> optional &operator=(U &&);
 template <class U> optional& operator=(const optional &);
 template <class U> optional& operator=(optional &&);
 template <class... Args> void emplace(Args &&...);
 template <class U, class... Args>
 void emplace(initializer_list, Args &&...);

 […]
 
};
Change [optional.object.ctor] as indicated:
optional(const optional<T>& rhs);
~~-3- Requires: is_copy_constructible_v<T> is true.~~
[…]
-?- Remarks: This constructor shall be defined as deleted unless is_copy_constructible_v<T> is true.
optional(optional<T>&& rhs) noexcept(see below);
~~-7- Requires: is_move_constructible_v<T> is true.~~
[…]
-11- Remarks: The expression inside noexcept is equivalent to is_nothrow_move_constructible_v<T>. This constructor shall be defined as deleted unless is_move_constructible_v<T> is true.
constexpr optional(const T& v);
~~-12- Requires: is_copy_constructible_v<T> is true.~~
[…]
-16- 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_copy_constructible_v<T> is true.
constexpr optional(T&& v);
~~-17- Requires: is_move_constructible_v<T> is true.~~
[…]
-21- 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_move_constructible_v<T> is true.
template <class... Args> constexpr explicit optional(in_place_t, Args&&... args);
~~-22- Requires: is_constructible_v<T, Args&&...> is true.~~
[…]
-26- 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.
template <class U, class... Args>
 constexpr explicit optional(in_place_t, initializer_list il, Args&&... args);
~~-27- Requires: is_constructible_v<T, initializer_list&, Args&&...> is true.~~
[…]
-31- Remarks: The ~~function~~constructor shall not participate in overload resolution unless is_constructible_v<T, initializer_list&, Args&&...> is true. If T's constructor selected for the initialization is a constexpr constructor, this constructor shall be a constexpr constructor.

[Note: 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]
template <class U>
 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(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, remove_reference_t is not the same type as T, and U is not a specialization of optional. The constructor is explicit if and only if is_convertible_v<U&&, T> is false.
template <class U>
 EXPLICIT 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 not participate in overload resolution unless is_constructible_v<T, const U&> is true and is_same_v<U, T> is false. The constructor is explicit if and only if is_convertible_v<const U&, T> is false.
template <class U>
 EXPLICIT optional(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 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 and is_same_v<U, T> is false. The constructor is explicit if and only if is_convertible_v<U&&, T> is false.
Change [optional.object.assign] as indicated:
optional<T>& operator=(const optional<T>& rhs);
~~-4- Requires: is_copy_constructible_v<T> is true and is_copy_assignable_v<T> is true.~~
[…]
-8- 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.
optional<T>& operator=(optional<T>&& rhs) noexcept(see below);
~~-9- Requires: is_move_constructible_v<T> is true and is_move_assignable_v<T> is true.~~
[…]
-13- Remarks: The expression inside noexcept is equivalent to:
is_nothrow_move_assignable_v<T> && is_nothrow_move_constructible_v<T>
-14- 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 be defined as deleted unless is_move_constructible_v<T> is true and is_move_assignable_v<T> is true.
template <class U> optional<T>& operator=(U&& v);
~~-15- Requires: is_constructible_v<T, U> is true and is_assignable_v<T&, U> is true.~~
[…]
-19- 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. ~~The~~This function shall not participate in overload resolution unless ~~is_same_v<decay_t, T>~~ decay_t is not nullopt_t, decay_t is not a specialization of optional, is_constructible_v<T, U> is true and is_assignable_v<T&, U> is true.
~~-20- Notes: The reason for providing such generic assignment and then constraining it so that effectively T == U is to guarantee that assignment of the form o = {} is unambiguous.~~
template <class U> optional<T>& operator=(const optional& rhs);
-?- Effects:

Table ? — optional::operator=(const optional&) effects
*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. The function shall not participate in overload resolution unless is_constructible_v<T, const U&> is true and is_assignable_v<T&, const U&> is true and is_same_v<U, T> is false.
template <class U> optional<T>& operator=(optional&& rhs);
-?- Effects: The result of the expression bool(rhs) remains unchanged.

Table ? — optional::operator=(optional&&) effects
*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. The function shall not participate in overload resolution unless is_constructible_v<T, U> is true and is_assignable_v<T&, U> is true and is_same_v<U, T> is false.

Table ? — `optional::operator=(const optional<U>&)` effects
	*`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

Table ? — `optional::operator=(optional<U>&&)` effects
	*`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

[2016-08-08 Ville reopens and provides improved wording]

This alternative proposed wording also resolves 2753.

The constructors that take a const T& or T&& are replaced by a constructor template that takes a U&& and defaults U = T. This allows copy-list-initialization with empty braces to still work:

optional<whatever> o = {}; // equivalent to initializing optional with nullopt

This resolution makes converting constructors and assignments have the same capabilities, including using arguments that can't be deduced. That is achieved by using a perfect-forwarding constructor and an assignment operator that default their argument to T. We don't need separate overloads for T, the overload for U does the job:

optional<vector<int>> ovi{{1, 2, 3}}; // still works
ovi = {4, 5, 6, 7}; // now works, didn't work before

Furthermore, this proposed wording makes optional "always unwrap". That is, the result of the following initializations is the same:

optional<optional<int>> oi = optional<int>();
optional<optional<int>> oi = optional<short>();

Both of those initializations initialize the optional wrapping another optional as if initializing with nullopt. Assignments do the same. These changes solve the issues pointed out by Tomasz Kamiński.

This P/R has been implemented and tested as a modification on top of libstdc++'s optional.

[2016-08-08 Ville and Tomasz collaborate and improve wording]

The suggested wording retains optional's converting constructors and assignment operators, but provides sane results for the types Tomasz Kaminski depicts in previous discussions.

As opposed to the current P/R of this issue, which does "always unwrap", this P/R does "always value-forward unless the incoming type is exactly a type that a special member function takes by reference, and don't unwrap if a value-forwarder can take an optional by any kind of reference".

I and Tomasz believe this is the best compromise between the different desires, and thus the best outcome so far.

This P/R has been implemented and tested on libstdc++.

[2016-09-08 Casey Carter finetunes existing resolution for move members]

[2016-09-09 Issues Resolution Telecon]

Move to Tentatively Ready

[2016-10-06 Ville Voutilainen finetunes the resolution for assignment from scalars]

Previous resolution [SUPERSEDED]:

This wording is relative to N4606.
Modify 22.5.3 [optional.optional] as indicated:
template <class T> class optional
{
public:
 using value_type = T;
 
 // 20.6.3.1, Constructors
 constexpr optional() noexcept;
 constexpr optional(nullopt_t) noexcept;
 optional(const optional &);
 optional(optional &&) noexcept(see below);
 constexpr optional(const T &);
 constexpr optional(T &&);
 template <class... Args> constexpr explicit optional(in_place_t, Args &&...);
 template <class U, class... Args>
 constexpr explicit optional(in_place_t, initializer_list, Args &&...);
 template <class U = T> EXPLICIT constexpr optional(U &&);
 template <class U> EXPLICIT optional(const optional &);
 template <class U> EXPLICIT optional(optional &&);
 
 […]
 
 // 20.6.3.3, 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 &);
 template <class U> optional& operator=(optional &&);
 template <class... Args> void emplace(Args &&...);
 template <class U, class... Args>
 void emplace(initializer_list, Args &&...);

 […]
 
};
Change [optional.object.ctor] as indicated:
optional(const optional<T>& rhs);
~~-3- Requires: is_copy_constructible_v<T> is true.~~
[…]
-?- Remarks: This constructor shall be defined as deleted unless is_copy_constructible_v<T> is true.
optional(optional<T>&& rhs) noexcept(see below);
~~-7- Requires: is_move_constructible_v<T> is true.~~
[…]
-11- 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.
constexpr optional(const T& v);
~~-12- Requires: is_copy_constructible_v<T> is true.~~
~~-13- Effects: Initializes the contained value as if direct-non-list-initializing an object of type T with the expression v.~~
~~-14- Postcondition: *this contains a value.~~
~~-15- Throws: Any exception thrown by the selected constructor of T.~~
~~-16- Remarks: If T's selected constructor is a constexpr constructor, this constructor shall be a constexpr constructor.~~
constexpr optional(T&& v);
~~-17- Requires: is_move_constructible_v<T> is true.~~
~~-18- Effects: Initializes the contained value as if direct-non-list-initializing an object of type T with the expression std::move(v).~~
~~-19- Postcondition: *this contains a value.~~
~~-20- Throws: Any exception thrown by the selected constructor of T.~~
~~-21- Remarks: If T's selected constructor is a constexpr constructor, this constructor shall be a constexpr constructor.~~
template <class... Args> constexpr explicit optional(in_place_t, Args&&... args);
~~-22- Requires: is_constructible_v<T, Args&&...> is true.~~
[…]
-26- 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.
template <class U, class... Args>
 constexpr explicit optional(in_place_t, initializer_list il, Args&&... args);
~~-27- Requires: is_constructible_v<T, initializer_list&, Args&&...> is true.~~
[…]
-31- Remarks: ~~The function~~This constructor shall not participate in overload resolution unless is_constructible_v<T, initializer_list&, Args&&...> is true. If T's constructor selected for the initialization is a constexpr constructor, this constructor shall be a constexpr constructor.

[Note: 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]
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(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<U, in_place_t> is false, and is_same_v<optional<T>, decay_t> is false. The constructor is explicit if and only if is_convertible_v<U&&, T> is false.
template <class U>
 EXPLICIT 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 not participate in overload resolution unless is_constructible_v<T, const U&> is true, is_constructible_v<T, optional&> is false, is_constructible_v<T, const optional&> is false, is_constructible_v<T, const optional&&> is false, is_constructible_v<T, optional&&> is false, is_convertible_v<optional&, T> is false, is_convertible_v<const optional&, T> is false, is_convertible_v<const optional&&, T> is false, and is_convertible_v<optional&&, T> is false. The constructor is explicit if and only if is_convertible_v<const U&, T> is false.
template <class U>
 EXPLICIT optional(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 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&> is false, is_constructible_v<T, const optional&> is false, is_constructible_v<T, const optional&&> is false, is_constructible_v<T, optional&&> is false, is_convertible_v<optional&, T> is false, is_convertible_v<const optional&, T> is false, is_convertible_v<const optional&&, T> is false, and is_convertible_v<optional&&, T> is false. The constructor is explicit if and only if is_convertible_v<U&&, T> is false.
Change [optional.object.assign] as indicated:
optional<T>& operator=(const optional<T>& rhs);
~~-4- Requires: is_copy_constructible_v<T> is true and is_copy_assignable_v<T> is true.~~
[…]
-8- 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.
optional<T>& operator=(optional<T>&& rhs) noexcept(see below);
~~-9- Requires: is_move_constructible_v<T> is true and is_move_assignable_v<T> is true.~~
[…]
-13- Remarks: The expression inside noexcept is equivalent to:
is_nothrow_move_assignable_v<T> && is_nothrow_move_constructible_v<T>
-14- 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.
template <class U = T> optional<T>& operator=(U&& v);
~~-15- Requires: is_constructible_v<T, U> is true and is_assignable_v<T&, U> is true.~~
[…]
-19- 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. ~~The~~This function shall not participate in overload resolution unless ~~is_same_v<decay_t, T>~~ is_same_v<optional<T>, decay_t> is false, is_constructible_v<T, U> is true, and is_assignable_v<T&, U> is true.
~~-20- Notes: The reason for providing such generic assignment and then constraining it so that effectively T == U is to guarantee that assignment of the form o = {} is unambiguous.~~
template <class U> optional<T>& operator=(const optional& rhs);
-?- Effects: See Table ?.

Table ? — optional::operator=(const optional&) effects
*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&> is false, is_constructible_v<T, const optional&> is false, is_constructible_v<T, const optional&&> is false, is_constructible_v<T, optional&&> is false, is_convertible_v<optional&, T> is false, is_convertible_v<const optional&, T> is false, is_convertible_v<const optional&&, T> is false, is_convertible_v<optional&&, T> is false, is_assignable_v<T&, optional&> is false, is_assignable_v<T&, const optional&> is false, is_assignable_v<T&, const optional&&> is false, and is_assignable_v<T&, optional&&> is false.
template <class U> optional<T>& operator=(optional&& rhs);
-?- Effects: See Table ?. The result of the expression bool(rhs) remains unchanged.

Table ? — optional::operator=(optional&&) effects
*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&> is false, is_constructible_v<T, const optional&> is false, is_constructible_v<T, const optional&&> is false, is_constructible_v<T, optional&&> is false, is_convertible_v<optional&, T> is false, is_convertible_v<const optional&, T> is false, is_convertible<const optional&&, T> is false, is_convertible<optional&&, T> is false, is_assignable_v<T&, optional&> is false, is_assignable_v<T&, const optional&> is false, is_assignable_v<T&, const optional&&> is false, and is_assignable_v<T&, optional&&> is false.

Table ? — `optional::operator=(const optional<U>&)` effects
	*`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

Table ? — `optional::operator=(optional<U>&&)` effects
	*`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

Proposed resolution:

This wording is relative to N4606.

Modify 22.5.3 [optional.optional] as indicated:

template <class T> class optional
{
public:
  using value_type = T;
  
  // 20.6.3.1, Constructors
  constexpr optional() noexcept;
  constexpr optional(nullopt_t) noexcept;
  optional(const optional &);
  optional(optional &&) noexcept(see below);
  constexpr optional(const T &);
  constexpr optional(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> &&);
  
  […]
  
  // 20.6.3.3, 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> void emplace(Args &&...);
  template <class U, class... Args>
    void emplace(initializer_list<U>, Args &&...);

  […]
  
};

Change [optional.object.ctor] as indicated:
```
optional(const optional<T>& rhs);
```
~~-3- Requires: is_copy_constructible_v<T> is true.~~
[…]
-?- Remarks: This constructor shall be defined as deleted unless is_copy_constructible_v<T> is true.
```
optional(optional<T>&& rhs) noexcept(see below);
```
~~-7- Requires: is_move_constructible_v<T> is true.~~
[…]
-11- 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.
```
constexpr optional(const T& v);
```
~~-12- Requires: is_copy_constructible_v<T> is true.~~
~~-13- Effects: Initializes the contained value as if direct-non-list-initializing an object of type T with the expression v.~~
~~-14- Postcondition: *this contains a value.~~
~~-15- Throws: Any exception thrown by the selected constructor of T.~~
~~-16- Remarks: If T's selected constructor is a constexpr constructor, this constructor shall be a constexpr constructor.~~
```
constexpr optional(T&& v);
```
~~-17- Requires: is_move_constructible_v<T> is true.~~
~~-18- Effects: Initializes the contained value as if direct-non-list-initializing an object of type T with the expression std::move(v).~~
~~-19- Postcondition: *this contains a value.~~
~~-20- Throws: Any exception thrown by the selected constructor of T.~~
~~-21- Remarks: If T's selected constructor is a constexpr constructor, this constructor shall be a constexpr constructor.~~
```
template <class... Args> constexpr explicit optional(in_place_t, Args&&... args);
```
~~-22- Requires: is_constructible_v<T, Args&&...> is true.~~
[…]
-26- 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.
```
template <class U, class... Args>
 constexpr explicit optional(in_place_t, initializer_list il, Args&&... args);
```
~~-27- Requires: is_constructible_v<T, initializer_list&, Args&&...> is true.~~
[…]
-31- Remarks: ~~The function~~This constructor shall not participate in overload resolution unless is_constructible_v<T, initializer_list&, Args&&...> is true. If T's constructor selected for the initialization is a constexpr constructor, this constructor shall be a constexpr constructor.

[Note: 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]
```
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(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<U, in_place_t> is false, and is_same_v<optional<T>, decay_t> is false. The constructor is explicit if and only if is_convertible_v<U&&, T> is false.
```
template <class U>
 EXPLICIT 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 not participate in overload resolution unless is_constructible_v<T, const U&> is true, is_constructible_v<T, optional&> is false, is_constructible_v<T, const optional&> is false, is_constructible_v<T, const optional&&> is false, is_constructible_v<T, optional&&> is false, is_convertible_v<optional&, T> is false, is_convertible_v<const optional&, T> is false, is_convertible_v<const optional&&, T> is false, and is_convertible_v<optional&&, T> is false. The constructor is explicit if and only if is_convertible_v<const U&, T> is false.
```
template <class U>
 EXPLICIT optional(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 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&> is false, is_constructible_v<T, const optional&> is false, is_constructible_v<T, const optional&&> is false, is_constructible_v<T, optional&&> is false, is_convertible_v<optional&, T> is false, is_convertible_v<const optional&, T> is false, is_convertible_v<const optional&&, T> is false, and is_convertible_v<optional&&, T> is false. The constructor is explicit if and only if is_convertible_v<U&&, T> is false.

Change [optional.object.assign] as indicated:

optional<T>& operator=(const optional<T>& rhs);
~~-4- Requires: is_copy_constructible_v<T> is true and is_copy_assignable_v<T> is true.~~
[…]
-8- 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.
optional<T>& operator=(optional<T>&& rhs) noexcept(see below);
~~-9- Requires: is_move_constructible_v<T> is true and is_move_assignable_v<T> is true.~~
[…]
-13- Remarks: The expression inside noexcept is equivalent to:
is_nothrow_move_assignable_v<T> && is_nothrow_move_constructible_v<T>
-14- 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.
template <class U = T> optional<T>& operator=(U&& v);
~~-15- Requires: is_constructible_v<T, U> is true and is_assignable_v<T&, U> is true.~~
[…]
-19- 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. ~~The~~This function shall not participate in overload resolution unless ~~is_same_v<decay_t, T>~~ is_same_v<optional<T>, decay_t> is false, conjunction_v<is_scalar<T>, is_same<T, decay_t>> is false, is_constructible_v<T, U> is true, and is_assignable_v<T&, U> is true.
~~-20- Notes: The reason for providing such generic assignment and then constraining it so that effectively T == U is to guarantee that assignment of the form o = {} is unambiguous.~~
template <class U> optional<T>& operator=(const optional& rhs);
-?- Effects: See Table ?.

Table ? — optional::operator=(const optional&) effects
*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&> is false, is_constructible_v<T, const optional&> is false, is_constructible_v<T, const optional&&> is false, is_constructible_v<T, optional&&> is false, is_convertible_v<optional&, T> is false, is_convertible_v<const optional&, T> is false, is_convertible_v<const optional&&, T> is false, is_convertible_v<optional&&, T> is false, is_assignable_v<T&, optional&> is false, is_assignable_v<T&, const optional&> is false, is_assignable_v<T&, const optional&&> is false, and is_assignable_v<T&, optional&&> is false.
template <class U> optional<T>& operator=(optional&& rhs);
-?- Effects: See Table ?. The result of the expression bool(rhs) remains unchanged.

Table ? — optional::operator=(optional&&) effects
*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&> is false, is_constructible_v<T, const optional&> is false, is_constructible_v<T, const optional&&> is false, is_constructible_v<T, optional&&> is false, is_convertible_v<optional&, T> is false, is_convertible_v<const optional&, T> is false, is_convertible<const optional&&, T> is false, is_convertible<optional&&, T> is false, is_assignable_v<T&, optional&> is false, is_assignable_v<T&, const optional&> is false, is_assignable_v<T&, const optional&&> is false, and is_assignable_v<T&, optional&&> is false.

2756. C++ WP optional<T> should 'forward' T's implicit conversions

2756. C++ WP `optional<T>` should 'forward' `T`'s implicit conversions