<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml" lang xml:lang>
<head>
  <meta charset="utf-8" />
  <meta name="generator" content="mpark/wg21" />
  <meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes" />
  <meta name="dcterms.date" content="2023-10-15" />
  <title>std::optional\&lt;T&amp;\&gt;</title>
  <style>
      code{white-space: pre-wrap;}
      span.smallcaps{font-variant: small-caps;}
      span.underline{text-decoration: underline;}
      div.column{display: inline-block; vertical-align: top; width: 50%;}
      div.csl-block{margin-left: 1.5em;}
      ul.task-list{list-style: none;}
      pre > code.sourceCode { white-space: pre; position: relative; }
      pre > code.sourceCode > span { display: inline-block; line-height: 1.25; }
      pre > code.sourceCode > span:empty { height: 1.2em; }
      .sourceCode { overflow: visible; }
      code.sourceCode > span { color: inherit; text-decoration: inherit; }
      div.sourceCode { margin: 1em 0; }
      pre.sourceCode { margin: 0; }
      @media screen {
      div.sourceCode { overflow: auto; }
      }
      @media print {
      pre > code.sourceCode { white-space: pre-wrap; }
      pre > code.sourceCode > span { text-indent: -5em; padding-left: 5em; }
      }
      pre.numberSource code
        { counter-reset: source-line 0; }
      pre.numberSource code > span
        { position: relative; left: -4em; counter-increment: source-line; }
      pre.numberSource code > span > a:first-child::before
        { content: counter(source-line);
          position: relative; left: -1em; text-align: right; vertical-align: baseline;
          border: none; display: inline-block;
          -webkit-touch-callout: none; -webkit-user-select: none;
          -khtml-user-select: none; -moz-user-select: none;
          -ms-user-select: none; user-select: none;
          padding: 0 4px; width: 4em;
          color: #aaaaaa;
        }
      pre.numberSource { margin-left: 3em; border-left: 1px solid #aaaaaa;  padding-left: 4px; }
      div.sourceCode
        {  background-color: #f6f8fa; }
      @media screen {
      pre > code.sourceCode > span > a:first-child::before { text-decoration: underline; }
      }
      code span { } /* Normal */
      code span.al { color: #ff0000; } /* Alert */
      code span.an { } /* Annotation */
      code span.at { } /* Attribute */
      code span.bn { color: #9f6807; } /* BaseN */
      code span.bu { color: #9f6807; } /* BuiltIn */
      code span.cf { color: #00607c; } /* ControlFlow */
      code span.ch { color: #9f6807; } /* Char */
      code span.cn { } /* Constant */
      code span.co { color: #008000; font-style: italic; } /* Comment */
      code span.cv { color: #008000; font-style: italic; } /* CommentVar */
      code span.do { color: #008000; } /* Documentation */
      code span.dt { color: #00607c; } /* DataType */
      code span.dv { color: #9f6807; } /* DecVal */
      code span.er { color: #ff0000; font-weight: bold; } /* Error */
      code span.ex { } /* Extension */
      code span.fl { color: #9f6807; } /* Float */
      code span.fu { } /* Function */
      code span.im { } /* Import */
      code span.in { color: #008000; } /* Information */
      code span.kw { color: #00607c; } /* Keyword */
      code span.op { color: #af1915; } /* Operator */
      code span.ot { } /* Other */
      code span.pp { color: #6f4e37; } /* Preprocessor */
      code span.re { } /* RegionMarker */
      code span.sc { color: #9f6807; } /* SpecialChar */
      code span.ss { color: #9f6807; } /* SpecialString */
      code span.st { color: #9f6807; } /* String */
      code span.va { } /* Variable */
      code span.vs { color: #9f6807; } /* VerbatimString */
      code span.wa { color: #008000; font-weight: bold; } /* Warning */
      code.diff {color: #898887}
      code.diff span.va {color: #006e28}
      code.diff span.st {color: #bf0303}
  </style>
  <style type="text/css">
body {
margin: 5em;
font-family: serif;

hyphens: auto;
line-height: 1.35;
text-align: justify;
}
@media screen and (max-width: 30em) {
body {
margin: 1.5em;
}
}
div.wrapper {
max-width: 60em;
margin: auto;
}
ul {
list-style-type: none;
padding-left: 2em;
margin-top: -0.2em;
margin-bottom: -0.2em;
}
a {
text-decoration: none;
color: #4183C4;
}
a.hidden_link {
text-decoration: none;
color: inherit;
}
li {
margin-top: 0.6em;
margin-bottom: 0.6em;
}
h1, h2, h3, h4 {
position: relative;
line-height: 1;
}
a.self-link {
position: absolute;
top: 0;
left: calc(-1 * (3.5rem - 26px));
width: calc(3.5rem - 26px);
height: 2em;
text-align: center;
border: none;
transition: opacity .2s;
opacity: .5;
font-family: sans-serif;
font-weight: normal;
font-size: 83%;
}
a.self-link:hover { opacity: 1; }
a.self-link::before { content: "§"; }
ul > li:before {
content: "\2014";
position: absolute;
margin-left: -1.5em;
}
:target { background-color: #C9FBC9; }
:target .codeblock { background-color: #C9FBC9; }
:target ul { background-color: #C9FBC9; }
.abbr_ref { float: right; }
.folded_abbr_ref { float: right; }
:target .folded_abbr_ref { display: none; }
:target .unfolded_abbr_ref { float: right; display: inherit; }
.unfolded_abbr_ref { display: none; }
.secnum { display: inline-block; min-width: 35pt; }
.header-section-number { display: inline-block; min-width: 35pt; }
.annexnum { display: block; }
div.sourceLinkParent {
float: right;
}
a.sourceLink {
position: absolute;
opacity: 0;
margin-left: 10pt;
}
a.sourceLink:hover {
opacity: 1;
}
a.itemDeclLink {
position: absolute;
font-size: 75%;
text-align: right;
width: 5em;
opacity: 0;
}
a.itemDeclLink:hover { opacity: 1; }
span.marginalizedparent {
position: relative;
left: -5em;
}
li span.marginalizedparent { left: -7em; }
li ul > li span.marginalizedparent { left: -9em; }
li ul > li ul > li span.marginalizedparent { left: -11em; }
li ul > li ul > li ul > li span.marginalizedparent { left: -13em; }
div.footnoteNumberParent {
position: relative;
left: -4.7em;
}
a.marginalized {
position: absolute;
font-size: 75%;
text-align: right;
width: 5em;
}
a.enumerated_item_num {
position: relative;
left: -3.5em;
display: inline-block;
margin-right: -3em;
text-align: right;
width: 3em;
}
div.para { margin-bottom: 0.6em; margin-top: 0.6em; text-align: justify; }
div.section { text-align: justify; }
div.sentence { display: inline; }
span.indexparent {
display: inline;
position: relative;
float: right;
right: -1em;
}
a.index {
position: absolute;
display: none;
}
a.index:before { content: "⟵"; }

a.index:target {
display: inline;
}
.indexitems {
margin-left: 2em;
text-indent: -2em;
}
div.itemdescr {
margin-left: 3em;
}
.bnf {
font-family: serif;
margin-left: 40pt;
margin-top: 0.5em;
margin-bottom: 0.5em;
}
.ncbnf {
font-family: serif;
margin-top: 0.5em;
margin-bottom: 0.5em;
margin-left: 40pt;
}
.ncsimplebnf {
font-family: serif;
font-style: italic;
margin-top: 0.5em;
margin-bottom: 0.5em;
margin-left: 40pt;
background: inherit; 
}
span.textnormal {
font-style: normal;
font-family: serif;
white-space: normal;
display: inline-block;
}
span.rlap {
display: inline-block;
width: 0px;
}
span.descr { font-style: normal; font-family: serif; }
span.grammarterm { font-style: italic; }
span.term { font-style: italic; }
span.terminal { font-family: monospace; font-style: normal; }
span.nonterminal { font-style: italic; }
span.tcode { font-family: monospace; font-style: normal; }
span.textbf { font-weight: bold; }
span.textsc { font-variant: small-caps; }
a.nontermdef { font-style: italic; font-family: serif; }
span.emph { font-style: italic; }
span.techterm { font-style: italic; }
span.mathit { font-style: italic; }
span.mathsf { font-family: sans-serif; }
span.mathrm { font-family: serif; font-style: normal; }
span.textrm { font-family: serif; }
span.textsl { font-style: italic; }
span.mathtt { font-family: monospace; font-style: normal; }
span.mbox { font-family: serif; font-style: normal; }
span.ungap { display: inline-block; width: 2pt; }
span.textit { font-style: italic; }
span.texttt { font-family: monospace; }
span.tcode_in_codeblock { font-family: monospace; font-style: normal; }
span.phantom { color: white; }

span.math { font-style: normal; }
span.mathblock {
display: block;
margin-left: auto;
margin-right: auto;
margin-top: 1.2em;
margin-bottom: 1.2em;
text-align: center;
}
span.mathalpha {
font-style: italic;
}
span.synopsis {
font-weight: bold;
margin-top: 0.5em;
display: block;
}
span.definition {
font-weight: bold;
display: block;
}
.codeblock {
margin-left: 1.2em;
line-height: 127%;
}
.outputblock {
margin-left: 1.2em;
line-height: 127%;
}
div.itemdecl {
margin-top: 2ex;
}
code.itemdeclcode {
white-space: pre;
display: block;
}
span.textsuperscript {
vertical-align: super;
font-size: smaller;
line-height: 0;
}
.footnotenum { vertical-align: super; font-size: smaller; line-height: 0; }
.footnote {
font-size: small;
margin-left: 2em;
margin-right: 2em;
margin-top: 0.6em;
margin-bottom: 0.6em;
}
div.minipage {
display: inline-block;
margin-right: 3em;
}
div.numberedTable {
text-align: center;
margin: 2em;
}
div.figure {
text-align: center;
margin: 2em;
}
table {
border: 1px solid black;
border-collapse: collapse;
margin-left: auto;
margin-right: auto;
margin-top: 0.8em;
text-align: left;
hyphens: none; 
}
td, th {
padding-left: 1em;
padding-right: 1em;
vertical-align: top;
}
td.empty {
padding: 0px;
padding-left: 1px;
}
td.left {
text-align: left;
}
td.right {
text-align: right;
}
td.center {
text-align: center;
}
td.justify {
text-align: justify;
}
td.border {
border-left: 1px solid black;
}
tr.rowsep, td.cline {
border-top: 1px solid black;
}
tr.even, tr.odd {
border-bottom: 1px solid black;
}
tr.capsep {
border-top: 3px solid black;
border-top-style: double;
}
tr.header {
border-bottom: 3px solid black;
border-bottom-style: double;
}
th {
border-bottom: 1px solid black;
}
span.centry {
font-weight: bold;
}
div.table {
display: block;
margin-left: auto;
margin-right: auto;
text-align: center;
width: 90%;
}
span.indented {
display: block;
margin-left: 2em;
margin-bottom: 1em;
margin-top: 1em;
}
ol.enumeratea { list-style-type: none; background: inherit; }
ol.enumerate { list-style-type: none; background: inherit; }

code.sourceCode > span { display: inline; }
</style>
  <link href="data:image/x-icon;base64,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" rel="icon" />
  
  <!--[if lt IE 9]>
    <script src="//cdnjs.cloudflare.com/ajax/libs/html5shiv/3.7.3/html5shiv-printshiv.min.js"></script>
  <![endif]-->
</head>
<body>
<div class="wrapper">
<header id="title-block-header">
<h1 class="title" style="text-align:center">std::optional&lt;T&amp;&gt;</h1>
<table style="border:none;float:right">
  <tr>
    <td>Document #:</td>
    <td>P2988R0</td>
  </tr>
  <tr>
    <td>Date:</td>
    <td>2023-10-15</td>
  </tr>
  <tr>
    <td style="vertical-align:top">Project:</td>
    <td>Programming Language C++</td>
  </tr>
  <tr>
    <td style="vertical-align:top">Audience:</td>
    <td>
      LEWG<br>
    </td>
  </tr>
  <tr>
    <td style="vertical-align:top">Reply-to:</td>
    <td>
      Steve Downey<br>&lt;<a href="mailto:sdowney@gmail.com" class="email">sdowney@gmail.com</a>, <a href="mailto:sdowney2@bloomberg.net" class="email">sdowney2@bloomberg.net</a>&gt;<br>
      Peter Sommerlad<br>&lt;<a href="mailto:peter.cpp@sommerlad.ch" class="email">peter.cpp@sommerlad.ch</a>&gt;<br>
    </td>
  </tr>
</table>
</header>
<div style="clear:both">
<h1 data-number="1" id="abstract"><span class="header-section-number">1</span> Abstract<a href="#abstract" class="self-link"></a></h1>
<p>We propose to fix a hole intentionally left in
<code class="sourceCode default">std::optional</code>: An optional over
a reference such that the post condition on assignment is independent of
the engaged state, always producing a rebound reference, and assigning a
<code class="sourceCode default">U</code> to a
<code class="sourceCode default">T</code> is disallowed by
<code class="sourceCode default">static_assert</code> if a
<code class="sourceCode default">U</code> can not be bound to a
<code class="sourceCode default">T&amp;</code>.</p>
<h1 data-number="2" id="comparison-table"><span class="header-section-number">2</span> Comparison table<a href="#comparison-table" class="self-link"></a></h1>
<p>There are many situations where an optional holding a reference can
come in handy. Here we first look at three possible alternative design
options for an object retrieval function that might fail to find a
corresponding object in a container. Then there are two more examples
showing the inferiority of potential workarounds to the missing
<code class="sourceCode default">std::optional&lt;T&amp;&gt;</code>.</p>
<h2 data-number="2.1" id="using-a-raw-pointer-result-for-an-element-search-function"><span class="header-section-number">2.1</span> Using a raw pointer result for
an element search function<a href="#using-a-raw-pointer-result-for-an-element-search-function" class="self-link"></a></h2>
<p>This is the convention the C++ core guidelines suggest, to use a raw
pointer for representing optional non-owning references. However, there
is a user-required check against
<code class="sourceCode default">nullptr</code>, no type safety meaning
no safety against mis-interpreting such a raw pointer, for example by
using pointer arithmetic on it.</p>
<table>
<thead>
<tr class="header">
<th><div style="text-align:center">
<strong>Before</strong>
</div></th>
<th><div style="text-align:center">
<strong>After</strong>
</div></th>
</tr>
</thead>
<tbody>
<tr class="odd">
<td><div>

<div class="sourceCode" id="cb1"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb1-1"><a href="#cb1-1" aria-hidden="true" tabindex="-1"></a>Cat<span class="op">*</span> cat <span class="op">=</span> find_cat<span class="op">(</span><span class="st">&quot;Fido&quot;</span><span class="op">)</span>;</span>
<span id="cb1-2"><a href="#cb1-2" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="op">(</span>cat<span class="op">!=</span><span class="kw">nullptr</span><span class="op">)</span> <span class="op">{</span> <span class="cf">return</span> doit<span class="op">(*</span>cat<span class="op">)</span>; <span class="op">}</span></span></code></pre></div>

</div></td>
<td><div>

<div class="sourceCode" id="cb2"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb2-1"><a href="#cb2-1" aria-hidden="true" tabindex="-1"></a>std<span class="op">::</span>optional<span class="op">&lt;</span>Cat<span class="op">&amp;&gt;</span> cat <span class="op">=</span> find_cat<span class="op">(</span><span class="st">&quot;Fido&quot;</span><span class="op">)</span>;</span>
<span id="cb2-2"><a href="#cb2-2" aria-hidden="true" tabindex="-1"></a><span class="cf">return</span> cat<span class="op">.</span>and_then<span class="op">(</span>doit<span class="op">)</span>;</span></code></pre></div>

</div></td>
</tr>
</tbody>
</table>
<h2 data-number="2.2" id="returning-result-of-an-element-search-function-via-a-smart-pointer"><span class="header-section-number">2.2</span> returning result of an element
search function via a (smart) pointer<a href="#returning-result-of-an-element-search-function-via-a-smart-pointer" class="self-link"></a></h2>
<p>The disadvantage here is that <code class="sourceCode default">std::experimental::observer_ptr&lt;T&gt;</code>
is both non-standard and not well named, therefore this example uses
<code class="sourceCode default">shared_ptr</code> that would have the
advantage of avoiding dangling through potential lifetime extension.
However, on the downside is still the explicit checks against the
<code class="sourceCode default">nullptr</code> on the client side,
failing so risks undefined behavior.</p>
<table>
<thead>
<tr class="header">
<th><div style="text-align:center">
<strong>Before</strong>
</div></th>
<th><div style="text-align:center">
<strong>After</strong>
</div></th>
</tr>
</thead>
<tbody>
<tr class="odd">
<td><div>

<div class="sourceCode" id="cb3"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb3-1"><a href="#cb3-1" aria-hidden="true" tabindex="-1"></a><span class="co">// use a smart pointer instead of optional&lt;T&amp;&gt;</span></span>
<span id="cb3-2"><a href="#cb3-2" aria-hidden="true" tabindex="-1"></a>std<span class="op">::</span>shared_ptr<span class="op">&lt;</span>Cat<span class="op">&gt;</span> cat <span class="op">=</span> find_cat<span class="op">(</span><span class="st">&quot;Fido&quot;</span><span class="op">)</span>;</span>
<span id="cb3-3"><a href="#cb3-3" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="op">(</span>cat <span class="op">!=</span> <span class="kw">nullptr</span><span class="op">)</span> <span class="op">{...</span></span></code></pre></div>

</div></td>
<td><div>

<div class="sourceCode" id="cb4"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb4-1"><a href="#cb4-1" aria-hidden="true" tabindex="-1"></a>std<span class="op">::</span>optional<span class="op">&lt;</span>Cat<span class="op">&amp;&gt;</span> cat <span class="op">=</span> find_cat<span class="op">(</span><span class="st">&quot;Fido&quot;</span><span class="op">)</span>;</span>
<span id="cb4-2"><a href="#cb4-2" aria-hidden="true" tabindex="-1"></a>cat<span class="op">.</span>and_then<span class="op">([](</span>Cat<span class="op">&amp;</span> thecat<span class="op">){...</span></span></code></pre></div>

</div></td>
</tr>
</tbody>
</table>
<h2 data-number="2.3" id="returning-result-of-an-element-search-function-via-an-iterator"><span class="header-section-number">2.3</span> returning result of an element
search function via an iterator<a href="#returning-result-of-an-element-search-function-via-an-iterator" class="self-link"></a></h2>
<p>This might be the obvious choice, for example, for associative
containers, especially since their iterator stability guarantees.
However, returning such an iterator will leak the underlying container
type as well necessarily requires one to know the sentinel of the
container to check for the not-found case.</p>
<table>
<thead>
<tr class="header">
<th><div style="text-align:center">
<strong>Before</strong>
</div></th>
<th><div style="text-align:center">
<strong>After</strong>
</div></th>
</tr>
</thead>
<tbody>
<tr class="odd">
<td><div>

<div class="sourceCode" id="cb5"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb5-1"><a href="#cb5-1" aria-hidden="true" tabindex="-1"></a>std<span class="op">::</span>map<span class="op">&lt;</span>std<span class="op">::</span>string, Cat<span class="op">&gt;::</span>iterator cat</span>
<span id="cb5-2"><a href="#cb5-2" aria-hidden="true" tabindex="-1"></a>    <span class="op">=</span> find_cat<span class="op">(</span><span class="st">&quot;Fido&quot;</span><span class="op">)</span>;</span>
<span id="cb5-3"><a href="#cb5-3" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="op">(</span>cat <span class="op">!=</span> theunderlyingmap<span class="op">.</span>end<span class="op">()){</span> <span class="op">...</span></span></code></pre></div>

</div></td>
<td><div>

<div class="sourceCode" id="cb6"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb6-1"><a href="#cb6-1" aria-hidden="true" tabindex="-1"></a>std<span class="op">::</span>optional<span class="op">&lt;</span>Cat<span class="op">&amp;&gt;</span> cat <span class="op">=</span> find_cat<span class="op">(</span><span class="st">&quot;Fido&quot;</span><span class="op">)</span>;</span>
<span id="cb6-2"><a href="#cb6-2" aria-hidden="true" tabindex="-1"></a>cat<span class="op">.</span>and_then<span class="op">([](</span>Cat<span class="op">&amp;</span> thecat<span class="op">){...</span></span></code></pre></div>

</div></td>
</tr>
</tbody>
</table>
<h2 data-number="2.4" id="using-an-optionalt-as-a-substitute-for-optionalt"><span class="header-section-number">2.4</span> Using an
<code class="sourceCode default">optional&lt;T*&gt;</code> as a
substitute for
<code class="sourceCode default">optional&lt;T&amp;&gt;</code><a href="#using-an-optionalt-as-a-substitute-for-optionalt" class="self-link"></a></h2>
<p>This approach adds another level of indirection and requires two
checks to take a definite action.</p>
<table>
<thead>
<tr class="header">
<th><div style="text-align:center">
<strong>Before</strong>
</div></th>
<th><div style="text-align:center">
<strong>After</strong>
</div></th>
</tr>
</thead>
<tbody>
<tr class="odd">
<td><div>

<div class="sourceCode" id="cb7"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb7-1"><a href="#cb7-1" aria-hidden="true" tabindex="-1"></a><span class="co">//Mutable optional</span></span>
<span id="cb7-2"><a href="#cb7-2" aria-hidden="true" tabindex="-1"></a>std<span class="op">::</span>optional<span class="op">&lt;</span>Cat<span class="op">*&gt;</span> c <span class="op">=</span> find_cat<span class="op">(</span><span class="st">&quot;Fido&quot;</span><span class="op">)</span>;</span>
<span id="cb7-3"><a href="#cb7-3" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="op">(</span>c<span class="op">)</span> <span class="op">{</span></span>
<span id="cb7-4"><a href="#cb7-4" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="op">(*</span>c<span class="op">)</span> <span class="op">{</span></span>
<span id="cb7-5"><a href="#cb7-5" aria-hidden="true" tabindex="-1"></a>        <span class="op">*</span>c<span class="op">.</span>value<span class="op">()</span> <span class="op">=</span> Cat<span class="op">(</span><span class="st">&quot;Fynn&quot;</span>, color<span class="op">::</span>orange<span class="op">)</span>;</span>
<span id="cb7-6"><a href="#cb7-6" aria-hidden="true" tabindex="-1"></a>    <span class="op">}</span></span>
<span id="cb7-7"><a href="#cb7-7" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></code></pre></div>

</div></td>
<td><div>

<div class="sourceCode" id="cb8"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb8-1"><a href="#cb8-1" aria-hidden="true" tabindex="-1"></a>std<span class="op">::</span>optional<span class="op">&lt;</span>Cat<span class="op">&amp;&gt;</span> c <span class="op">=</span> find_cat<span class="op">(</span><span class="st">&quot;Fido&quot;</span><span class="op">)</span>;</span>
<span id="cb8-2"><a href="#cb8-2" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="op">(</span>c<span class="op">)</span> <span class="op">{</span></span>
<span id="cb8-3"><a href="#cb8-3" aria-hidden="true" tabindex="-1"></a>    <span class="op">*</span>c <span class="op">=</span> Cat<span class="op">(</span><span class="st">&quot;Fynn&quot;</span>, color<span class="op">::</span>orange<span class="op">)</span>;</span>
<span id="cb8-4"><a href="#cb8-4" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span>
<span id="cb8-5"><a href="#cb8-5" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb8-6"><a href="#cb8-6" aria-hidden="true" tabindex="-1"></a><span class="co">//or</span></span>
<span id="cb8-7"><a href="#cb8-7" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb8-8"><a href="#cb8-8" aria-hidden="true" tabindex="-1"></a>o<span class="op">.</span>transform<span class="op">([](</span>Cat<span class="op">&amp;</span> c<span class="op">){</span></span>
<span id="cb8-9"><a href="#cb8-9" aria-hidden="true" tabindex="-1"></a>    c <span class="op">=</span> Cat<span class="op">(</span><span class="st">&quot;Fynn&quot;</span>, color<span class="op">::</span>orange<span class="op">)</span>;</span>
<span id="cb8-10"><a href="#cb8-10" aria-hidden="true" tabindex="-1"></a>    <span class="op">})</span>;</span></code></pre></div>

</div></td>
</tr>
</tbody>
</table>
<h2 data-number="2.5" id="using-optionalreference_wrappert"><span class="header-section-number">2.5</span> Using <code class="sourceCode default">optional&lt;reference_wrapper&lt;T&gt;&gt;</code><a href="#using-optionalreference_wrappert" class="self-link"></a></h2>
<p>While
<code class="sourceCode default">reference_wrapper&lt;T&gt;</code>
implicitly coverts to <code class="sourceCode default">T&amp;</code> in
many practical situation, especially in generic code, such an implicit
conversion is not triggered, thus requiring
<code class="sourceCode default">o.value().get()</code> train wrecks, to
access the wrapped reference, when the optional is engaged. In addition
it lacks the possible optimization of the internal representation of
<code class="sourceCode default">optional&lt;T&amp;&gt;</code>.</p>
<table>
<thead>
<tr class="header">
<th><div style="text-align:center">
<strong>Before</strong>
</div></th>
<th><div style="text-align:center">
<strong>After</strong>
</div></th>
</tr>
</thead>
<tbody>
<tr class="odd">
<td><div>

<div class="sourceCode" id="cb9"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb9-1"><a href="#cb9-1" aria-hidden="true" tabindex="-1"></a><span class="co">// use an optional reference_wrapper instead of optional&lt;T&amp;&gt;</span></span>
<span id="cb9-2"><a href="#cb9-2" aria-hidden="true" tabindex="-1"></a>std<span class="op">::</span>optional<span class="op">&lt;</span>std<span class="op">::</span>reference_wrapper<span class="op">&lt;</span>Cat<span class="op">&gt;&gt;</span> cat <span class="op">=</span> find_cat<span class="op">(</span><span class="st">&quot;Fido&quot;</span><span class="op">)</span>;</span>
<span id="cb9-3"><a href="#cb9-3" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="op">(</span>cat<span class="op">)</span> <span class="op">{</span></span>
<span id="cb9-4"><a href="#cb9-4" aria-hidden="true" tabindex="-1"></a>    cat<span class="op">.</span>value<span class="op">().</span>get<span class="op">()</span> <span class="op">=</span>  Cat<span class="op">(</span><span class="st">&quot;Fynn&quot;</span>, color<span class="op">::</span>orange<span class="op">)</span>;</span>
<span id="cb9-5"><a href="#cb9-5" aria-hidden="true" tabindex="-1"></a><span class="op">...</span></span></code></pre></div>

</div></td>
<td><div>

<div class="sourceCode" id="cb10"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb10-1"><a href="#cb10-1" aria-hidden="true" tabindex="-1"></a>std<span class="op">::</span>optional<span class="op">&lt;</span>Cat<span class="op">&amp;&gt;</span> cat <span class="op">=</span> find_cat<span class="op">(</span><span class="st">&quot;Fido&quot;</span><span class="op">)</span>;</span>
<span id="cb10-2"><a href="#cb10-2" aria-hidden="true" tabindex="-1"></a>cat<span class="op">.</span>and_then<span class="op">([](</span>Cat<span class="op">&amp;</span> thecat<span class="op">){</span></span>
<span id="cb10-3"><a href="#cb10-3" aria-hidden="true" tabindex="-1"></a>    thecat <span class="op">=</span> Cat<span class="op">(</span><span class="st">&quot;Fynn&quot;</span>, color<span class="op">::</span>orange<span class="op">)</span>;</span>
<span id="cb10-4"><a href="#cb10-4" aria-hidden="true" tabindex="-1"></a><span class="op">...</span></span></code></pre></div>

</div></td>
</tr>
</tbody>
</table>
<h1 data-number="3" id="motivation"><span class="header-section-number">3</span> Motivation<a href="#motivation" class="self-link"></a></h1>
<p>Other than the standard library’s implementation of optional,
optionals holding references are common. The desire for such a feature
is well understood, and many optional types in commonly used libraries
provide it, with the semantics proposed here. One standard library
implementation already provides an implementation of
<code class="sourceCode default">std::optional&lt;T&amp;&gt;</code> but
disables its use, because the standard forbids it.</p>
<p>The research in JeanHeyd Meneide’s <em>References for Standard
Library Vocabulary Types - an optional case study.</em> <span class="citation" data-cites="P1683R0">[<a href="#ref-P1683R0" role="doc-biblioref">P1683R0</a>]</span> shows conclusively that rebind
semantics are the only safe semantic as assign through on engaged is too
bug-prone. Implementations that attempt assign-through are abandoned.
The standard library should follow existing practice and supply an
<code class="sourceCode default">optional&lt;T&amp;&gt;</code> that
rebinds on assignment.</p>
<p>Additional background reading on
<code class="sourceCode default">optional&lt;T&amp;&gt;</code> can be
found in JeanHeyd Meneide’s article <em>To Bind and Loose a
Reference</em> <span class="citation" data-cites="REFBIND">[<a href="#ref-REFBIND" role="doc-biblioref">BindRef</a>]</span>.</p>
<p>In freestanding environments or for safety-critical libraries, an
optional type over references is important to implement containers, that
otherwise as the standard library either would cause undefined behavior
when accessing an non-available element, throw an exception, or silently
create the element. Returning a plain pointer for such an optional
reference, as the core guidelines suggest, is a non-type-safe solution
and doesn’t protect in any way from accessing an non-existing element by
a <code class="sourceCode default">nullptr</code> de-reference. In
addition, the monadic APIs of
<code class="sourceCode default">std::optional</code> makes is
especially attractive by streamlining client code receiving such an
optional reference, in contrast to a pointer that requires an explicit
nullptr check and de-reference.</p>
<p>There is a principled reason not to provide a partial specialization
over <code class="sourceCode default">T&amp;</code> as the semantics are
in some ways subtly different than the primary template. Assignment may
have side-effects not present in the primary, which has pure value
semantics. However, I argue this is misleading, as reference semantics
often has side-effects. The proposed semantic is similar to what an
<code class="sourceCode default">optional&lt;std::reference_wrapper&lt;T&gt;&gt;</code>
provides, with much greater usability.</p>
<p>There are well motivated suggestions that perhaps instead of an
<code class="sourceCode default">optional&lt;T&amp;&gt;</code> there
should be an
<code class="sourceCode default">optional_ref&lt;T&gt;</code> that is an
independent primary template. This proposal rejects that, because we
need a policy over all sum types as to how reference semantics should
work, as optional is a variant over T and monostate. That the library
sum type can not express the same range of types as the product type,
tuple, is an increasing problem as we add more types logically
equivalent to a variant. The template types
<code class="sourceCode default">optional</code> and
<code class="sourceCode default">expected</code> should behave as
extensions of
<code class="sourceCode default">variant&lt;T, monostate&gt;</code> and
<code class="sourceCode default">variant&lt;T, E&gt;</code>, or we lose
the ability to reason about generic types.</p>
<p>That we can’t guarantee from
<code class="sourceCode default">std::tuple&lt;Args...&gt;</code>
(product type) that
<code class="sourceCode default">std::variant&lt;Args...&gt;</code> (sum
type) is valid, is a problem, and one that reflection can’t solve. A
language sum type could, but we need agreement on the semantics.</p>
<p>The semantics of a variant with a reference are as if it holds the
address of the referent when referring to that referent. All other
semantics are worse. Not being able to express a variant&lt;T&amp;&gt;
is inconsistent, hostile, and strictly worse than disallowing it.</p>
<p>Thus, we expect future papers to propose
<code class="sourceCode default">std::expected&lt;T&amp;,E&gt;</code>
and <code class="sourceCode default">std::variant</code> with the
ability to hold references. The latter can be used as an iteration type
over <code class="sourceCode default">std::tuple</code> elements.</p>
<h1 data-number="4" id="design"><span class="header-section-number">4</span> Design<a href="#design" class="self-link"></a></h1>
<p>The design is straightforward. The
<code class="sourceCode default">optional&lt;T&amp;&gt;</code> holds a
pointer to the underlying object of type
<code class="sourceCode default">T</code>, or
<code class="sourceCode default">nullptr</code> if the optional is
disengaged. The implementation is simple, especially with C++20 and up
techniques, using concept constraints. As the held pointer is a
primitive regular type with reference semantics, many operations can be
defaulted and are <code class="sourceCode default">noexcept</code> by
nature. See <a href="https://github.com/steve-downey/optional_ref">https://github.com/steve-downey/optional_ref</a>
and <a href="https://github.com/steve-downey/optional_ref/blob/main/src/smd/optional/optional.h">https://github.com/steve-downey/optional_ref/blob/main/src/smd/optional/optional.h</a>
for a reference implementation. The
<code class="sourceCode default">optional&lt;T&amp;&gt;</code>
implementation is less than 200 lines of code, much of it the monadic
functions with identical textual implementations with different
signatures and different overloads being called.</p>
<p>In place construction is not supported as it would just be a way of
providing immediate life-time issues.</p>
<h1 data-number="5" id="shallow-vs-deep-const"><span class="header-section-number">5</span> Shallow vs Deep
<code class="sourceCode default">const</code><a href="#shallow-vs-deep-const" class="self-link"></a></h1>
<p>There is some implementation divergence in optionals about deep const
for <code class="sourceCode default">optional&lt;T&amp;&gt;</code>. That
is, can the referred to <code class="sourceCode default">int</code> be
modified through a
<code class="sourceCode default">const optional&lt;int&amp;&gt;</code>.
Does <code class="sourceCode default">operator-&gt;()</code> return an
<code class="sourceCode default">int*</code> or a
<code class="sourceCode default">const int*</code>, and does
<code class="sourceCode default">operator*()</code> return an
<code class="sourceCode default">int&amp;</code> or a
<code class="sourceCode default">const int&amp;</code>. I believe it is
overall more defensible if the
<code class="sourceCode default">const</code> is shallow as it would be
for a <code class="sourceCode default">struct ref {int * p;}</code>
where the constness of the struct ref does not affect if the p pointer
can be written through. This is consistent with the rebinding behavior
being proposed.</p>
<p>Where deeper constness is desired,
<code class="sourceCode default">optional&lt;const T&amp;&gt;</code>
would prevent non const access to the underlying object.</p>
<h1 data-number="6" id="wording"><span class="header-section-number">6</span> Wording<a href="#wording" class="self-link"></a></h1>
<p>Modify 22.5 Optional Objects</p>
<p>add</p>
<div class="sourceCode" id="cb11"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb11-1"><a href="#cb11-1" aria-hidden="true" tabindex="-1"></a>Class <span class="kw">template</span> optional<span class="op">[</span>optional<span class="op">.</span>optional_ref<span class="op">]</span></span>
<span id="cb11-2"><a href="#cb11-2" aria-hidden="true" tabindex="-1"></a>General<span class="op">[</span>optional<span class="op">.</span>optional_ref<span class="op">.</span>general<span class="op">]</span></span>
<span id="cb11-3"><a href="#cb11-3" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb11-4"><a href="#cb11-4" aria-hidden="true" tabindex="-1"></a><span class="kw">namespace</span> std <span class="op">{</span></span>
<span id="cb11-5"><a href="#cb11-5" aria-hidden="true" tabindex="-1"></a><span class="kw">namespace</span> std <span class="op">{</span></span>
<span id="cb11-6"><a href="#cb11-6" aria-hidden="true" tabindex="-1"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> T<span class="op">&gt;</span></span>
<span id="cb11-7"><a href="#cb11-7" aria-hidden="true" tabindex="-1"></a>  <span class="kw">class</span> optional<span class="op">&lt;</span>T<span class="op">&amp;&gt;</span> <span class="op">{</span></span>
<span id="cb11-8"><a href="#cb11-8" aria-hidden="true" tabindex="-1"></a>  <span class="kw">public</span><span class="op">:</span></span>
<span id="cb11-9"><a href="#cb11-9" aria-hidden="true" tabindex="-1"></a>    <span class="kw">using</span> value_type <span class="op">=</span> T;</span>
<span id="cb11-10"><a href="#cb11-10" aria-hidden="true" tabindex="-1"></a>    <span class="op">[</span>optional_ref<span class="op">.</span>ctor<span class="op">]</span>, constructors</span>
<span id="cb11-11"><a href="#cb11-11" aria-hidden="true" tabindex="-1"></a>         <span class="kw">constexpr</span> optional<span class="op">()</span> <span class="kw">noexcept</span>;</span>
<span id="cb11-12"><a href="#cb11-12" aria-hidden="true" tabindex="-1"></a>         <span class="kw">constexpr</span> optional<span class="op">(</span>nullopt_t<span class="op">)</span> <span class="kw">noexcept</span>;</span>
<span id="cb11-13"><a href="#cb11-13" aria-hidden="true" tabindex="-1"></a>         <span class="kw">constexpr</span> optional<span class="op">(</span><span class="kw">const</span> optional<span class="op">&amp;)</span> <span class="kw">noexcept</span>;</span>
<span id="cb11-14"><a href="#cb11-14" aria-hidden="true" tabindex="-1"></a>         <span class="kw">constexpr</span> optional<span class="op">(</span>optional<span class="op">&amp;&amp;)</span> <span class="kw">noexcept</span>;</span>
<span id="cb11-15"><a href="#cb11-15" aria-hidden="true" tabindex="-1"></a>         <span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> U <span class="op">=</span> T<span class="op">&gt;</span></span>
<span id="cb11-16"><a href="#cb11-16" aria-hidden="true" tabindex="-1"></a>           <span class="kw">constexpr</span> optional<span class="op">(</span>U<span class="op">&amp;&amp;)</span>;</span>
<span id="cb11-17"><a href="#cb11-17" aria-hidden="true" tabindex="-1"></a>         <span class="kw">template</span> <span class="op">&lt;</span><span class="kw">class</span> U<span class="op">&gt;</span></span>
<span id="cb11-18"><a href="#cb11-18" aria-hidden="true" tabindex="-1"></a>           <span class="kw">constexpr</span> <span class="kw">explicit</span> optional<span class="op">(</span><span class="kw">const</span> optional<span class="op">&lt;</span>U<span class="op">&gt;&amp;</span> rhs<span class="op">)</span> <span class="kw">noexcept</span>;</span>
<span id="cb11-19"><a href="#cb11-19" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb11-20"><a href="#cb11-20" aria-hidden="true" tabindex="-1"></a>      <span class="op">[</span>optional_ref<span class="op">.</span>dtor<span class="op">]</span>, destructor</span>
<span id="cb11-21"><a href="#cb11-21" aria-hidden="true" tabindex="-1"></a>         <span class="kw">constexpr</span> <span class="op">~</span>optional<span class="op">()</span>;</span>
<span id="cb11-22"><a href="#cb11-22" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb11-23"><a href="#cb11-23" aria-hidden="true" tabindex="-1"></a>      <span class="op">[</span>optional_ref<span class="op">.</span>assign<span class="op">]</span>, assignment</span>
<span id="cb11-24"><a href="#cb11-24" aria-hidden="true" tabindex="-1"></a>         <span class="kw">constexpr</span> optional<span class="op">&amp;</span> <span class="kw">operator</span><span class="op">=(</span>nullopt_t<span class="op">)</span> <span class="kw">noexcept</span>;</span>
<span id="cb11-25"><a href="#cb11-25" aria-hidden="true" tabindex="-1"></a>         <span class="kw">constexpr</span> optional<span class="op">&amp;</span> <span class="kw">operator</span><span class="op">=(</span><span class="kw">const</span> optional<span class="op">&amp;)</span>;</span>
<span id="cb11-26"><a href="#cb11-26" aria-hidden="true" tabindex="-1"></a>         <span class="kw">constexpr</span> optional<span class="op">&amp;</span> <span class="kw">operator</span><span class="op">=(</span>optional<span class="op">&amp;&amp;)</span> <span class="kw">noexcept</span><span class="op">(</span><span class="co">/* see below */</span><span class="op">)</span>;</span>
<span id="cb11-27"><a href="#cb11-27" aria-hidden="true" tabindex="-1"></a>         <span class="kw">template</span> <span class="op">&lt;</span><span class="kw">class</span> U <span class="op">=</span> T<span class="op">&gt;</span></span>
<span id="cb11-28"><a href="#cb11-28" aria-hidden="true" tabindex="-1"></a>           <span class="kw">constexpr</span> optional<span class="op">&amp;</span> <span class="kw">operator</span><span class="op">=(</span>U<span class="op">&amp;&amp;)</span>;</span>
<span id="cb11-29"><a href="#cb11-29" aria-hidden="true" tabindex="-1"></a>         <span class="kw">template</span> <span class="op">&lt;</span><span class="kw">class</span> U<span class="op">&gt;</span></span>
<span id="cb11-30"><a href="#cb11-30" aria-hidden="true" tabindex="-1"></a>           <span class="kw">constexpr</span> optional<span class="op">&amp;</span> <span class="kw">operator</span><span class="op">=(</span><span class="kw">const</span> optional<span class="op">&lt;</span>U<span class="op">&gt;&amp;)</span>;</span>
<span id="cb11-31"><a href="#cb11-31" aria-hidden="true" tabindex="-1"></a>         <span class="kw">template</span> <span class="op">&lt;</span><span class="kw">class</span> U<span class="op">&gt;</span></span>
<span id="cb11-32"><a href="#cb11-32" aria-hidden="true" tabindex="-1"></a>           <span class="kw">constexpr</span> optional<span class="op">&amp;</span> <span class="kw">operator</span><span class="op">=(</span>optional<span class="op">&lt;</span>U<span class="op">&gt;&amp;&amp;)</span>;</span>
<span id="cb11-33"><a href="#cb11-33" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb11-34"><a href="#cb11-34" aria-hidden="true" tabindex="-1"></a>      <span class="op">[</span>optional_ref<span class="op">.</span>swap<span class="op">]</span>, swap</span>
<span id="cb11-35"><a href="#cb11-35" aria-hidden="true" tabindex="-1"></a>         <span class="kw">constexpr</span> <span class="dt">void</span> swap<span class="op">(</span>optional<span class="op">&amp;)</span> <span class="kw">noexcept</span><span class="op">(</span><span class="co">/* see below */</span><span class="op">)</span>;</span>
<span id="cb11-36"><a href="#cb11-36" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb11-37"><a href="#cb11-37" aria-hidden="true" tabindex="-1"></a>      <span class="op">[</span>optional_ref<span class="op">.</span>observe<span class="op">]</span>, observers</span>
<span id="cb11-38"><a href="#cb11-38" aria-hidden="true" tabindex="-1"></a>         <span class="kw">constexpr</span> T<span class="op">*</span>        <span class="kw">operator</span><span class="op">-&gt;()</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb11-39"><a href="#cb11-39" aria-hidden="true" tabindex="-1"></a>         <span class="kw">constexpr</span> T<span class="op">&amp;</span>        <span class="kw">operator</span><span class="op">*()</span> <span class="kw">const</span><span class="op">&amp;</span> <span class="kw">noexcept</span>;</span>
<span id="cb11-40"><a href="#cb11-40" aria-hidden="true" tabindex="-1"></a>         <span class="kw">constexpr</span> T<span class="op">&amp;&amp;</span>       <span class="kw">operator</span><span class="op">*()</span> <span class="kw">const</span><span class="op">&amp;&amp;</span> <span class="kw">noexcept</span>;</span>
<span id="cb11-41"><a href="#cb11-41" aria-hidden="true" tabindex="-1"></a>         <span class="kw">constexpr</span> <span class="kw">explicit</span>  <span class="kw">operator</span> <span class="dt">bool</span><span class="op">()</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb11-42"><a href="#cb11-42" aria-hidden="true" tabindex="-1"></a>         <span class="kw">constexpr</span> <span class="dt">bool</span>      has_value<span class="op">()</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb11-43"><a href="#cb11-43" aria-hidden="true" tabindex="-1"></a>         <span class="kw">constexpr</span> T<span class="op">&amp;</span>        value<span class="op">()</span> <span class="kw">const</span><span class="op">&amp;</span>;</span>
<span id="cb11-44"><a href="#cb11-44" aria-hidden="true" tabindex="-1"></a>         <span class="kw">constexpr</span> T<span class="op">&amp;&amp;</span> value<span class="op">()</span> <span class="kw">const</span><span class="op">&amp;&amp;</span>;</span>
<span id="cb11-45"><a href="#cb11-45" aria-hidden="true" tabindex="-1"></a>         <span class="kw">template</span> <span class="op">&lt;</span><span class="kw">class</span> U<span class="op">&gt;</span></span>
<span id="cb11-46"><a href="#cb11-46" aria-hidden="true" tabindex="-1"></a>           <span class="kw">constexpr</span> T value_or<span class="op">(</span>U<span class="op">&amp;&amp;)</span> <span class="kw">const</span><span class="op">&amp;</span>;</span>
<span id="cb11-47"><a href="#cb11-47" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb11-48"><a href="#cb11-48" aria-hidden="true" tabindex="-1"></a>      <span class="op">[</span>optional_ref<span class="op">.</span>monadic<span class="op">]</span>, monadic operations</span>
<span id="cb11-49"><a href="#cb11-49" aria-hidden="true" tabindex="-1"></a>         <span class="kw">template</span> <span class="op">&lt;</span><span class="kw">class</span> F<span class="op">&gt;</span></span>
<span id="cb11-50"><a href="#cb11-50" aria-hidden="true" tabindex="-1"></a>           <span class="kw">constexpr</span> <span class="kw">auto</span> and_then<span class="op">(</span>F<span class="op">&amp;&amp;</span> f<span class="op">)</span> <span class="op">&amp;</span>;</span>
<span id="cb11-51"><a href="#cb11-51" aria-hidden="true" tabindex="-1"></a>         <span class="kw">template</span> <span class="op">&lt;</span><span class="kw">class</span> F<span class="op">&gt;</span></span>
<span id="cb11-52"><a href="#cb11-52" aria-hidden="true" tabindex="-1"></a>           <span class="kw">constexpr</span> <span class="kw">auto</span> and_then<span class="op">(</span>F<span class="op">&amp;&amp;</span> f<span class="op">)</span> <span class="op">&amp;&amp;</span>;</span>
<span id="cb11-53"><a href="#cb11-53" aria-hidden="true" tabindex="-1"></a>         <span class="kw">template</span> <span class="op">&lt;</span><span class="kw">class</span> F<span class="op">&gt;</span></span>
<span id="cb11-54"><a href="#cb11-54" aria-hidden="true" tabindex="-1"></a>           <span class="kw">constexpr</span> <span class="kw">auto</span> and_then<span class="op">(</span>F<span class="op">&amp;&amp;</span> f<span class="op">)</span> <span class="kw">const</span><span class="op">&amp;</span>;</span>
<span id="cb11-55"><a href="#cb11-55" aria-hidden="true" tabindex="-1"></a>         <span class="kw">template</span> <span class="op">&lt;</span><span class="kw">class</span> F<span class="op">&gt;</span></span>
<span id="cb11-56"><a href="#cb11-56" aria-hidden="true" tabindex="-1"></a>           <span class="kw">constexpr</span> <span class="kw">auto</span> and_then<span class="op">(</span>F<span class="op">&amp;&amp;</span> f<span class="op">)</span> <span class="kw">const</span><span class="op">&amp;&amp;</span>;</span>
<span id="cb11-57"><a href="#cb11-57" aria-hidden="true" tabindex="-1"></a>         <span class="kw">template</span> <span class="op">&lt;</span><span class="kw">class</span> F<span class="op">&gt;</span></span>
<span id="cb11-58"><a href="#cb11-58" aria-hidden="true" tabindex="-1"></a>           <span class="kw">constexpr</span> <span class="kw">auto</span> transform<span class="op">(</span>F<span class="op">&amp;&amp;</span> f<span class="op">)</span> <span class="op">&amp;</span>;</span>
<span id="cb11-59"><a href="#cb11-59" aria-hidden="true" tabindex="-1"></a>         <span class="kw">template</span> <span class="op">&lt;</span><span class="kw">class</span> F<span class="op">&gt;</span></span>
<span id="cb11-60"><a href="#cb11-60" aria-hidden="true" tabindex="-1"></a>           <span class="kw">constexpr</span> <span class="kw">auto</span> transform<span class="op">(</span>F<span class="op">&amp;&amp;</span> f<span class="op">)</span> <span class="op">&amp;&amp;</span>;</span>
<span id="cb11-61"><a href="#cb11-61" aria-hidden="true" tabindex="-1"></a>         <span class="kw">template</span> <span class="op">&lt;</span><span class="kw">class</span> F<span class="op">&gt;</span></span>
<span id="cb11-62"><a href="#cb11-62" aria-hidden="true" tabindex="-1"></a>           <span class="kw">constexpr</span> <span class="kw">auto</span> transform<span class="op">(</span>F<span class="op">&amp;&amp;</span> f<span class="op">)</span> <span class="kw">const</span><span class="op">&amp;</span>;</span>
<span id="cb11-63"><a href="#cb11-63" aria-hidden="true" tabindex="-1"></a>         <span class="kw">template</span> <span class="op">&lt;</span><span class="kw">class</span> F<span class="op">&gt;</span></span>
<span id="cb11-64"><a href="#cb11-64" aria-hidden="true" tabindex="-1"></a>           <span class="kw">constexpr</span> <span class="kw">auto</span> transform<span class="op">(</span>F<span class="op">&amp;&amp;</span> f<span class="op">)</span> <span class="kw">const</span><span class="op">&amp;&amp;</span>;</span>
<span id="cb11-65"><a href="#cb11-65" aria-hidden="true" tabindex="-1"></a>         <span class="kw">template</span> <span class="op">&lt;</span><span class="kw">class</span> F<span class="op">&gt;</span></span>
<span id="cb11-66"><a href="#cb11-66" aria-hidden="true" tabindex="-1"></a>           <span class="kw">constexpr</span> optional or_else<span class="op">(</span>F<span class="op">&amp;&amp;</span> f<span class="op">)</span> <span class="op">&amp;&amp;</span>;</span>
<span id="cb11-67"><a href="#cb11-67" aria-hidden="true" tabindex="-1"></a>         <span class="kw">template</span> <span class="op">&lt;</span><span class="kw">class</span> F<span class="op">&gt;</span></span>
<span id="cb11-68"><a href="#cb11-68" aria-hidden="true" tabindex="-1"></a>           <span class="kw">constexpr</span> optional or_else<span class="op">(</span>F<span class="op">&amp;&amp;</span> f<span class="op">)</span> <span class="kw">const</span><span class="op">&amp;</span>;</span>
<span id="cb11-69"><a href="#cb11-69" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb11-70"><a href="#cb11-70" aria-hidden="true" tabindex="-1"></a>      <span class="op">[</span>optional_ref<span class="op">.</span>mod<span class="op">]</span>, modifiers</span>
<span id="cb11-71"><a href="#cb11-71" aria-hidden="true" tabindex="-1"></a>         <span class="kw">constexpr</span> <span class="dt">void</span> reset<span class="op">()</span> <span class="kw">noexcept</span>;</span>
<span id="cb11-72"><a href="#cb11-72" aria-hidden="true" tabindex="-1"></a>  <span class="kw">private</span><span class="op">:</span></span>
<span id="cb11-73"><a href="#cb11-73" aria-hidden="true" tabindex="-1"></a>    T <span class="op">*</span>val;         <span class="co">// exposition only</span></span></code></pre></div>
<p>Constructors[optional_ref.ctor]</p>
<div class="sourceCode" id="cb12"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb12-1"><a href="#cb12-1" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> optional<span class="op">()</span> <span class="kw">noexcept</span>;</span>
<span id="cb12-2"><a href="#cb12-2" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb12-3"><a href="#cb12-3" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> optional<span class="op">(</span>nullopt\_t<span class="op">)</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span>
<em>Postconditions</em>: <code class="sourceCode default">*this</code>
does not contain a value.</p>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span>
<em>Remarks</em>: No contained value is initialized. For every object
type <code class="sourceCode default">T</code> these constructors are
<code class="sourceCode default">constexpr</code> constructors
([dcl.constexpr]).</p>
<div class="sourceCode" id="cb13"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb13-1"><a href="#cb13-1" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> optional<span class="op">(</span><span class="kw">const</span> optional<span class="op">&amp;</span> rhs<span class="op">)</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span>
<em>Effects</em>: Initializes
<code class="sourceCode default">val</code> with the value of
<code class="sourceCode default">rhs.val</code></p>
<p><span class="marginalizedparent"><a class="marginalized">4</a></span>
<em>Postconditions</em>: <code class="sourceCode default">rhs.has_value() == this-&gt;has_value()</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">5</a></span>
<em>Remarks</em>: The constructor is trivial.</p>
<div class="sourceCode" id="cb14"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb14-1"><a href="#cb14-1" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> optional<span class="op">(</span>optional<span class="op">&amp;&amp;)</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span>
<em>Effects</em>: Initializes
<code class="sourceCode default">val</code> with the value of
<code class="sourceCode default">rhs.val</code></p>
<p><span class="marginalizedparent"><a class="marginalized">4</a></span>
<em>Postconditions</em>: <code class="sourceCode default">rhs.has_value() == this-&gt;has_value()</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">5</a></span>
<em>Remarks</em>: The constructor is trivial.</p>
<div class="sourceCode" id="cb15"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb15-1"><a href="#cb15-1" aria-hidden="true" tabindex="-1"></a>         <span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> U <span class="op">=</span> T<span class="op">&gt;</span></span>
<span id="cb15-2"><a href="#cb15-2" aria-hidden="true" tabindex="-1"></a>           <span class="kw">constexpr</span> optional<span class="op">(</span>U<span class="op">&amp;&amp;)</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span>
<em>Constraints</em>:</p>
<p><span class="marginalizedparent"><a class="marginalized">(3.1)</a></span> –
<code class="sourceCode default">!is-optional&lt;decay_t&lt;U&gt;&gt;::value is true</code></p>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span>
<em>Mandates</em>:</p>
<p><span class="marginalizedparent"><a class="marginalized">(3.1)</a></span> –
<code class="sourceCode default">std::is_constructible_v&lt;std::add_lvalue_reference_t&lt;T&gt;, U&gt;</code>;</p>
<p><span class="marginalizedparent"><a class="marginalized">(3.1)</a></span> –
<code class="sourceCode default">std::is_lvalue_reference_v&lt;U&gt;</code></p>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span>
<em>Effects</em>: Initializes
<code class="sourceCode default">val</code> with the address of u</p>
<p><span class="marginalizedparent"><a class="marginalized">4</a></span>
<em>Postconditions</em>:
<code class="sourceCode default">this-&gt;has_value() == true</code>.</p>
<div class="sourceCode" id="cb16"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb16-1"><a href="#cb16-1" aria-hidden="true" tabindex="-1"></a>         <span class="kw">template</span> <span class="op">&lt;</span><span class="kw">class</span> U<span class="op">&gt;</span></span>
<span id="cb16-2"><a href="#cb16-2" aria-hidden="true" tabindex="-1"></a>           <span class="kw">constexpr</span> <span class="kw">explicit</span> optional<span class="op">(</span><span class="kw">const</span> optional<span class="op">&lt;</span>U<span class="op">&gt;&amp;</span> rhs<span class="op">)</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span>
<em>Constraints</em>:</p>
<p><span class="marginalizedparent"><a class="marginalized">(3.1)</a></span> –
<code class="sourceCode default">!is-optional&lt;decay_t&lt;U&gt;&gt;::value is true</code></p>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span>
<em>Mandates</em>:</p>
<p><span class="marginalizedparent"><a class="marginalized">(3.1)</a></span> –
<code class="sourceCode default">std::is_constructible_v&lt;std::add_lvalue_reference_t&lt;T&gt;, U&gt;</code>;</p>
<p><span class="marginalizedparent"><a class="marginalized">(3.1)</a></span> –
<code class="sourceCode default">std::is_lvalue_reference&lt;U&gt;::value</code></p>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span>
<em>Effects</em>:</p>
<p>Destructor [optional_ref.dtor]</p>
<div class="sourceCode" id="cb17"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb17-1"><a href="#cb17-1" aria-hidden="true" tabindex="-1"></a>         <span class="kw">constexpr</span> <span class="op">~</span>optional<span class="op">()</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">5</a></span>
<em>Remarks</em>: The destructor is trivial.</p>
<h1 data-number="7" id="bibliography"><span class="header-section-number">7</span> References<a href="#bibliography" class="self-link"></a></h1>
<div id="refs" class="references csl-bib-body hanging-indent" role="doc-bibliography">
<div id="ref-REFBIND" class="csl-entry" role="doc-biblioentry">
[BindRef] JeanHeyd Meneide. To Bind and Loose a Reference. <a href="https://thephd.dev/to-bind-and-loose-a-reference-optional"><div class="csl-block">https://thephd.dev/to-bind-and-loose-a-reference-optional</div></a>
</div>
<div id="ref-P1683R0" class="csl-entry" role="doc-biblioentry">
[P1683R0] JeanHeyd Meneide. 2020-02-29. References for Standard Library
Vocabulary Types - an optional case study. <a href="https://wg21.link/p1683r0"><div class="csl-block">https://wg21.link/p1683r0</div></a>
</div>
</div>
</div>
</div>
</body>
</html>
