depish/cppdraft_translate
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
main
cppdraft_translate/cppdraft/optional.md
Leonov Artur (Depish) 043225d523 Init
2025-10-25 03:02:53 +03:00

2473 lines
95 KiB
Markdown
Raw Permalink Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

[optional]
# 22 General utilities library [[utilities]](./#utilities)
## 22.5 Optional objects [optional]
### [22.5.1](#general) General [[optional.general]](optional.general)
[1](#general-1)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3169)
Subclause [optional] describes class template optional that represents
optional objects[.](#general-1.sentence-1)
An [*optional object*](#def:optional_object "22.5.1 General [optional.general]") is an
object that contains the storage for another object and manages the lifetime of
this contained object, if any[.](#general-1.sentence-2)
The contained object may be initialized after
the optional object has been initialized, and may be destroyed before the
optional object has been destroyed[.](#general-1.sentence-3)
The initialization state of the contained
object is tracked by the optional object[.](#general-1.sentence-4)
### [22.5.2](#syn) Header <optional> synopsis [[optional.syn]](optional.syn)
[🔗](#header:%3coptional%3e)
// mostly freestanding#include <compare> // see [[compare.syn]](compare.syn "17.12.1 Header <compare> synopsis")namespace std {// [[optional.optional]](#optional "22.5.3 Class template optional"), class template optionaltemplate<class T>class optional; // partially freestanding// [[optional.optional.ref]](#optional.ref "22.5.4 Partial specialization of optional for reference types"), partial specialization of optional for lvalue reference typestemplate<class T>class optional<T&>; // partially freestandingtemplate<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*](#concept:is-derived-from-optional "22.5.2 Header <optional> synopsis [optional.syn]") = requires(const T& t) { // *exposition only*[]<class U>(const optional<U>&){ }(t); }; // [[optional.nullopt]](#nullopt "22.5.5 No-value state indicator"), no-value state indicatorstruct nullopt_t{*see below*}; inline constexpr nullopt_t nullopt(*unspecified*); // [[optional.bad.access]](#bad.access "22.5.6 Class bad_­optional_­access"), class bad_optional_accessclass bad_optional_access; // [[optional.relops]](#relops "22.5.7 Relational operators"), relational operatorstemplate<class T, class U>constexpr bool operator==(const optional<T>&, const optional<U>&); template<class T, class U>constexpr bool operator!=(const optional<T>&, const optional<U>&); template<class T, class U>constexpr bool operator<(const optional<T>&, const optional<U>&); template<class T, class U>constexpr bool operator>(const optional<T>&, const optional<U>&); template<class T, class U>constexpr bool operator<=(const optional<T>&, const optional<U>&); template<class T, class U>constexpr bool operator>=(const optional<T>&, const optional<U>&); template<class T, [three_way_comparable_with](cmp.concept#concept:three_way_comparable_with "17.12.4 Concept three_­way_­comparable [cmp.concept]")<T> U>constexpr compare_three_way_result_t<T, U>operator<=>(const optional<T>&, const optional<U>&); // [[optional.nullops]](#nullops "22.5.8 Comparison with nullopt"), comparison with nullopttemplate<class T> constexpr bool operator==(const optional<T>&, nullopt_t) noexcept; template<class T>constexpr strong_ordering operator<=>(const optional<T>&, nullopt_t) noexcept; // [[optional.comp.with.t]](#comp.with.t "22.5.9 Comparison with T"), comparison with Ttemplate<class T, class U> constexpr bool operator==(const optional<T>&, const U&); template<class T, class U> constexpr bool operator==(const T&, const optional<U>&); template<class T, class U> constexpr bool operator!=(const optional<T>&, const U&); template<class T, class U> constexpr bool operator!=(const T&, const optional<U>&); template<class T, class U> constexpr bool operator<(const optional<T>&, const U&); template<class T, class U> constexpr bool operator<(const T&, const optional<U>&); template<class T, class U> constexpr bool operator>(const optional<T>&, const U&); template<class T, class U> constexpr bool operator>(const T&, const optional<U>&); template<class T, class U> constexpr bool operator<=(const optional<T>&, const U&); template<class T, class U> constexpr bool operator<=(const T&, const optional<U>&); template<class T, class U> constexpr bool operator>=(const optional<T>&, const U&); template<class T, class U> constexpr bool operator>=(const T&, const optional<U>&); template<class T, class U>requires (![*is-derived-from-optional*](#concept:is-derived-from-optional "22.5.2 Header <optional> synopsis [optional.syn]")<U>) && [three_way_comparable_with](cmp.concept#concept:three_way_comparable_with "17.12.4 Concept three_­way_­comparable [cmp.concept]")<T, U>constexpr compare_three_way_result_t<T, U>operator<=>(const optional<T>&, const U&); // [[optional.specalg]](#specalg "22.5.10 Specialized algorithms"), specialized algorithmstemplate<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); // [[optional.hash]](#hash "22.5.11 Hash support"), hash supporttemplate<class T> struct hash; template<class T> struct hash<optional<T>>;}
### [22.5.3](#optional) Class template optional [[optional.optional]](optional.optional)
#### [22.5.3.1](#optional.general) General [[optional.optional.general]](optional.optional.general)
[🔗](#lib:optional)
namespace std {template<class T>class optional {public:using value_type = T; using iterator = *implementation-defined*; // see [[optional.iterators]](#iterators "22.5.3.6 Iterator support")using const_iterator = *implementation-defined*; // see [[optional.iterators]](#iterators "22.5.3.6 Iterator support")// [[optional.ctor]](#ctor "22.5.3.2 Constructors"), constructorsconstexpr 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.dtor]](#dtor "22.5.3.3 Destructor"), destructorconstexpr ~optional(); // [[optional.assign]](#assign "22.5.3.4 Assignment"), assignmentconstexpr 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 "22.5.3.5 Swap"), swapconstexpr void swap(optional&) noexcept(*see below*); // [[optional.iterators]](#iterators "22.5.3.6 Iterator support"), iterator supportconstexpr iterator begin() noexcept; constexpr const_iterator begin() const noexcept; constexpr iterator end() noexcept; constexpr const_iterator end() const noexcept; // [[optional.observe]](#observe "22.5.3.7 Observers"), observersconstexpr 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-deletedconstexpr T& value() &; // freestanding-deletedconstexpr T&& value() &&; // freestanding-deletedconstexpr const T&& value() const &&; // freestanding-deletedtemplate<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 "22.5.3.8 Monadic operations"), monadic operationstemplate<class F> constexpr auto and_then(F&& f) &; template<class F> constexpr auto and_then(F&& f) &&; template<class F> constexpr auto and_then(F&& f) const &; template<class F> constexpr auto and_then(F&& f) const &&; template<class F> constexpr auto transform(F&& f) &; template<class F> constexpr auto transform(F&& f) &&; template<class F> constexpr auto transform(F&& f) const &; template<class F> constexpr auto transform(F&& f) const &&; template<class F> constexpr optional or_else(F&& f) &&; template<class F> constexpr optional or_else(F&& f) const &; // [[optional.mod]](#mod "22.5.3.9 Modifiers"), modifiersconstexpr void reset() noexcept; private: T* *val*; // *exposition only*}; template<class T> optional(T) -> optional<T>;}
[1](#optional.general-1)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3364)
Any instance of optional<T> at any given time either contains a value or does not contain a value[.](#optional.general-1.sentence-1)
When an instance of optional<T> [*contains a value*](#def:contains_a_value,optional "22.5.3.1 General [optional.optional.general]"),
it means that an object of type T, referred to as the optional object's [*contained value*](#def:contained_value,optional "22.5.3.1 General [optional.optional.general]"),
is nested within ([[intro.object]](intro.object "6.8.2 Object model")) the optional object[.](#optional.general-1.sentence-2)
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[.](#optional.general-1.sentence-3)
[2](#optional.general-2)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3373)
When an optional<T> object contains a value,
member val points to the contained value[.](#optional.general-2.sentence-1)
[3](#optional.general-3)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3377)
A type X is a[*valid contained type*](#def:valid_contained_type,optional "22.5.3.1 General [optional.optional.general]") 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[.](#optional.general-3.sentence-1)
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[.](#optional.general-3.sentence-2)
If T is an object type,T shall meet the *Cpp17Destructible* requirements (Table [35](utility.arg.requirements#tab:cpp17.destructible "Table 35: Cpp17Destructible requirements"))[.](#optional.general-3.sentence-3)
#### [22.5.3.2](#ctor) Constructors [[optional.ctor]](optional.ctor)
[1](#ctor-1)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3389)
The exposition-only variable template *converts-from-any-cvref* is used by some constructors for optional[.](#ctor-1.sentence-1)
template<class T, class W>constexpr bool *converts-from-any-cvref* = // *exposition only* disjunction_v<is_constructible<T, W&>, is_convertible<W&, T>,
is_constructible<T, W>, is_convertible<W, T>,
is_constructible<T, const W&>, is_convertible<const W&, T>,
is_constructible<T, const W>, is_convertible<const W, T>>;
[🔗](#lib:optional,constructor)
`constexpr optional() noexcept;
constexpr optional(nullopt_t) noexcept;
`
[2](#ctor-2)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3408)
*Postconditions*: *this does not contain a value[.](#ctor-2.sentence-1)
[3](#ctor-3)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3412)
*Remarks*: No contained value is initialized[.](#ctor-3.sentence-1)
For every object type T these constructors are constexpr constructors ([[dcl.constexpr]](dcl.constexpr "9.2.6 The constexpr and consteval specifiers"))[.](#ctor-3.sentence-2)
[🔗](#lib:optional,constructor_)
`constexpr optional(const optional& rhs);
`
[4](#ctor-4)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3424)
*Effects*: If rhs contains a value, direct-non-list-initializes the contained value
with *rhs[.](#ctor-4.sentence-1)
[5](#ctor-5)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3429)
*Postconditions*: rhs.has_value() == this->has_value()[.](#ctor-5.sentence-1)
[6](#ctor-6)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3433)
*Throws*: Any exception thrown by the selected constructor of T[.](#ctor-6.sentence-1)
[7](#ctor-7)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3437)
*Remarks*: This constructor is defined as deleted unlessis_copy_constructible_v<T> is true[.](#ctor-7.sentence-1)
If is_trivially_copy_constructible_v<T> is true,
this constructor is trivial[.](#ctor-7.sentence-2)
[🔗](#lib:optional,constructor__)
`constexpr optional(optional&& rhs) noexcept(see below);
`
[8](#ctor-8)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3451)
*Constraints*: is_move_constructible_v<T> is true[.](#ctor-8.sentence-1)
[9](#ctor-9)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3455)
*Effects*: If rhs contains a value, direct-non-list-initializes the contained value
with *std​::​move(rhs)[.](#ctor-9.sentence-1)
rhs.has_value() is unchanged[.](#ctor-9.sentence-2)
[10](#ctor-10)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3461)
*Postconditions*: rhs.has_value() == this->has_value()[.](#ctor-10.sentence-1)
[11](#ctor-11)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3465)
*Throws*: Any exception thrown by the selected constructor of T[.](#ctor-11.sentence-1)
[12](#ctor-12)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3469)
*Remarks*: The exception specification is equivalent tois_nothrow_move_constructible_v<T>[.](#ctor-12.sentence-1)
If is_trivially_move_constructible_v<T> is true,
this constructor is trivial[.](#ctor-12.sentence-2)
[🔗](#lib:optional,constructor___)
`template<class... Args> constexpr explicit optional(in_place_t, Args&&... args);
`
[13](#ctor-13)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3483)
*Constraints*: is_constructible_v<T, Args...> is true[.](#ctor-13.sentence-1)
[14](#ctor-14)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3487)
*Effects*: Direct-non-list-initializes the contained value with std​::​forward<Args>(args)...[.](#ctor-14.sentence-1)
[15](#ctor-15)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3491)
*Postconditions*: *this contains a value[.](#ctor-15.sentence-1)
[16](#ctor-16)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3495)
*Throws*: Any exception thrown by the selected constructor of T[.](#ctor-16.sentence-1)
[17](#ctor-17)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3499)
*Remarks*: If T's constructor selected for the initialization is a constexpr constructor, this constructor is a constexpr constructor[.](#ctor-17.sentence-1)
[🔗](#lib:optional,constructor____)
`template<class U, class... Args>
constexpr explicit optional(in_place_t, initializer_list<U> il, Args&&... args);
`
[18](#ctor-18)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3511)
*Constraints*: is_constructible_v<T, initializer_list<U>&, Args...> is true[.](#ctor-18.sentence-1)
[19](#ctor-19)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3515)
*Effects*: Direct-non-list-initializes the contained value with il, std​::​forward<Args>(args)...[.](#ctor-19.sentence-1)
[20](#ctor-20)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3519)
*Postconditions*: *this contains a value[.](#ctor-20.sentence-1)
[21](#ctor-21)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3523)
*Throws*: Any exception thrown by the selected constructor of T[.](#ctor-21.sentence-1)
[22](#ctor-22)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3527)
*Remarks*: If T's constructor selected for the initialization is a constexpr constructor, this constructor is a constexpr constructor[.](#ctor-22.sentence-1)
[🔗](#lib:optional,constructor_____)
`template<class U = remove_cv_t<T>> constexpr explicit(see below) optional(U&& v);
`
[23](#ctor-23)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3538)
*Constraints*:
- [(23.1)](#ctor-23.1)
is_constructible_v<T, U> is true,
- [(23.2)](#ctor-23.2)
is_same_v<remove_cvref_t<U>, in_place_t> is false,
- [(23.3)](#ctor-23.3)
is_same_v<remove_cvref_t<U>, optional> is false, and
- [(23.4)](#ctor-23.4)
if T is cv bool,remove_cvref_t<U> is not a specialization of optional[.](#ctor-23.sentence-1)
[24](#ctor-24)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3548)
*Effects*: Direct-non-list-initializes the contained value with std​::​forward<U>(v)[.](#ctor-24.sentence-1)
[25](#ctor-25)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3552)
*Postconditions*: *this contains a value[.](#ctor-25.sentence-1)
[26](#ctor-26)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3556)
*Throws*: Any exception thrown by the selected constructor of T[.](#ctor-26.sentence-1)
[27](#ctor-27)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3560)
*Remarks*: If T's selected constructor is a constexpr constructor,
this constructor is a constexpr constructor[.](#ctor-27.sentence-1)
The expression inside explicit is equivalent to:!is_convertible_v<U, T>
[🔗](#lib:optional,constructor______)
`template<class U> constexpr explicit(see below) optional(const optional<U>& rhs);
`
[28](#ctor-28)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3576)
*Constraints*:
- [(28.1)](#ctor-28.1)
is_constructible_v<T, const U&> is true, and
- [(28.2)](#ctor-28.2)
if T is not cv bool,*converts-from-any-cvref*<T, optional<U>> is false[.](#ctor-28.sentence-1)
[29](#ctor-29)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3584)
*Effects*: If rhs contains a value,
direct-non-list-initializes the contained value with *rhs[.](#ctor-29.sentence-1)
[30](#ctor-30)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3589)
*Postconditions*: rhs.has_value() == this->has_value()[.](#ctor-30.sentence-1)
[31](#ctor-31)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3593)
*Throws*: Any exception thrown by the selected constructor of T[.](#ctor-31.sentence-1)
[32](#ctor-32)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3597)
*Remarks*: The expression inside explicit is equivalent to:!is_convertible_v<const U&, T>
[🔗](#lib:optional,constructor_______)
`template<class U> constexpr explicit(see below) optional(optional<U>&& rhs);
`
[33](#ctor-33)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3611)
*Constraints*:
- [(33.1)](#ctor-33.1)
is_constructible_v<T, U> is true, and
- [(33.2)](#ctor-33.2)
if T is not cv bool,*converts-from-any-cvref*<T, optional<U>> is false[.](#ctor-33.sentence-1)
[34](#ctor-34)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3619)
*Effects*: If rhs contains a value,
direct-non-list-initializes the contained value with *std​::​move(rhs)[.](#ctor-34.sentence-1)
rhs.has_value() is unchanged[.](#ctor-34.sentence-2)
[35](#ctor-35)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3625)
*Postconditions*: rhs.has_value() == this->has_value()[.](#ctor-35.sentence-1)
[36](#ctor-36)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3629)
*Throws*: Any exception thrown by the selected constructor of T[.](#ctor-36.sentence-1)
[37](#ctor-37)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3633)
*Remarks*: The expression inside explicit is equivalent to:!is_convertible_v<U, T>
#### [22.5.3.3](#dtor) Destructor [[optional.dtor]](optional.dtor)
[🔗](#lib:optional,destructor)
`constexpr ~optional();
`
[1](#dtor-1)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3649)
*Effects*: If is_trivially_destructible_v<T> != true and *this contains a value, callsval->T::~T()
[2](#dtor-2)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3656)
*Remarks*: If is_trivially_destructible_v<T> is true, then this destructor is trivial[.](#dtor-2.sentence-1)
#### [22.5.3.4](#assign) Assignment [[optional.assign]](optional.assign)
[🔗](#lib:operator=,optional)
`constexpr optional<T>& operator=(nullopt_t) noexcept;
`
[1](#assign-1)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3669)
*Effects*: If *this contains a value, calls val->T​::​~T() to destroy the contained value; otherwise no effect[.](#assign-1.sentence-1)
[2](#assign-2)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3673)
*Postconditions*: *this does not contain a value[.](#assign-2.sentence-1)
[3](#assign-3)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3677)
*Returns*: *this[.](#assign-3.sentence-1)
[🔗](#lib:operator=,optional_)
`constexpr optional<T>& operator=(const optional& rhs);
`
[4](#assign-4)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3688)
*Effects*: See Table [67](#tab:optional.assign.copy "Table 67: optional​::​operator=(const optional&amp;) effects")[.](#assign-4.sentence-1)
Table [67](#tab:optional.assign.copy) — optional​::​operator=(const optional&) effects [[tab:optional.assign.copy]](./tab:optional.assign.copy)
| [🔗](#tab:optional.assign.copy-row-1) | | ***this contains a value** | ***this does not contain a value** |
| --- | --- | --- | --- |
| [🔗](#tab:optional.assign.copy-row-2)<br>**rhs contains a value** | | assigns *rhs to the contained value | direct-non-list-initializes the contained value with *rhs |
| [🔗](#tab:optional.assign.copy-row-3)<br>**rhs does not contain a value** | | destroys the contained value by calling val->T​::​~T() | no effect |
[5](#assign-5)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3705)
*Postconditions*: rhs.has_value() == this->has_value()[.](#assign-5.sentence-1)
[6](#assign-6)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3709)
*Returns*: *this[.](#assign-6.sentence-1)
[7](#assign-7)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3713)
*Remarks*: If any exception is thrown, the result of the expression this->has_value() remains unchanged[.](#assign-7.sentence-1)
If an exception is thrown during the call to T's copy constructor, no effect[.](#assign-7.sentence-2)
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[.](#assign-7.sentence-3)
This operator is defined as deleted unlessis_copy_constructible_v<T> is true andis_copy_assignable_v<T> is true[.](#assign-7.sentence-4)
If is_trivially_copy_constructible_v<T> &&is_trivially_copy_assignable_v<T> &&is_trivially_destructible_v<T> is true,
this assignment operator is trivial[.](#assign-7.sentence-5)
[🔗](#lib:operator=,optional__)
`constexpr optional& operator=(optional&& rhs) noexcept(see below);
`
[8](#assign-8)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3734)
*Constraints*: is_move_constructible_v<T> is true andis_move_assignable_v<T> is true[.](#assign-8.sentence-1)
[9](#assign-9)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3739)
*Effects*: See Table [68](#tab:optional.assign.move "Table 68: optional​::​operator=(optional&amp;&amp;) effects")[.](#assign-9.sentence-1)
The result of the expression rhs.has_value() remains unchanged[.](#assign-9.sentence-2)
Table [68](#tab:optional.assign.move) — optional​::​operator=(optional&&) effects [[tab:optional.assign.move]](./tab:optional.assign.move)
| [🔗](#tab:optional.assign.move-row-1) | | ***this contains a value** | ***this does not contain a value** |
| --- | --- | --- | --- |
| [🔗](#tab:optional.assign.move-row-2)<br>**rhs contains a value** | | assigns *std​::​move(rhs) to the contained value | direct-non-list-initializes the contained value with *std​::​move(rhs) |
| [🔗](#tab:optional.assign.move-row-3)<br>**rhs does not contain a value** | | destroys the contained value by calling val->T​::​~T() | no effect |
[10](#assign-10)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3757)
*Postconditions*: rhs.has_value() == this->has_value()[.](#assign-10.sentence-1)
[11](#assign-11)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3761)
*Returns*: *this[.](#assign-11.sentence-1)
[12](#assign-12)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3765)
*Remarks*: The exception specification is equivalent to:is_nothrow_move_assignable_v<T> && is_nothrow_move_constructible_v<T>
[13](#assign-13)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3772)
If any exception is thrown, the result of the expression this->has_value() remains unchanged[.](#assign-13.sentence-1)
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[.](#assign-13.sentence-2)
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[.](#assign-13.sentence-3)
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[.](#assign-13.sentence-4)
[🔗](#lib:operator=,optional___)
`template<class U = remove_cv_t<T>> constexpr optional& operator=(U&& v);
`
[14](#assign-14)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3790)
*Constraints*:
- [(14.1)](#assign-14.1)
is_same_v<remove_cvref_t<U>, optional> is false,
- [(14.2)](#assign-14.2)
conjunction_v<is_scalar<T>, is_same<T, decay_t<U>>> is false,
- [(14.3)](#assign-14.3)
is_constructible_v<T, U> is true, and
- [(14.4)](#assign-14.4)
is_assignable_v<T&, U> is true[.](#assign-14.sentence-1)
[15](#assign-15)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3799)
*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)[.](#assign-15.sentence-1)
[16](#assign-16)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3803)
*Postconditions*: *this contains a value[.](#assign-16.sentence-1)
[17](#assign-17)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3807)
*Returns*: *this[.](#assign-17.sentence-1)
[18](#assign-18)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3811)
*Remarks*: If any exception is thrown, the result of the expression this->has_value() remains unchanged[.](#assign-18.sentence-1)
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[.](#assign-18.sentence-2)
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[.](#assign-18.sentence-3)
[🔗](#lib:operator=,optional____)
`template<class U> constexpr optional<T>& operator=(const optional<U>& rhs);
`
[19](#assign-19)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3822)
*Constraints*:
- [(19.1)](#assign-19.1)
is_constructible_v<T, const U&> is true,
- [(19.2)](#assign-19.2)
is_assignable_v<T&, const U&> is true,
- [(19.3)](#assign-19.3)
*converts-from-any-cvref*<T, optional<U>> is false,
- [(19.4)](#assign-19.4)
is_assignable_v<T&, optional<U>&> is false,
- [(19.5)](#assign-19.5)
is_assignable_v<T&, optional<U>&&> is false,
- [(19.6)](#assign-19.6)
is_assignable_v<T&, const optional<U>&> is false, and
- [(19.7)](#assign-19.7)
is_assignable_v<T&, const optional<U>&&> is false[.](#assign-19.sentence-1)
[20](#assign-20)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3834)
*Effects*: See Table [69](#tab:optional.assign.copy.templ "Table 69: optional​::​operator=(const optional<U>&amp;) effects")[.](#assign-20.sentence-1)
Table [69](#tab:optional.assign.copy.templ) — optional​::​operator=(const optional<U>&) effects [[tab:optional.assign.copy.templ]](./tab:optional.assign.copy.templ)
| [🔗](#tab:optional.assign.copy.templ-row-1) | | ***this contains a value** | ***this does not contain a value** |
| --- | --- | --- | --- |
| [🔗](#tab:optional.assign.copy.templ-row-2)<br>**rhs contains a value** | | assigns *rhs to the contained value | direct-non-list-initializes the contained value with *rhs |
| [🔗](#tab:optional.assign.copy.templ-row-3)<br>**rhs does not contain a value** | | destroys the contained value by calling val->T​::​~T() | no effect |
[21](#assign-21)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3851)
*Postconditions*: rhs.has_value() == this->has_value()[.](#assign-21.sentence-1)
[22](#assign-22)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3855)
*Returns*: *this[.](#assign-22.sentence-1)
[23](#assign-23)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3859)
*Remarks*: If any exception is thrown,
the result of the expression this->has_value() remains unchanged[.](#assign-23.sentence-1)
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[.](#assign-23.sentence-2)
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[.](#assign-23.sentence-3)
[🔗](#lib:operator=,optional_____)
`template<class U> constexpr optional<T>& operator=(optional<U>&& rhs);
`
[24](#assign-24)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3877)
*Constraints*:
- [(24.1)](#assign-24.1)
is_constructible_v<T, U> is true,
- [(24.2)](#assign-24.2)
is_assignable_v<T&, U> is true,
- [(24.3)](#assign-24.3)
*converts-from-any-cvref*<T, optional<U>> is false,
- [(24.4)](#assign-24.4)
is_assignable_v<T&, optional<U>&> is false,
- [(24.5)](#assign-24.5)
is_assignable_v<T&, optional<U>&&> is false,
- [(24.6)](#assign-24.6)
is_assignable_v<T&, const optional<U>&> is false, and
- [(24.7)](#assign-24.7)
is_assignable_v<T&, const optional<U>&&> is false[.](#assign-24.sentence-1)
[25](#assign-25)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3889)
*Effects*: See Table [70](#tab:optional.assign.move.templ "Table 70: optional​::​operator=(optional<U>&amp;&amp;) effects")[.](#assign-25.sentence-1)
The result of the expression rhs.has_value() remains unchanged[.](#assign-25.sentence-2)
Table [70](#tab:optional.assign.move.templ) — optional​::​operator=(optional<U>&&) effects [[tab:optional.assign.move.templ]](./tab:optional.assign.move.templ)
| [🔗](#tab:optional.assign.move.templ-row-1) | | ***this contains a value** | ***this does not contain a value** |
| --- | --- | --- | --- |
| [🔗](#tab:optional.assign.move.templ-row-2)<br>**rhs contains a value** | | assigns *std​::​move(rhs) to the contained value | direct-non-list-initializes the contained value with *std​::​move(rhs) |
| [🔗](#tab:optional.assign.move.templ-row-3)<br>**rhs does not contain a value** | | destroys the contained value by calling val->T​::​~T() | no effect |
[26](#assign-26)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3907)
*Postconditions*: rhs.has_value() == this->has_value()[.](#assign-26.sentence-1)
[27](#assign-27)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3911)
*Returns*: *this[.](#assign-27.sentence-1)
[28](#assign-28)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3915)
*Remarks*: If any exception is thrown,
the result of the expression this->has_value() remains unchanged[.](#assign-28.sentence-1)
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[.](#assign-28.sentence-2)
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[.](#assign-28.sentence-3)
[🔗](#lib:emplace,optional)
`template<class... Args> constexpr T& emplace(Args&&... args);
`
[29](#assign-29)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3933)
*Mandates*: is_constructible_v<T, Args...> is true[.](#assign-29.sentence-1)
[30](#assign-30)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3937)
*Effects*: Calls *this = nullopt[.](#assign-30.sentence-1)
Then direct-non-list-initializes the contained value
with std​::​forward​<Args>(args)...[.](#assign-30.sentence-2)
[31](#assign-31)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3942)
*Postconditions*: *this contains a value[.](#assign-31.sentence-1)
[32](#assign-32)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3946)
*Returns*: A reference to the new contained value[.](#assign-32.sentence-1)
[33](#assign-33)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3950)
*Throws*: Any exception thrown by the selected constructor of T[.](#assign-33.sentence-1)
[34](#assign-34)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3954)
*Remarks*: If an exception is thrown during the call to T's constructor, *this does not contain a value, and the previous *val (if any) has been destroyed[.](#assign-34.sentence-1)
[🔗](#lib:emplace,optional_)
`template<class U, class... Args> constexpr T& emplace(initializer_list<U> il, Args&&... args);
`
[35](#assign-35)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3965)
*Constraints*: is_constructible_v<T, initializer_list<U>&, Args...> is true[.](#assign-35.sentence-1)
[36](#assign-36)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3969)
*Effects*: Calls *this = nullopt[.](#assign-36.sentence-1)
Then direct-non-list-initializes the contained value withil, std​::​​forward<Args>(args)...[.](#assign-36.sentence-2)
[37](#assign-37)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3974)
*Postconditions*: *this contains a value[.](#assign-37.sentence-1)
[38](#assign-38)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3978)
*Returns*: A reference to the new contained value[.](#assign-38.sentence-1)
[39](#assign-39)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3982)
*Throws*: Any exception thrown by the selected constructor of T[.](#assign-39.sentence-1)
[40](#assign-40)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3986)
*Remarks*: If an exception is thrown during the call to T's constructor, *this does not contain a value, and the previous *val (if any) has been destroyed[.](#assign-40.sentence-1)
#### [22.5.3.5](#swap) Swap [[optional.swap]](optional.swap)
[🔗](#lib:swap,optional)
`constexpr void swap(optional& rhs) noexcept(see below);
`
[1](#swap-1)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L3999)
*Mandates*: is_move_constructible_v<T> is true[.](#swap-1.sentence-1)
[2](#swap-2)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4003)
*Preconditions*: T meets the [*Cpp17Swappable*](swappable.requirements#:Cpp17Swappable "16.4.4.3 Swappable requirements [swappable.requirements]") requirements ([[swappable.requirements]](swappable.requirements "16.4.4.3 Swappable requirements"))[.](#swap-2.sentence-1)
[3](#swap-3)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4007)
*Effects*: See Table [71](#tab:optional.swap "Table 71: optional​::​swap(optional&amp;) effects")[.](#swap-3.sentence-1)
Table [71](#tab:optional.swap) — optional​::​swap(optional&) effects [[tab:optional.swap]](./tab:optional.swap)
| [🔗](#tab:optional.swap-row-1) | | ***this contains a value** | ***this does not contain a value** |
| --- | --- | --- | --- |
| [🔗](#tab:optional.swap-row-2)<br>**rhs contains a value** | | calls swap(*(*this), *rhs) | direct-non-list-initializes the contained value of *this with std​::​move(*rhs), followed by rhs.val->T​::​~T(); postcondition is that *this contains a value and rhs does not contain a value |
| [🔗](#tab:optional.swap-row-3)<br>**rhs does not contain a value** | | direct-non-list-initializes the contained value of rhs with std​::​move(*(*this)), followed by val->T​::​~T(); postcondition is that *this does not contain a value and rhs contains a value | no effect |
[4](#swap-4)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4030)
*Throws*: Any exceptions thrown by the operations in the relevant part of Table [71](#tab:optional.swap "Table 71: optional​::​swap(optional&amp;) effects")[.](#swap-4.sentence-1)
[5](#swap-5)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4034)
*Remarks*: The exception specification is equivalent to:is_nothrow_move_constructible_v<T> && is_nothrow_swappable_v<T>
[6](#swap-6)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4041)
If any exception is thrown, the results of the expressions this->has_value() and rhs.has_value() remain unchanged[.](#swap-6.sentence-1)
If an exception is thrown during the call to function swap,
the state of *val and *rhs.val is determined by the exception safety guarantee of swap for lvalues of T[.](#swap-6.sentence-2)
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[.](#swap-6.sentence-3)
#### [22.5.3.6](#iterators) Iterator support [[optional.iterators]](optional.iterators)
[🔗](#lib:iterator,optional)
`using iterator = implementation-defined;
using const_iterator = implementation-defined;
`
[1](#iterators-1)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4059)
These types
model [contiguous_iterator](iterator.concept.contiguous#concept:contiguous_iterator "24.3.4.14 Concept contiguous_­iterator [iterator.concept.contiguous]") ([[iterator.concept.contiguous]](iterator.concept.contiguous "24.3.4.14 Concept contiguous_­iterator")),
meet the [*Cpp17RandomAccessIterator*](random.access.iterators#:Cpp17RandomAccessIterator "24.3.5.7 Random access iterators [random.access.iterators]") requirements ([[random.access.iterators]](random.access.iterators "24.3.5.7 Random access iterators")), and
meet the requirements for constexpr iterators ([[iterator.requirements.general]](iterator.requirements.general "24.3.1 General")),
with value type remove_cv_t<T>[.](#iterators-1.sentence-1)
The reference type is T& for iterator andconst T& for const_iterator[.](#iterators-1.sentence-2)
[2](#iterators-2)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4068)
All requirements on container iterators ([[container.reqmts]](container.reqmts "23.2.2.2 Container requirements")) apply tooptional​::​iterator and optional​::​const_iterator as well[.](#iterators-2.sentence-1)
[3](#iterators-3)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4072)
Any operation that initializes or destroys the contained value of an optional object invalidates all iterators into that object[.](#iterators-3.sentence-1)
[🔗](#lib:begin,optional)
`constexpr iterator begin() noexcept;
constexpr const_iterator begin() const noexcept;
`
[4](#iterators-4)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4083)
*Returns*: If has_value() is true,
an iterator referring to the contained value[.](#iterators-4.sentence-1)
Otherwise, a past-the-end iterator value[.](#iterators-4.sentence-2)
[🔗](#lib:end,optional)
`constexpr iterator end() noexcept;
constexpr const_iterator end() const noexcept;
`
[5](#iterators-5)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4097)
*Returns*: begin() + has_value()[.](#iterators-5.sentence-1)
#### [22.5.3.7](#observe) Observers [[optional.observe]](optional.observe)
[🔗](#lib:operator-%3e,optional)
`constexpr const T* operator->() const noexcept;
constexpr T* operator->() noexcept;
`
[1](#observe-1)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4111)
*Hardened preconditions*: has_value() is true[.](#observe-1.sentence-1)
[2](#observe-2)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4115)
*Returns*: val[.](#observe-2.sentence-1)
[3](#observe-3)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4119)
*Remarks*: These functions are constexpr functions[.](#observe-3.sentence-1)
[🔗](#lib:operator*,optional)
`constexpr const T& operator*() const & noexcept;
constexpr T& operator*() & noexcept;
`
[4](#observe-4)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4131)
*Hardened preconditions*: has_value() is true[.](#observe-4.sentence-1)
[5](#observe-5)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4135)
*Returns*: *val[.](#observe-5.sentence-1)
[6](#observe-6)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4139)
*Remarks*: These functions are constexpr functions[.](#observe-6.sentence-1)
[🔗](#lib:operator*,optional_)
`constexpr T&& operator*() && noexcept;
constexpr const T&& operator*() const && noexcept;
`
[7](#observe-7)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4151)
*Hardened preconditions*: has_value() is true[.](#observe-7.sentence-1)
[8](#observe-8)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4155)
*Effects*: Equivalent to: return std​::​move(*val);
[🔗](#lib:operator_bool,optional)
`constexpr explicit operator bool() const noexcept;
`
[9](#observe-9)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4166)
*Returns*: true if and only if *this contains a value[.](#observe-9.sentence-1)
[10](#observe-10)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4170)
*Remarks*: This function is a constexpr function[.](#observe-10.sentence-1)
[🔗](#lib:has_value,optional)
`constexpr bool has_value() const noexcept;
`
[11](#observe-11)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4181)
*Returns*: true if and only if *this contains a value[.](#observe-11.sentence-1)
[12](#observe-12)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4185)
*Remarks*: This function is a constexpr function[.](#observe-12.sentence-1)
[🔗](#lib:value,optional)
`constexpr const T& value() const &;
constexpr T& value() &;
`
[13](#observe-13)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4197)
*Effects*: Equivalent to:return has_value() ? *val : throw bad_optional_access();
[🔗](#lib:value,optional_)
`constexpr T&& value() &&;
constexpr const T&& value() const &&;
`
[14](#observe-14)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4213)
*Effects*: Equivalent to:return has_value() ? std::move(*val) : throw bad_optional_access();
[🔗](#lib:value_or,optional)
`template<class U = remove_cv_t<T>> constexpr T value_or(U&& v) const &;
`
[15](#observe-15)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4227)
*Mandates*: is_copy_constructible_v<T> && is_convertible_v<U&&, T> is true[.](#observe-15.sentence-1)
[16](#observe-16)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4231)
*Effects*: Equivalent to:return has_value() ? **this : static_cast<T>(std::forward<U>(v));
[🔗](#lib:value_or,optional_)
`template<class U = remove_cv_t<T>> constexpr T value_or(U&& v) &&;
`
[17](#observe-17)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4245)
*Mandates*: is_move_constructible_v<T> && is_convertible_v<U&&, T> is true[.](#observe-17.sentence-1)
[18](#observe-18)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4249)
*Effects*: Equivalent to:return has_value() ? std::move(**this) : static_cast<T>(std::forward<U>(v));
#### [22.5.3.8](#monadic) Monadic operations [[optional.monadic]](optional.monadic)
[🔗](#lib:and_then,optional)
`template<class F> constexpr auto and_then(F&& f) &;
template<class F> constexpr auto and_then(F&& f) const &;
`
[1](#monadic-1)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4266)
Let U be invoke_result_t<F, decltype(**val*)>[.](#monadic-1.sentence-1)
[2](#monadic-2)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4269)
*Mandates*: remove_cvref_t<U> is a specialization of optional[.](#monadic-2.sentence-1)
[3](#monadic-3)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4273)
*Effects*: Equivalent to:if (*this) {return invoke(std::forward<F>(f), **val*);} else {return remove_cvref_t<U>();}
[🔗](#lib:and_then,optional_)
`template<class F> constexpr auto and_then(F&& f) &&;
template<class F> constexpr auto and_then(F&& f) const &&;
`
[4](#monadic-4)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4292)
Let U be invoke_result_t<F, decltype(std​::​move(**val*))>[.](#monadic-4.sentence-1)
[5](#monadic-5)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4295)
*Mandates*: remove_cvref_t<U> is a specialization of optional[.](#monadic-5.sentence-1)
[6](#monadic-6)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4299)
*Effects*: Equivalent to:if (*this) {return invoke(std::forward<F>(f), std::move(**val*));} else {return remove_cvref_t<U>();}
[🔗](#lib:transform,optional)
`template<class F> constexpr auto transform(F&& f) &;
template<class F> constexpr auto transform(F&& f) const &;
`
[7](#monadic-7)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4318)
Let U be remove_cv_t<invoke_result_t<F, decltype(**val*)>>[.](#monadic-7.sentence-1)
[8](#monadic-8)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4321)
*Mandates*: U is a valid contained type for optional[.](#monadic-8.sentence-1)
The declarationU u(invoke(std::forward<F>(f), **val*)); is well-formed for some invented variable u[.](#monadic-8.sentence-2)
[*Note [1](#monadic-note-1)*:
There is no requirement that U is movable ([[dcl.init.general]](dcl.init.general "9.5.1 General"))[.](#monadic-8.sentence-3)
— *end note*]
[9](#monadic-9)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4333)
*Returns*: If *this contains a value, an optional<U> object
whose contained value is direct-non-list-initialized withinvoke(std​::​forward<F>(f), **val*);
otherwise, optional<U>()[.](#monadic-9.sentence-1)
[🔗](#lib:transform,optional_)
`template<class F> constexpr auto transform(F&& f) &&;
template<class F> constexpr auto transform(F&& f) const &&;
`
[10](#monadic-10)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4348)
Let U beremove_cv_t<invoke_result_t<F, decltype(std​::​move(**val*))>>[.](#monadic-10.sentence-1)
[11](#monadic-11)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4352)
*Mandates*: U is a valid contained type for optional[.](#monadic-11.sentence-1)
The declarationU u(invoke(std::forward<F>(f), std::move(**val*))); is well-formed for some invented variable u[.](#monadic-11.sentence-2)
[*Note [2](#monadic-note-2)*:
There is no requirement that U is movable ([[dcl.init.general]](dcl.init.general "9.5.1 General"))[.](#monadic-11.sentence-3)
— *end note*]
[12](#monadic-12)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4364)
*Returns*: If *this contains a value, an optional<U> object
whose contained value is direct-non-list-initialized withinvoke(std​::​forward<F>(f), std​::​move(**val*));
otherwise, optional<U>()[.](#monadic-12.sentence-1)
[🔗](#lib:or_else,optional)
`template<class F> constexpr optional or_else(F&& f) const &;
`
[13](#monadic-13)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4378)
*Constraints*: F models [invocable](concept.invocable#concept:invocable "18.7.2 Concept invocable [concept.invocable]") andT models [copy_constructible](concept.copyconstructible#concept:copy_constructible "18.4.14 Concept copy_­constructible [concept.copyconstructible]")[.](#monadic-13.sentence-1)
[14](#monadic-14)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4383)
*Mandates*: is_same_v<remove_cvref_t<invoke_result_t<F>>, optional> is true[.](#monadic-14.sentence-1)
[15](#monadic-15)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4387)
*Effects*: Equivalent to:if (*this) {return *this;} else {return std::forward<F>(f)();}
[🔗](#lib:or_else,optional_)
`template<class F> constexpr optional or_else(F&& f) &&;
`
[16](#monadic-16)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4405)
*Constraints*: F models [invocable](concept.invocable#concept:invocable "18.7.2 Concept invocable [concept.invocable]") andT models [move_constructible](concept.moveconstructible#concept:move_constructible "18.4.13 Concept move_­constructible [concept.moveconstructible]")[.](#monadic-16.sentence-1)
[17](#monadic-17)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4410)
*Mandates*: is_same_v<remove_cvref_t<invoke_result_t<F>>, optional> is true[.](#monadic-17.sentence-1)
[18](#monadic-18)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4414)
*Effects*: Equivalent to:if (*this) {return std::move(*this);} else {return std::forward<F>(f)();}
#### [22.5.3.9](#mod) Modifiers [[optional.mod]](optional.mod)
[🔗](#lib:reset,optional)
`constexpr void reset() noexcept;
`
[1](#mod-1)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4434)
*Effects*: If *this contains a value, calls val->T​::​~T() to destroy the contained value;
otherwise no effect[.](#mod-1.sentence-1)
[2](#mod-2)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4439)
*Postconditions*: *this does not contain a value[.](#mod-2.sentence-1)
### [22.5.4](#optional.ref) Partial specialization of optional for reference types [[optional.optional.ref]](optional.optional.ref)
#### [22.5.4.1](#optional.ref.general) General [[optional.optional.ref.general]](optional.optional.ref.general)
namespace std {template<class T>class optional<T&> {public:using value_type = T; using iterator = *implementation-defined*; // see [[optional.ref.iterators]](#ref.iterators "22.5.4.5 Iterator support")public:// [[optional.ref.ctor]](#ref.ctor "22.5.4.2 Constructors"), constructorsconstexpr 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]](#ref.assign "22.5.4.3 Assignment"), assignmentconstexpr 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]](#ref.swap "22.5.4.4 Swap"), swapconstexpr void swap(optional& rhs) noexcept; // [[optional.ref.iterators]](#ref.iterators "22.5.4.5 Iterator support"), iterator supportconstexpr iterator begin() const noexcept; constexpr iterator end() const noexcept; // [[optional.ref.observe]](#ref.observe "22.5.4.6 Observers"), observersconstexpr 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-deletedtemplate<class U = remove_cv_t<T>>constexpr remove_cv_t<T> value_or(U&& u) const; // [[optional.ref.monadic]](#ref.monadic "22.5.4.7 Monadic operations"), monadic operationstemplate<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]](#ref.mod "22.5.4.8 Modifiers"), modifiersconstexpr void reset() noexcept; private: T* *val* = nullptr; // *exposition only*// [[optional.ref.expos]](#ref.expos "22.5.4.9 Exposition only helper functions"), exposition only helper functionstemplate<class U>constexpr void *convert-ref-init-val*(U&& u); // *exposition only*};}
[1](#optional.ref.general-1)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4516)
An object of optional<T&>[*contains a value*](#def:contains_a_value,optional.ref "22.5.4.1 General [optional.optional.ref.general]") if and only if *val* != nullptr is true[.](#optional.ref.general-1.sentence-1)
When an optional<T&> contains a value,
the [*contained value*](#def:contained_value,optional.ref "22.5.4.1 General [optional.optional.ref.general]") is a reference to **val*[.](#optional.ref.general-1.sentence-2)
#### [22.5.4.2](#ref.ctor) Constructors [[optional.ref.ctor]](optional.ref.ctor)
[🔗](#ref.ctor-itemdecl:1)
`template<class Arg>
constexpr explicit optional(in_place_t, Arg&& arg);
`
[1](#ref.ctor-1)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4532)
*Constraints*:
- [(1.1)](#ref.ctor-1.1)
is_constructible_v<T&, Arg> is true, and
- [(1.2)](#ref.ctor-1.2)
reference_constructs_from_temporary_v<T&, Arg> is false[.](#ref.ctor-1.sentence-1)
[2](#ref.ctor-2)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4539)
*Effects*: Equivalent to: *convert-ref-init-val*(std​::​forward<Arg>(arg))[.](#ref.ctor-2.sentence-1)
[3](#ref.ctor-3)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4543)
*Postconditions*: *this contains a value[.](#ref.ctor-3.sentence-1)
[🔗](#ref.ctor-itemdecl:2)
`template<class U>
constexpr explicit(!is_convertible_v<U, T&>)
optional(U&& u) noexcept(is_nothrow_constructible_v<T&, U>);
`
[4](#ref.ctor-4)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4555)
*Constraints*:
- [(4.1)](#ref.ctor-4.1)
is_same_v<remove_cvref_t<U>, optional> is false,
- [(4.2)](#ref.ctor-4.2)
is_same_v<remove_cvref_t<U>, in_place_t> is false, and
- [(4.3)](#ref.ctor-4.3)
is_constructible_v<T&, U> is true[.](#ref.ctor-4.sentence-1)
[5](#ref.ctor-5)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4563)
*Effects*: Equivalent to: *convert-ref-init-val*(std​::​forward<U>(u))[.](#ref.ctor-5.sentence-1)
[6](#ref.ctor-6)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4567)
*Postconditions*: *this contains a value[.](#ref.ctor-6.sentence-1)
[7](#ref.ctor-7)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4571)
*Remarks*: This constructor is defined as deleted ifreference_constructs_from_temporary_v<T&, U> is true[.](#ref.ctor-7.sentence-1)
[🔗](#ref.ctor-itemdecl:3)
`template<class U>
constexpr explicit(!is_convertible_v<U&, T&>)
optional(optional<U>& rhs) noexcept(is_nothrow_constructible_v<T&, U&>);
`
[8](#ref.ctor-8)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4587)
*Constraints*:
- [(8.1)](#ref.ctor-8.1)
is_same_v<remove_cv_t<T>, optional<U>> is false,
- [(8.2)](#ref.ctor-8.2)
is_same_v<T&, U> is false, and
- [(8.3)](#ref.ctor-8.3)
is_constructible_v<T&, U&> is true[.](#ref.ctor-8.sentence-1)
[9](#ref.ctor-9)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4595)
*Effects*: Equivalent to:if (rhs.has_value()) *convert-ref-init-val*(*rhs);
[10](#ref.ctor-10)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4602)
*Remarks*: This constructor is defined as deleted ifreference_constructs_from_temporary_v<T&, U&> is true[.](#ref.ctor-10.sentence-1)
[🔗](#ref.ctor-itemdecl:4)
`template<class U>
constexpr explicit(!is_convertible_v<const U&, T&>)
optional(const optional<U>& rhs) noexcept(is_nothrow_constructible_v<T&, const U&>);
`
[11](#ref.ctor-11)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4618)
*Constraints*:
- [(11.1)](#ref.ctor-11.1)
is_same_v<remove_cv_t<T>, optional<U>> is false,
- [(11.2)](#ref.ctor-11.2)
is_same_v<T&, U> is false, and
- [(11.3)](#ref.ctor-11.3)
is_constructible_v<T&, const U&> is true[.](#ref.ctor-11.sentence-1)
[12](#ref.ctor-12)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4626)
*Effects*: Equivalent to:if (rhs.has_value()) *convert-ref-init-val*(*rhs);
[13](#ref.ctor-13)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4633)
*Remarks*: This constructor is defined as deleted ifreference_constructs_from_temporary_v<T&, const U&> is true[.](#ref.ctor-13.sentence-1)
[🔗](#ref.ctor-itemdecl:5)
`template<class U>
constexpr explicit(!is_convertible_v<U, T&>)
optional(optional<U>&& rhs) noexcept(is_nothrow_constructible_v<T&, U>);
`
[14](#ref.ctor-14)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4649)
*Constraints*:
- [(14.1)](#ref.ctor-14.1)
is_same_v<remove_cv_t<T>, optional<U>> is false,
- [(14.2)](#ref.ctor-14.2)
is_same_v<T&, U> is false, and
- [(14.3)](#ref.ctor-14.3)
is_constructible_v<T&, U> is true[.](#ref.ctor-14.sentence-1)
[15](#ref.ctor-15)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4657)
*Effects*: Equivalent to:if (rhs.has_value()) *convert-ref-init-val*(*std::move(rhs));
[16](#ref.ctor-16)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4664)
*Remarks*: This constructor is defined as deleted ifreference_constructs_from_temporary_v<T&, U> is true[.](#ref.ctor-16.sentence-1)
[🔗](#ref.ctor-itemdecl:6)
`template<class U>
constexpr explicit(!is_convertible_v<const U, T&>)
optional(const optional<U>&& rhs) noexcept(is_nothrow_constructible_v<T&, const U>);
`
[17](#ref.ctor-17)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4680)
*Constraints*:
- [(17.1)](#ref.ctor-17.1)
is_same_v<remove_cv_t<T>, optional<U>> is false,
- [(17.2)](#ref.ctor-17.2)
is_same_v<T&, U> is false, and
- [(17.3)](#ref.ctor-17.3)
is_constructible_v<T&, const U> is true[.](#ref.ctor-17.sentence-1)
[18](#ref.ctor-18)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4688)
*Effects*: Equivalent to:if (rhs.has_value()) *convert-ref-init-val*(*std::move(rhs));
[19](#ref.ctor-19)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4695)
*Remarks*: This constructor is defined as deleted ifreference_constructs_from_temporary_v<T&, const U> is true[.](#ref.ctor-19.sentence-1)
#### [22.5.4.3](#ref.assign) Assignment [[optional.ref.assign]](optional.ref.assign)
[🔗](#ref.assign-itemdecl:1)
`constexpr optional& operator=(nullopt_t) noexcept;
`
[1](#ref.assign-1)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4711)
*Effects*: Assigns nullptr to *val*[.](#ref.assign-1.sentence-1)
[2](#ref.assign-2)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4715)
*Postconditions*: *this does not contain a value[.](#ref.assign-2.sentence-1)
[3](#ref.assign-3)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4719)
*Returns*: *this[.](#ref.assign-3.sentence-1)
[🔗](#ref.assign-itemdecl:2)
`template<class U>
constexpr T& emplace(U&& u) noexcept(is_nothrow_constructible_v<T&, U>);
`
[4](#ref.assign-4)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4730)
*Constraints*:
- [(4.1)](#ref.assign-4.1)
is_constructible_v<T&, U> is true, and
- [(4.2)](#ref.assign-4.2)
reference_constructs_from_temporary_v<T&, U> is false[.](#ref.assign-4.sentence-1)
[5](#ref.assign-5)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4737)
*Effects*: Equivalent to: *convert-ref-init-val*(std​::​forward<U>(u))[.](#ref.assign-5.sentence-1)
#### [22.5.4.4](#ref.swap) Swap [[optional.ref.swap]](optional.ref.swap)
[🔗](#ref.swap-itemdecl:1)
`constexpr void swap(optional& rhs) noexcept;
`
[1](#ref.swap-1)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4749)
*Effects*: Equivalent to: swap(*val*, rhs.*val*)[.](#ref.swap-1.sentence-1)
#### [22.5.4.5](#ref.iterators) Iterator support [[optional.ref.iterators]](optional.ref.iterators)
[🔗](#ref.iterators-itemdecl:1)
`using iterator = implementation-defined;
`
[1](#ref.iterators-1)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4761)
This type
models [contiguous_iterator](iterator.concept.contiguous#concept:contiguous_iterator "24.3.4.14 Concept contiguous_­iterator [iterator.concept.contiguous]") ([[iterator.concept.contiguous]](iterator.concept.contiguous "24.3.4.14 Concept contiguous_­iterator")),
meets the *Cpp17RandomAccessIterator* requirements ([[random.access.iterators]](random.access.iterators "24.3.5.7 Random access iterators")),
and meets the requirements for constexpr iterators ([[iterator.requirements.general]](iterator.requirements.general "24.3.1 General")),
with value type remove_cv_t<T>[.](#ref.iterators-1.sentence-1)
The reference type is T& for iterator[.](#ref.iterators-1.sentence-2)
[2](#ref.iterators-2)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4769)
All requirements on container iterators ([[container.reqmts]](container.reqmts "23.2.2.2 Container requirements")) apply tooptional​::​iterator[.](#ref.iterators-2.sentence-1)
[🔗](#ref.iterators-itemdecl:2)
`constexpr iterator begin() const noexcept;
`
[3](#ref.iterators-3)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4779)
*Returns*: If has_value() is true,
an iterator referring to **val*[.](#ref.iterators-3.sentence-1)
Otherwise, a past-the-end iterator value[.](#ref.iterators-3.sentence-2)
[🔗](#ref.iterators-itemdecl:3)
`constexpr iterator end() const noexcept;
`
[4](#ref.iterators-4)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4791)
*Returns*: begin() + has_value()[.](#ref.iterators-4.sentence-1)
#### [22.5.4.6](#ref.observe) Observers [[optional.ref.observe]](optional.ref.observe)
[🔗](#ref.observe-itemdecl:1)
`constexpr T* operator->() const noexcept;
`
[1](#ref.observe-1)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4803)
*Hardened preconditions*: has_value() is true[.](#ref.observe-1.sentence-1)
[2](#ref.observe-2)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4807)
*Returns*: *val*[.](#ref.observe-2.sentence-1)
[🔗](#ref.observe-itemdecl:2)
`constexpr T& operator*() const noexcept;
`
[3](#ref.observe-3)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4818)
*Hardened preconditions*: has_value() is true[.](#ref.observe-3.sentence-1)
[4](#ref.observe-4)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4822)
*Returns*: **val*[.](#ref.observe-4.sentence-1)
[🔗](#ref.observe-itemdecl:3)
`constexpr explicit operator bool() const noexcept;
`
[5](#ref.observe-5)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4832)
*Returns*: *val* != nullptr[.](#ref.observe-5.sentence-1)
[🔗](#ref.observe-itemdecl:4)
`constexpr bool has_value() const noexcept;
`
[6](#ref.observe-6)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4842)
*Returns*: *val* != nullptr[.](#ref.observe-6.sentence-1)
[🔗](#ref.observe-itemdecl:5)
`constexpr T& value() const;
`
[7](#ref.observe-7)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4852)
*Effects*: Equivalent to:return has_value() ? **val* : throw bad_optional_access();
[🔗](#ref.observe-itemdecl:6)
`template<class U = remove_cv_t<T>> constexpr remove_cv_t<T> value_or(U&& u) const;
`
[8](#ref.observe-8)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4865)
Let X be remove_cv_t<T>[.](#ref.observe-8.sentence-1)
[9](#ref.observe-9)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4868)
*Mandates*: is_constructible_v<X, T&> && is_convertible_v<U, X> is true[.](#ref.observe-9.sentence-1)
[10](#ref.observe-10)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4872)
*Effects*: Equivalent to:return has_value() ? **val* : static_cast<X>(std::forward<U>(u));
#### [22.5.4.7](#ref.monadic) Monadic operations [[optional.ref.monadic]](optional.ref.monadic)
[🔗](#ref.monadic-itemdecl:1)
`template<class F> constexpr auto and_then(F&& f) const;
`
[1](#ref.monadic-1)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4887)
Let U be invoke_result_t<F, T&>[.](#ref.monadic-1.sentence-1)
[2](#ref.monadic-2)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4890)
*Mandates*: remove_cvref_t<U> is a specialization of optional[.](#ref.monadic-2.sentence-1)
[3](#ref.monadic-3)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4894)
*Effects*: Equivalent to:if (has_value()) {return invoke(std::forward<F>(f), **val*);} else {return remove_cvref_t<U>();}
[🔗](#ref.monadic-itemdecl:2)
`template<class F>
constexpr optional<remove_cv_t<invoke_result_t<F, T&>>> transform(F&& f) const;
`
[4](#ref.monadic-4)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4912)
Let U be remove_cv_t<invoke_result_t<F, T&>>[.](#ref.monadic-4.sentence-1)
[5](#ref.monadic-5)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4915)
*Mandates*: The declarationU u(invoke(std::forward<F>(f), **val*)); is well-formed for some invented variable u[.](#ref.monadic-5.sentence-1)
[*Note [1](#ref.monadic-note-1)*:
There is no requirement that U is movable ([[dcl.init.general]](dcl.init.general "9.5.1 General"))[.](#ref.monadic-5.sentence-2)
— *end note*]
[6](#ref.monadic-6)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4926)
*Returns*: If *this contains a value, an optional<U> object
whose contained value is direct-non-list-initialized withinvoke(std​::​forward<F>(f), **val*);
otherwise, optional<U>()[.](#ref.monadic-6.sentence-1)
[🔗](#ref.monadic-itemdecl:3)
`template<class F> constexpr optional or_else(F&& f) const;
`
[7](#ref.monadic-7)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4939)
*Constraints*: F models [invocable](concept.invocable#concept:invocable "18.7.2 Concept invocable [concept.invocable]")[.](#ref.monadic-7.sentence-1)
[8](#ref.monadic-8)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4943)
*Mandates*: is_same_v<remove_cvref_t<invoke_result_t<F>>, optional> is true[.](#ref.monadic-8.sentence-1)
[9](#ref.monadic-9)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4947)
*Effects*: Equivalent to:if (has_value()) {return **val*;} else {return std::forward<F>(f)();}
#### [22.5.4.8](#ref.mod) Modifiers [[optional.ref.mod]](optional.ref.mod)
[🔗](#ref.mod-itemdecl:1)
`constexpr void reset() noexcept;
`
[1](#ref.mod-1)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4966)
*Effects*: Assigns nullptr to *val*[.](#ref.mod-1.sentence-1)
[2](#ref.mod-2)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4970)
*Postconditions*: *this does not contain a value[.](#ref.mod-2.sentence-1)
#### [22.5.4.9](#ref.expos) Exposition only helper functions [[optional.ref.expos]](optional.ref.expos)
[🔗](#ref.expos-itemdecl:1)
`template<class U>
constexpr void convert-ref-init-val(U&& u); // exposition only
`
[1](#ref.expos-1)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4983)
*Effects*: Creates a variable r as if by T& r(std​::​forward<U>(u)); and then initializes *val* with addressof(r)[.](#ref.expos-1.sentence-1)
### [22.5.5](#nullopt) No-value state indicator [[optional.nullopt]](optional.nullopt)
[🔗](#lib:nullopt_t)
`struct nullopt_t{see below};
inline constexpr nullopt_t nullopt(unspecified);
`
[1](#nullopt-1)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L4998)
The struct nullopt_t is an empty class type used as a unique type to indicate the state of not containing a value for optional objects[.](#nullopt-1.sentence-1)
In particular, optional<T> has a constructor with nullopt_t as a single argument;
this indicates that an optional object not containing a value shall be constructed[.](#nullopt-1.sentence-2)
[2](#nullopt-2)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L5003)
Type nullopt_t shall not have a default constructor or an initializer-list constructor, and shall not be an aggregate[.](#nullopt-2.sentence-1)
### [22.5.6](#bad.access) Class bad_optional_access [[optional.bad.access]](optional.bad.access)
namespace std {class bad_optional_access : public exception {public:// see [[exception]](exception "17.9.3 Class exception") for the specification of the special member functionsconstexpr const char* what() const noexcept override; };}
[1](#bad.access-1)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L5018)
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[.](#bad.access-1.sentence-1)
[🔗](#lib:what,bad_optional_access)
`constexpr const char* what() const noexcept override;
`
[2](#bad.access-2)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L5027)
*Returns*: An implementation-defined ntbs,
which during constant evaluation is encoded with
the ordinary literal encoding ([[lex.ccon]](lex.ccon "5.13.3 Character literals"))[.](#bad.access-2.sentence-1)
### [22.5.7](#relops) Relational operators [[optional.relops]](optional.relops)
[🔗](#lib:operator==,optional)
`template<class T, class U> constexpr bool operator==(const optional<T>& x, const optional<U>& y);
`
[1](#relops-1)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L5042)
*Constraints*: The expression *x == *y is well-formed and
its result is convertible to bool[.](#relops-1.sentence-1)
[*Note [1](#relops-note-1)*:
T need not be [*Cpp17EqualityComparable*](utility.arg.requirements#:Cpp17EqualityComparable "16.4.4.2 Template argument requirements [utility.arg.requirements]")[.](#relops-1.sentence-2)
— *end note*]
[2](#relops-2)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L5050)
*Returns*: If x.has_value() != y.has_value(), false; otherwise if x.has_value() == false, true; otherwise *x == *y[.](#relops-2.sentence-1)
[3](#relops-3)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L5054)
*Remarks*: Specializations of this function template
for which *x == *y is a core constant expression
are constexpr functions[.](#relops-3.sentence-1)
[🔗](#lib:operator!=,optional)
`template<class T, class U> constexpr bool operator!=(const optional<T>& x, const optional<U>& y);
`
[4](#relops-4)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L5067)
*Constraints*: The expression *x != *y is well-formed and
its result is convertible to bool[.](#relops-4.sentence-1)
[5](#relops-5)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L5072)
*Returns*: If x.has_value() != y.has_value(), true;
otherwise, if x.has_value() == false, false;
otherwise *x != *y[.](#relops-5.sentence-1)
[6](#relops-6)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L5078)
*Remarks*: Specializations of this function template
for which *x != *y is a core constant expression
are constexpr functions[.](#relops-6.sentence-1)
[🔗](#lib:operator%3c,optional)
`template<class T, class U> constexpr bool operator<(const optional<T>& x, const optional<U>& y);
`
[7](#relops-7)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L5091)
*Constraints*: *x < *y is well-formed
and its result is convertible to bool[.](#relops-7.sentence-1)
[8](#relops-8)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L5096)
*Returns*: If !y, false;
otherwise, if !x, true;
otherwise *x < *y[.](#relops-8.sentence-1)
[9](#relops-9)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L5102)
*Remarks*: Specializations of this function template
for which *x < *y is a core constant expression
are constexpr functions[.](#relops-9.sentence-1)
[🔗](#lib:operator%3e,optional)
`template<class T, class U> constexpr bool operator>(const optional<T>& x, const optional<U>& y);
`
[10](#relops-10)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L5115)
*Constraints*: The expression *x > *y is well-formed and
its result is convertible to bool[.](#relops-10.sentence-1)
[11](#relops-11)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L5120)
*Returns*: If !x, false;
otherwise, if !y, true;
otherwise *x > *y[.](#relops-11.sentence-1)
[12](#relops-12)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L5126)
*Remarks*: Specializations of this function template
for which *x > *y is a core constant expression
are constexpr functions[.](#relops-12.sentence-1)
[🔗](#lib:operator%3c=,optional)
`template<class T, class U> constexpr bool operator<=(const optional<T>& x, const optional<U>& y);
`
[13](#relops-13)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L5139)
*Constraints*: The expression *x <= *y is well-formed and
its result is convertible to bool[.](#relops-13.sentence-1)
[14](#relops-14)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L5144)
*Returns*: If !x, true;
otherwise, if !y, false;
otherwise *x <= *y[.](#relops-14.sentence-1)
[15](#relops-15)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L5150)
*Remarks*: Specializations of this function template
for which *x <= *y is a core constant expression
are constexpr functions[.](#relops-15.sentence-1)
[🔗](#lib:operator%3e=,optional)
`template<class T, class U> constexpr bool operator>=(const optional<T>& x, const optional<U>& y);
`
[16](#relops-16)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L5163)
*Constraints*: The expression *x >= *y is well-formed and
its result is convertible to bool[.](#relops-16.sentence-1)
[17](#relops-17)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L5168)
*Returns*: If !y, true;
otherwise, if !x, false;
otherwise *x >= *y[.](#relops-17.sentence-1)
[18](#relops-18)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L5174)
*Remarks*: Specializations of this function template
for which *x >= *y is a core constant expression
are constexpr functions[.](#relops-18.sentence-1)
[🔗](#lib:operator%3c=%3e,optional)
`template<class T, [three_way_comparable_with](cmp.concept#concept:three_way_comparable_with "17.12.4 Concept three_­way_­comparable [cmp.concept]")<T> U>
constexpr compare_three_way_result_t<T, U>
operator<=>(const optional<T>& x, const optional<U>& y);
`
[19](#relops-19)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L5189)
*Returns*: If x && y, *x <=> *y; otherwise x.has_value() <=> y.has_value()[.](#relops-19.sentence-1)
[20](#relops-20)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L5193)
*Remarks*: Specializations of this function template
for which *x <=> *y is a core constant expression
are constexpr functions[.](#relops-20.sentence-1)
### [22.5.8](#nullops) Comparison with nullopt [[optional.nullops]](optional.nullops)
[🔗](#lib:operator==,optional_)
`template<class T> constexpr bool operator==(const optional<T>& x, nullopt_t) noexcept;
`
[1](#nullops-1)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L5208)
*Returns*: !x[.](#nullops-1.sentence-1)
[🔗](#lib:operator%3c=%3e,optional_)
`template<class T> constexpr strong_ordering operator<=>(const optional<T>& x, nullopt_t) noexcept;
`
[2](#nullops-2)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L5219)
*Returns*: x.has_value() <=> false[.](#nullops-2.sentence-1)
### [22.5.9](#comp.with.t) Comparison with T [[optional.comp.with.t]](optional.comp.with.t)
[🔗](#lib:operator==,optional__)
`template<class T, class U> constexpr bool operator==(const optional<T>& x, const U& v);
`
[1](#comp.with.t-1)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L5232)
*Constraints*: U is not a specialization of optional[.](#comp.with.t-1.sentence-1)
The expression *x == v is well-formed and
its result is convertible to bool[.](#comp.with.t-1.sentence-2)
[*Note [1](#comp.with.t-note-1)*:
T need not be [*Cpp17EqualityComparable*](utility.arg.requirements#:Cpp17EqualityComparable "16.4.4.2 Template argument requirements [utility.arg.requirements]")[.](#comp.with.t-1.sentence-3)
— *end note*]
[2](#comp.with.t-2)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L5241)
*Effects*: Equivalent to: return x.has_value() ? *x == v : false;
[🔗](#lib:operator==,optional___)
`template<class T, class U> constexpr bool operator==(const T& v, const optional<U>& x);
`
[3](#comp.with.t-3)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L5252)
*Constraints*: T is not a specialization of optional[.](#comp.with.t-3.sentence-1)
The expression v == *x is well-formed and
its result is convertible to bool[.](#comp.with.t-3.sentence-2)
[4](#comp.with.t-4)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L5258)
*Effects*: Equivalent to: return x.has_value() ? v == *x : false;
[🔗](#lib:operator!=,optional_)
`template<class T, class U> constexpr bool operator!=(const optional<T>& x, const U& v);
`
[5](#comp.with.t-5)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L5269)
*Constraints*: U is not a specialization of optional[.](#comp.with.t-5.sentence-1)
The expression *x != v is well-formed and
its result is convertible to bool[.](#comp.with.t-5.sentence-2)
[6](#comp.with.t-6)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L5275)
*Effects*: Equivalent to: return x.has_value() ? *x != v : true;
[🔗](#lib:operator!=,optional__)
`template<class T, class U> constexpr bool operator!=(const T& v, const optional<U>& x);
`
[7](#comp.with.t-7)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L5286)
*Constraints*: T is not a specialization of optional[.](#comp.with.t-7.sentence-1)
The expression v != *x is well-formed and
its result is convertible to bool[.](#comp.with.t-7.sentence-2)
[8](#comp.with.t-8)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L5292)
*Effects*: Equivalent to: return x.has_value() ? v != *x : true;
[🔗](#lib:operator%3c,optional_)
`template<class T, class U> constexpr bool operator<(const optional<T>& x, const U& v);
`
[9](#comp.with.t-9)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L5303)
*Constraints*: U is not a specialization of optional[.](#comp.with.t-9.sentence-1)
The expression *x < v is well-formed and
its result is convertible to bool[.](#comp.with.t-9.sentence-2)
[10](#comp.with.t-10)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L5309)
*Effects*: Equivalent to: return x.has_value() ? *x < v : true;
[🔗](#lib:operator%3c,optional__)
`template<class T, class U> constexpr bool operator<(const T& v, const optional<U>& x);
`
[11](#comp.with.t-11)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L5320)
*Constraints*: T is not a specialization of optional[.](#comp.with.t-11.sentence-1)
The expression v < *x is well-formed and
its result is convertible to bool[.](#comp.with.t-11.sentence-2)
[12](#comp.with.t-12)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L5326)
*Effects*: Equivalent to: return x.has_value() ? v < *x : false;
[🔗](#lib:operator%3e,optional_)
`template<class T, class U> constexpr bool operator>(const optional<T>& x, const U& v);
`
[13](#comp.with.t-13)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L5337)
*Constraints*: U is not a specialization of optional[.](#comp.with.t-13.sentence-1)
The expression *x > v is well-formed and
its result is convertible to bool[.](#comp.with.t-13.sentence-2)
[14](#comp.with.t-14)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L5343)
*Effects*: Equivalent to: return x.has_value() ? *x > v : false;
[🔗](#lib:operator%3e,optional__)
`template<class T, class U> constexpr bool operator>(const T& v, const optional<U>& x);
`
[15](#comp.with.t-15)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L5354)
*Constraints*: T is not a specialization of optional[.](#comp.with.t-15.sentence-1)
The expression v > *x is well-formed and
its result is convertible to bool[.](#comp.with.t-15.sentence-2)
[16](#comp.with.t-16)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L5360)
*Effects*: Equivalent to: return x.has_value() ? v > *x : true;
[🔗](#lib:operator%3c=,optional_)
`template<class T, class U> constexpr bool operator<=(const optional<T>& x, const U& v);
`
[17](#comp.with.t-17)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L5371)
*Constraints*: U is not a specialization of optional[.](#comp.with.t-17.sentence-1)
The expression *x <= v is well-formed and
its result is convertible to bool[.](#comp.with.t-17.sentence-2)
[18](#comp.with.t-18)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L5377)
*Effects*: Equivalent to: return x.has_value() ? *x <= v : true;
[🔗](#lib:operator%3c=,optional__)
`template<class T, class U> constexpr bool operator<=(const T& v, const optional<U>& x);
`
[19](#comp.with.t-19)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L5388)
*Constraints*: T is not a specialization of optional[.](#comp.with.t-19.sentence-1)
The expression v <= *x is well-formed and
its result is convertible to bool[.](#comp.with.t-19.sentence-2)
[20](#comp.with.t-20)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L5394)
*Effects*: Equivalent to: return x.has_value() ? v <= *x : false;
[🔗](#lib:operator%3e=,optional_)
`template<class T, class U> constexpr bool operator>=(const optional<T>& x, const U& v);
`
[21](#comp.with.t-21)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L5405)
*Constraints*: U is not a specialization of optional[.](#comp.with.t-21.sentence-1)
The expression *x >= v is well-formed and
its result is convertible to bool[.](#comp.with.t-21.sentence-2)
[22](#comp.with.t-22)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L5411)
*Effects*: Equivalent to: return x.has_value() ? *x >= v : false;
[🔗](#lib:operator%3e=,optional__)
`template<class T, class U> constexpr bool operator>=(const T& v, const optional<U>& x);
`
[23](#comp.with.t-23)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L5422)
*Constraints*: T is not a specialization of optional[.](#comp.with.t-23.sentence-1)
The expression v >= *x is well-formed and
its result is convertible to bool[.](#comp.with.t-23.sentence-2)
[24](#comp.with.t-24)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L5428)
*Effects*: Equivalent to: return x.has_value() ? v >= *x : true;
[🔗](#lib:operator%3c=%3e,optional__)
`template<class T, class U>
requires (![is-derived-from-optional](#concept:is-derived-from-optional "22.5.2 Header <optional> synopsis [optional.syn]")<U>) && [three_way_comparable_with](cmp.concept#concept:three_way_comparable_with "17.12.4 Concept three_­way_­comparable [cmp.concept]")<T, U>
constexpr compare_three_way_result_t<T, U>
operator<=>(const optional<T>& x, const U& v);
`
[25](#comp.with.t-25)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L5442)
*Effects*: Equivalent to: return x.has_value() ? *x <=> v : strong_ordering​::​less;
### [22.5.10](#specalg) Specialized algorithms [[optional.specalg]](optional.specalg)
[🔗](#lib:swap,optional_)
`template<class T>
constexpr void swap(optional<T>& x, optional<T>& y) noexcept(noexcept(x.swap(y)));
`
[1](#specalg-1)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L5456)
*Constraints*: is_reference_v<T> || (is_move_constructible_v<T> && is_swappable_v<T>) is true[.](#specalg-1.sentence-1)
[2](#specalg-2)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L5463)
*Effects*: Calls x.swap(y)[.](#specalg-2.sentence-1)
[🔗](#lib:make_optional)
`template<class T> constexpr optional<decay_t<T>> make_optional(T&& v);
`
[3](#specalg-3)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L5474)
*Constraints*: The call to make_optional does not use
an explicit [*template-argument-list*](temp.names#nt:template-argument-list "13.3 Names of template specializations [temp.names]") that
begins with a type [*template-argument*](temp.names#nt:template-argument "13.3 Names of template specializations [temp.names]")[.](#specalg-3.sentence-1)
[4](#specalg-4)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L5480)
*Returns*: optional<decay_t<T>>(std​::​forward<T>(v))[.](#specalg-4.sentence-1)
[🔗](#lib:make_optional_)
`template<class T, class...Args>
constexpr optional<T> make_optional(Args&&... args);
`
[5](#specalg-5)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L5492)
*Effects*: Equivalent to: return optional<T>(in_place, std​::​forward<Args>(args)...);
[🔗](#lib:make_optional__)
`template<class T, class U, class... Args>
constexpr optional<T> make_optional(initializer_list<U> il, Args&&... args);
`
[6](#specalg-6)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L5504)
*Effects*: Equivalent to: return optional<T>(in_place, il, std​::​forward<Args>(args)...);
### [22.5.11](#hash) Hash support [[optional.hash]](optional.hash)
[🔗](#lib:hash,optional)
`template<class T> struct hash<optional<T>>;
`
[1](#hash-1)
[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L5517)
The specialization hash<optional<T>> is enabled ([[unord.hash]](unord.hash "22.10.19 Class template hash"))
if and only if hash<remove_const_t<T>> is enabled[.](#hash-1.sentence-1)
When enabled, for an object o of type optional<T>,
if o.has_value() == true, then hash<optional<T>>()(o) evaluates to the same value as hash<remove_const_t<T>>()(*o);
otherwise it evaluates to an unspecified value[.](#hash-1.sentence-2)
The member functions are not guaranteed to be noexcept[.](#hash-1.sentence-3)
Reference in New Issue View Git Blame Copy Permalink