<!DOCTYPE html>
<html lang="en"><head>
  <meta content="text/html; charset=UTF-8" http-equiv="Content-Type">
  <meta content="width=device-width, initial-scale=1, shrink-to-fit=no" name="viewport">
  <title>P0323R12: std::expected</title>
<style data-fill-with="stylesheet">/******************************************************************************
 *                   Style sheet for the W3C specifications                   *
 *
 * Special classes handled by this style sheet include:
 *
 * Indices
 *   - .toc for the Table of Contents (<ol class="toc">)
 *     + <span class="secno"> for the section numbers
 *   - #toc for the Table of Contents (<nav id="toc">)
 *   - ul.index for Indices (<a href="#ref">term</a><span>, in § N.M</span>)
 *   - table.index for Index Tables (e.g. for properties or elements)
 *
 * Structural Markup
 *   - table.data for general data tables
 *     -> use 'scope' attribute, <colgroup>, <thead>, and <tbody> for best results !
 *     -> use <table class='complex data'> for extra-complex tables
 *     -> use <td class='long'> for paragraph-length cell content
 *     -> use <td class='pre'> when manual line breaks/indentation would help readability
 *   - dl.switch for switch statements
 *   - ol.algorithm for algorithms (helps to visualize nesting)
 *   - .figure and .caption (HTML4) and figure and figcaption (HTML5)
 *     -> .sidefigure for right-floated figures
 *   - ins/del
 *     -> ins/del.c### for candidate and proposed changes (amendments)
 *
 * Code
 *   - pre and code
 *
 * Special Sections
 *   - .note       for informative notes             (div, p, span, aside, details)
 *   - .example    for informative examples          (div, p, pre, span)
 *   - .issue      for issues                        (div, p, span)
 *   - .advisement for loud normative statements     (div, p, strong)
 *   - .annoying-warning for spec obsoletion notices (div, aside, details)
 *   - .correction for "candidate corrections"       (div, aside, details, section)
 *   - .addition   for "candidate additions"         (div, aside, details, section)
 *   - .correction.proposed for "proposed corrections" (div, aside, details, section)
 *   - .addition.proposed   for "proposed additions"   (div, aside, details, section)
 *
 * Definition Boxes
 *   - pre.def   for WebIDL definitions
 *   - table.def for tables that define other entities (e.g. CSS properties)
 *   - dl.def    for definition lists that define other entitles (e.g. HTML elements)
 *
 * Numbering
 *   - .secno for section numbers in .toc and headings (<span class='secno'>3.2</span>)
 *   - .marker for source-inserted example/figure/issue numbers (<span class='marker'>Issue 4</span>)
 *   - ::before styled for CSS-generated issue/example/figure numbers:
 *     -> Documents wishing to use this only need to add
 *        figcaption::before,
 *        .caption::before { content: "Figure "  counter(figure) " ";  }
 *        .example::before { content: "Example " counter(example) " "; }
 *        .issue::before   { content: "Issue "   counter(issue) " ";   }
 *
 * Header Stuff (ignore, just don't conflict with these classes)
 *   - .head for the header
 *   - .copyright for the copyright
 *
 * Outdated warning for old specs
 *
 * Miscellaneous
 *   - .overlarge for things that should be as wide as possible, even if
 *     that overflows the body text area. This can be used on an item or
 *     on its container, depending on the effect desired.
 *     Note that this styling basically doesn't help at all when printing,
 *     since A4 paper isn't much wider than the max-width here.
 *     It's better to design things to fit into a narrower measure if possible.
 *
 *   - js-added ToC jump links (see fixup.js)
 *
 ******************************************************************************/

/* color variables included separately for reliability */

/******************************************************************************/
/*                                    Body                                    */
/******************************************************************************/

	html {
	}

	body {
		counter-reset: example figure issue;

		/* Layout */
		max-width: 50em;			  /* limit line length to 50em for readability   */
		margin: 0 auto;				/* center text within page                    */
		padding: 1.6em 1.5em 2em 50px; /* assume 16px font size for downlevel clients */
		padding: 1.6em 1.5em 2em calc(26px + 1.5em); /* leave space for status flag    */

		/* Typography */
		line-height: 1.5;
		font-family: sans-serif;
		widows: 2;
		orphans: 2;
		word-wrap: break-word;
		overflow-wrap: break-word;
		hyphens: auto;

		color: black;
		color: var(--text);
		background: white top left fixed no-repeat;
		background: var(--bg) top left fixed no-repeat;
		background-size: 25px auto;
	}


/******************************************************************************/
/*                         Front Matter & Navigation                          */
/******************************************************************************/

/** Header ********************************************************************/

	div.head { margin-bottom: 1em; }
	div.head hr { border-style: solid; }

	div.head h1 {
		font-weight: bold;
		margin: 0 0 .1em;
		font-size: 220%;
	}

	div.head h2 { margin-bottom: 1.5em;}

/** W3C Logo ******************************************************************/

	.head .logo {
		float: right;
		margin: 0.4rem 0 0.2rem .4rem;
	}

	.head img[src*="logos/W3C"] {
		display: block;
		border: solid #1a5e9a;
		border: solid var(--logo-bg);
		border-width: .65rem .7rem .6rem;
		border-radius: .4rem;
		background: #1a5e9a;
		background: var(--logo-bg);
		color: white;
		color: var(--logo-text);
		font-weight: bold;
	}

	.head a:hover > img[src*="logos/W3C"],
	.head a:focus > img[src*="logos/W3C"] {
		opacity: .8;
	}

	.head a:active > img[src*="logos/W3C"] {
		background: #c00;
		background: var(--logo-active-bg);
		border-color: #c00;
		border-color: var(--logo-active-bg);
	}

	/* see also additional rules in Link Styling section */

/** Copyright *****************************************************************/

	p.copyright,
	p.copyright small { font-size: small; }

/** Back to Top / ToC Toggle **************************************************/

	@media print {
		#toc-nav {
			display: none;
		}
	}
	@media not print {
		#toc-nav {
			position: fixed;
			z-index: 3;
			bottom: 0; left: 0;
			margin: 0;
			min-width: 1.33em;
			border-top-right-radius: 2rem;
			box-shadow: 0 0 2px;
			font-size: 1.5em;
		}
		#toc-nav > a {
			display: block;
			white-space: nowrap;

			height: 1.33em;
			padding: .1em 0.3em;
			margin: 0;

			box-shadow: 0 0 2px;
			border: none;
			border-top-right-radius: 1.33em;

			color: #707070;
			color: var(--tocnav-normal-text);
			background: white;
			background: var(--tocnav-normal-bg);
		}
		#toc-nav > a:hover,
		#toc-nav > a:focus {
			color: black;
			color: var(--tocnav-hover-text);
			background: #f8f8f8;
			background: var(--tocnav-hover-bg);
		}
		#toc-nav > a:active {
			color: #c00;
			color: var(--tocnav-active-text);
			background: white;
			background: var(--tocnav-active-bg);
		}

		#toc-nav > #toc-jump {
			padding-bottom: 2em;
			margin-bottom: -1.9em;
		}

		/* statusbar gets in the way on keyboard focus; remove once browsers fix */
		#toc-nav > a[href="#toc"]:not(:hover):focus:last-child {
			padding-bottom: 1.5rem;
		}

		#toc-nav:not(:hover) > a:not(:focus) > span + span {
			/* Ideally this uses :focus-within on #toc-nav */
			display: none;
		}
		#toc-nav > a > span + span {
			padding-right: 0.2em;
		}
	}

/** ToC Sidebar ***************************************************************/

	/* Floating sidebar */
	@media screen {
		body.toc-sidebar #toc {
			position: fixed;
			top: 0; bottom: 0;
			left: 0;
			width: 23.5em;
			max-width: 80%;
			max-width: calc(100% - 2em - 26px);
			overflow: auto;
			padding: 0 1em;
			padding-left: 42px;
			padding-left: calc(1em + 26px);
			color: black;
			color: var(--tocsidebar-text);
			background: inherit;
			background-color: #f7f8f9;
			background-color: var(--tocsidebar-bg);
			z-index: 1;
			box-shadow: -.1em 0 .25em rgba(0,0,0,.1) inset;
			box-shadow: -.1em 0 .25em var(--tocsidebar-shadow) inset;
		}
		body.toc-sidebar #toc h2 {
			margin-top: .8rem;
			font-variant: small-caps;
			font-variant: all-small-caps;
			text-transform: lowercase;
			font-weight: bold;
			color: gray;
			color: hsla(203,20%,40%,.7);
			color: var(--tocsidebar-heading-text);
		}
		body.toc-sidebar #toc-jump:not(:focus) {
			width: 0;
			height: 0;
			padding: 0;
			position: absolute;
			overflow: hidden;
		}
	}
	/* Hide main scroller when only the ToC is visible anyway */
	@media screen and (max-width: 28em) {
		body.toc-sidebar {
			overflow: hidden;
		}
	}

	/* Sidebar with its own space */
	@media screen and (min-width: 78em) {
		body:not(.toc-inline) #toc {
			position: fixed;
			top: 0; bottom: 0;
			left: 0;
			width: 23.5em;
			overflow: auto;
			padding: 0 1em;
			padding-left: 42px;
			padding-left: calc(1em + 26px);
			color: black;
			color: var(--tocsidebar-text);
			background: inherit;
			background-color: #f7f8f9;
			background-color: var(--tocsidebar-bg);
			z-index: 1;
			box-shadow: -.1em 0 .25em rgba(0,0,0,.1) inset;
			box-shadow: -.1em 0 .25em var(--tocsidebar-shadow) inset;
		}
		body:not(.toc-inline) #toc h2 {
			margin-top: .8rem;
			font-variant: small-caps;
			font-variant: all-small-caps;
			text-transform: lowercase;
			font-weight: bold;
			color: gray;
			color: hsla(203,20%,40%,.7);
			color: var(--tocsidebar-heading-text);
		}

		body:not(.toc-inline) {
			padding-left: 29em;
		}
		/* See also Overflow section at the bottom */

		body:not(.toc-inline) #toc-jump:not(:focus) {
			width: 0;
			height: 0;
			padding: 0;
			position: absolute;
			overflow: hidden;
		}
	}
	@media screen and (min-width: 90em) {
		body:not(.toc-inline) {
			margin: 0 4em;
		}
	}

/******************************************************************************/
/*                                Sectioning                                  */
/******************************************************************************/

/** Headings ******************************************************************/

	h1, h2, h3, h4, h5, h6, dt {
		page-break-after: avoid;
		page-break-inside: avoid;
		font: 100% sans-serif;   /* Reset all font styling to clear out UA styles */
		font-family: inherit;	/* Inherit the font family. */
		line-height: 1.2;		/* Keep wrapped headings compact */
		hyphens: manual;		/* Hyphenated headings look weird */
	}

	h2, h3, h4, h5, h6 {
		margin-top: 3rem;
	}

	h1, h2, h3 {
		color: #005A9C;
		color: var(--heading-text);
	}

	h1 { font-size: 170%; }
	h2 { font-size: 140%; }
	h3 { font-size: 120%; }
	h4 { font-weight: bold; }
	h5 { font-style: italic; }
	h6 { font-variant: small-caps; }
	dt { font-weight: bold; }

/** Subheadings ***************************************************************/

	h1 + h2,
	#profile-and-date {
		/* #profile-and-date is a subtitle in an H2 under the H1 */
		margin-top: 0;
	}
	h2 + h3,
	h3 + h4,
	h4 + h5,
	h5 + h6 {
		margin-top: 1.2em; /* = 1 x line-height */
	}

/** Section divider ***********************************************************/

	:not(.head) > :not(.head) + hr {
		font-size: 1.5em;
		text-align: center;
		margin: 1em auto;
		height: auto;
		color: black;
		color: var(--hr-text);
		border: transparent solid 0;
		background: transparent;
	}
	:not(.head) > hr::before {
		content: "\2727\2003\2003\2727\2003\2003\2727";
	}

/******************************************************************************/
/*                            Paragraphs and Lists                            */
/******************************************************************************/

	p {
		margin: 1em 0;
	}

	dd > p:first-child,
	li > p:first-child {
		margin-top: 0;
	}

	ul, ol {
		margin-left: 0;
		padding-left: 2em;
	}

	li {
		margin: 0.25em 0 0.5em;
		padding: 0;
	}

	dl dd {
		margin: 0 0 .5em 2em;
	}

	.head dd + dd { /* compact for header */
		margin-top: -.5em;
	}

	/* Style for algorithms */
	ol.algorithm ol:not(.algorithm),
	.algorithm > ol ol:not(.algorithm) {
	border-left: 0.5em solid #DEF;
	border-left: 0.5em solid var(--algo-border);
	}

	/* Put nice boxes around each algorithm. */
	[data-algorithm]:not(.heading) {
	 padding: .5em;
	 border: thin solid #ddd;
	 border: thin solid var(--algo-border);
	 border-radius: .5em;
	 margin: .5em calc(-0.5em - 1px);
	}
	[data-algorithm]:not(.heading) > :first-child {
	 margin-top: 0;
	}
	[data-algorithm]:not(.heading) > :last-child {
	 margin-bottom: 0;
	}

	/* Style for switch/case <dl>s */
	dl.switch > dd > ol.only,
	dl.switch > dd > .only > ol {
	margin-left: 0;
	}
	dl.switch > dd > ol.algorithm,
	dl.switch > dd > .algorithm > ol {
	margin-left: -2em;
	}
	dl.switch {
	padding-left: 2em;
	}
	dl.switch > dt {
	text-indent: -1.5em;
	margin-top: 1em;
	}
	dl.switch > dt + dt {
	margin-top: 0;
	}
	dl.switch > dt::before {
	content: '\21AA';
	padding: 0 0.5em 0 0;
	display: inline-block;
	width: 1em;
	text-align: right;
	line-height: 0.5em;
	}

/** Terminology Markup ********************************************************/


/******************************************************************************/
/*                                 Inline Markup                              */
/******************************************************************************/

/** Terminology Markup ********************************************************/
	dfn   { /* Defining instance */
		font-weight: bolder;
	}
	a > i { /* Instance of term */
		font-style: normal;
	}
	dt dfn code, code.idl {
		font-size: inherit;
	}
	dfn var {
		font-style: normal;
	}

/** Change Marking ************************************************************/

	del {
		color: #aa0000;
		color: var(--del-text);
		background: transparent;
		background: var(--del-bg);
		text-decoration: line-through;
	}
	ins {
		color: #006100;
		color: var(--ins-text);
		background: transparent;
		background: var(--ins-bg);
		text-decoration: underline;
	}

	/* for amendments (candidate/proposed changes) */

	.amendment ins, .correction ins, .addition ins,
	ins[class^=c] {
		text-decoration-style: dotted;
	}
	.amendment del, .correction del, .addition del,
	del[class^=c] {
		text-decoration-style: dotted;
	}
	.amendment.proposed ins, .correction.proposed ins, .addition.proposed ins,
	ins[class^=c].proposed {
		text-decoration-style: double;
	}
	.amendment.proposed del, .correction.proposed del, .addition.proposed del,
	del[class^=c].proposed {
		text-decoration-style: double;
	}

/** Miscellaneous improvements to inline formatting ***************************/

	sup {
		vertical-align: super;
		font-size: 80%
	}

/******************************************************************************/
/*                                    Code                                    */
/******************************************************************************/

/** General monospace/pre rules ***********************************************/

	pre, code, samp {
		font-family: Menlo, Consolas, "DejaVu Sans Mono", Monaco, monospace;
		font-size: .9em;
		hyphens: none;
		text-transform: none;
		text-align: left;
		text-align: start;
		font-variant: normal;
		orphans: 3;
		widows: 3;
		page-break-before: avoid;
	}
	pre code,
	code code {
		font-size: 100%;
	}

	pre {
		margin-top: 1em;
		margin-bottom: 1em;
		overflow: auto;
	}

/** Inline Code fragments *****************************************************/

	/* Do something nice. */

/******************************************************************************/
/*                                    Links                                   */
/******************************************************************************/

/** General Hyperlinks ********************************************************/

	/* We hyperlink a lot, so make it less intrusive */
	a[href] {
		color: #034575;
		color: var(--a-normal-text);
		text-decoration: underline #707070;
		text-decoration: underline var(--a-normal-underline);
		text-decoration-skip-ink: none;
	}
	a:visited {
		color: #034575;
		color: var(--a-visited-text);
		text-decoration-color: #bbb;
		text-decoration-color: var(--a-visited-underline);
	}

	/* Indicate interaction with the link */
	a[href]:focus,
	a[href]:hover {
		text-decoration-thickness: 2px;
	}
	a[href]:active {
		color: #c00;
		color: var(--a-active-text);
		text-decoration-color: #c00;
		text-decoration-color: var(--a-active-underline);
	}

	/* Backout above styling for W3C logo */
	.head .logo,
	.head .logo a {
		border: none;
		text-decoration: none;
		background: transparent;
	}

/******************************************************************************/
/*                                    Images                                  */
/******************************************************************************/

	img {
		border-style: none;
	}

	img, svg {
		/* Intentionally not color-scheme aware. */
		background: white;
	}

	/* For autogen numbers, add
	  .caption::before, figcaption::before { content: "Figure " counter(figure) ". "; }
	*/

	figure, .figure, .sidefigure {
		page-break-inside: avoid;
		text-align: center;
		margin: 2.5em 0;
	}
	.figure img,	.sidefigure img,	figure img,
	.figure object, .sidefigure object, figure object {
		max-width: 100%;
		margin: auto;
		height: auto;
	}
	.figure pre, .sidefigure pre, figure pre {
		text-align: left;
		display: table;
		margin: 1em auto;
	}
	.figure table, figure table {
		margin: auto;
	}
	@media screen and (min-width: 20em) {
		.sidefigure {
			float: right;
			width: 50%;
			margin: 0 0 0.5em 0.5em;
		}
	}
	.caption, figcaption, caption {
		font-style: italic;
		font-size: 90%;
	}
	.caption::before, figcaption::before, figcaption > .marker {
		font-weight: bold;
	}
	.caption, figcaption {
		counter-increment: figure;
	}

	/* DL list is indented 2em, but figure inside it is not */
	dd > .figure, dd > figure { margin-left: -2em; }

/******************************************************************************/
/*                             Colored Boxes                                  */
/******************************************************************************/

	.issue, .note, .example, .assertion, .advisement, blockquote,
	.amendment, .correction, .addition {
		margin: 1em auto;
		padding: .5em;
		border: .5em;
		border-left-style: solid;
		page-break-inside: avoid;
	}
	span.issue, span.note {
		padding: .1em .5em .15em;
		border-right-style: solid;
	}

	blockquote > :first-child,
	.note  > p:first-child,
	.issue > p:first-child,
	.amendment > p:first-child,
	.correction > p:first-child,
	.addition > p:first-child {
		margin-top: 0;
	}
	blockquote > :last-child,
	.note  > p:last-child,
	.issue > p:last-child,
	.amendment > p:last-child,
	.correction > p:last-child,
	.addition > p:last-child {
		margin-bottom: 0;
	}


	.issue::before, .issue > .marker,
	.example::before, .example > .marker,
	.note::before, .note > .marker,
	details.note > summary > .marker,
	.amendment::before, .amendment > .marker,
	details.amendment > summary > .marker,
	.addition::before, .addition > .marker,
	addition.amendment > summary > .marker,
	.correction::before, .correction > .marker,
	correction.amendment > summary > .marker
	{
		text-transform: uppercase;
		padding-right: 1em;
	}

	.example::before, .example > .marker {
		display: block;
		padding-right: 0em;
	}

/** Blockquotes ***************************************************************/

	blockquote {
		border-color: silver;
		border-color: var(--blockquote-border);
		background: transparent;
		background: var(--blockquote-bg);
		color: currentcolor;
		color: var(--blockquote-text);
	}

/** Open issue ****************************************************************/

	.issue {
		border-color: #e05252;
		border-color: var(--issue-border);
		background: #fbe9e9;
		background: var(--issue-bg);
		color: black;
		color: var(--issue-text);
		counter-increment: issue;
		overflow: auto;
	}
	.issue::before, .issue > .marker {
		color: #831616;
		color: var(--issueheading-text);
	}
	/* Add .issue::before { content: "Issue " counter(issue) " "; } for autogen numbers,
	  or use class="marker" to mark up the issue number in source. */

/** Example *******************************************************************/

	.example {
		border-color: #e0cb52;
		border-color: var(--example-border);
		background: #fcfaee;
		background: var(--example-bg);
		color: black;
		color: var(--example-text);
		counter-increment: example;
		overflow: auto;
		clear: both;
	}
	.example::before, .example > .marker {
		color: #574b0f;
		color: var(--exampleheading-text);
	}
	/* Add .example::before { content: "Example " counter(example) " "; } for autogen numbers,
	  or use class="marker" to mark up the example number in source. */

/** Non-normative Note ********************************************************/

	.note {
		border-color: #52e052;
		border-color: var(--note-border);
		background: #e9fbe9;
		background: var(--note-bg);
		color: black;
		color: var(--note-text);
		overflow: auto;
	}

	.note::before, .note > .marker,
	details.note > summary {
		color: hsl(120, 70%, 30%);
		color: var(--noteheading-text);
	}
	/* Add .note::before { content: "Note "; } for autogen label,
	  or use class="marker" to mark up the label in source. */

	details.note[open] > summary {
		border-bottom: 1px silver solid;
		border-bottom: 1px var(--notesummary-underline) solid;
	}

/** Assertion Box *************************************************************/
	/*  for assertions in algorithms */

	.assertion {
		border-color: #AAA;
		border-color: var(--assertion-border);
		background: #EEE;
		background: var(--assertion-bg);
		color: black;
		color: var(--assertion-text);
	}

/** Advisement Box ************************************************************/
	/*  for attention-grabbing normative statements */

	.advisement {
		border-color: orange;
		border-color: var(--advisement-border);
		border-style: none solid;
		background: #fec;
		background: var(--advisement-bg);
		color: black;
		color: var(--advisement-text);
	}
	strong.advisement {
		display: block;
		text-align: center;
	}
	.advisement::before, .advisement > .marker {
		color: #b35f00;
		color: var(--advisementheading-text);
	}

/** Amendment Box *************************************************************/

	.amendment, .correction, .addition {
		border-color: #330099;
		border-color: var(--amendment-border);
		background: #F5F0FF;
		background: var(--amendment-bg);
		color: black;
		color: var(--amendment-text);
	}
	.amendment.proposed, .correction.proposed, .addition.proposed {
		border-style: solid;
		border-block-width: 0.25em;
	}
	.amendment::before, .amendment > .marker,
	details.amendment > summary::before, details.amendment > summary > .marker,
	.correction::before, .correction > .marker,
	details.correction > summary::before, details.correction > summary > .marker,
	.addition::before, .addition > .marker,
	details.addition > summary::before, details.addition > summary > .marker {
		color: #220066;
		color: var(--amendmentheading-text);
	}
	.amendment.proposed::before, .amendment.proposed > .marker,
	details.amendment.proposed > summary::before, details.amendment.proposed > summary > .marker,
	.correction.proposed::before, .correction.proposed > .marker,
	details.correction.proposed > summary::before, details.correction.proposed > summary > .marker,
	.addition.proposed::before, .addition.proposed > .marker,
	details.addition.proposed > summary::before, details.addition.proposed > summary > .marker {
		font-weight: bold;
	}

/** Spec Obsoletion Notice ****************************************************/
	/* obnoxious obsoletion notice for older/abandoned specs. */

	details {
		display: block;
	}
	summary {
		font-weight: bolder;
	}

	.annoying-warning:not(details),
	details.annoying-warning:not([open]) > summary,
	details.annoying-warning[open] {
		background: hsla(40,100%,50%,0.95);
		background: var(--warning-bg);
		color: black;
		color: var(--warning-text);
		padding: .75em 1em;
		border: red;
		border: var(--warning-border);
		border-style: solid none;
		box-shadow: 0 2px 8px black;
		text-align: center;
	}
	.annoying-warning :last-child {
		margin-bottom: 0;
	}

@media not print {
	details.annoying-warning[open] {
		position: fixed;
		left: 0;
		right: 0;
		bottom: 2em;
		z-index: 1000;
	}
}

	details.annoying-warning:not([open]) > summary {
		text-align: center;
	}

/** Entity Definition Boxes ***************************************************/

	.def {
		padding: .5em 1em;
		background: #def;
		background: var(--def-bg);
		margin: 1.2em 0;
		border-left: 0.5em solid #8ccbf2;
		border-left: 0.5em solid var(--def-border);
		color: black;
		color: var(--def-text);
	}

/******************************************************************************/
/*                                    Tables                                  */
/******************************************************************************/

	th, td {
		text-align: left;
		text-align: start;
	}

/** Property/Descriptor Definition Tables *************************************/

	table.def {
		/* inherits .def box styling, see above */
		width: 100%;
		border-spacing: 0;
	}

	table.def td,
	table.def th {
		padding: 0.5em;
		vertical-align: baseline;
		border-bottom: 1px solid #bbd7e9;
		border-bottom: 1px solid var(--defrow-border);
	}

	table.def > tbody > tr:last-child th,
	table.def > tbody > tr:last-child td {
		border-bottom: 0;
	}

	table.def th {
		font-style: italic;
		font-weight: normal;
		padding-left: 1em;
		width: 3em;
	}

	/* For when values are extra-complex and need formatting for readability */
	table td.pre {
		white-space: pre-wrap;
	}

	/* A footnote at the bottom of a def table */
	table.def td.footnote {
		padding-top: 0.6em;
	}
	table.def td.footnote::before {
		content: " ";
		display: block;
		height: 0.6em;
		width: 4em;
		border-top: thin solid;
	}

/** Data tables (and properly marked-up index tables) *************************/
	/*
		<table class="data"> highlights structural relationships in a table
		when correct markup is used (e.g. thead/tbody, th vs. td, scope attribute)

		Use class="complex data" for particularly complicated tables --
		(This will draw more lines: busier, but clearer.)

		Use class="long" on table cells with paragraph-like contents
		(This will adjust text alignment accordingly.)
		Alternately use class="longlastcol" on tables, to have the last column assume "long".
	*/

	table {
		word-wrap: normal;
		overflow-wrap: normal;
		hyphens: manual;
	}

	table.data,
	table.index {
		margin: 1em auto;
		border-collapse: collapse;
		border: hidden;
		width: 100%;
	}
	table.data caption,
	table.index caption {
		max-width: 50em;
		margin: 0 auto 1em;
	}

	table.data td,  table.data th,
	table.index td, table.index th {
		padding: 0.5em 1em;
		border-width: 1px;
		border-color: silver;
		border-color: var(--datacell-border);
		border-top-style: solid;
	}

	table.data thead td:empty {
		padding: 0;
		border: 0;
	}

	table.data  thead,
	table.index thead,
	table.data  tbody,
	table.index tbody {
		border-bottom: 2px solid;
	}

	table.data colgroup,
	table.index colgroup {
		border-left: 2px solid;
	}

	table.data  tbody th:first-child,
	table.index tbody th:first-child  {
		border-right: 2px solid;
		border-top: 1px solid silver;
		border-top: 1px solid var(--datacell-border);
		padding-right: 1em;
	}

	table.data th[colspan],
	table.data td[colspan] {
		text-align: center;
	}

	table.complex.data th,
	table.complex.data td {
		border: 1px solid silver;
		border: 1px solid var(--datacell-border);
		text-align: center;
	}

	table.data.longlastcol td:last-child,
	table.data td.long {
		vertical-align: baseline;
		text-align: left;
	}

	table.data img {
		vertical-align: middle;
	}


/*
Alternate table alignment rules

	table.data,
	table.index {
		text-align: center;
	}

	table.data  thead th[scope="row"],
	table.index thead th[scope="row"] {
		text-align: right;
	}

	table.data  tbody th:first-child,
	table.index tbody th:first-child  {
		text-align: right;
	}

Possible extra rowspan handling

	table.data  tbody th[rowspan]:not([rowspan='1']),
	table.index tbody th[rowspan]:not([rowspan='1']),
	table.data  tbody td[rowspan]:not([rowspan='1']),
	table.index tbody td[rowspan]:not([rowspan='1']) {
		border-left: 1px solid silver;
	}

	table.data  tbody th[rowspan]:first-child,
	table.index tbody th[rowspan]:first-child,
	table.data  tbody td[rowspan]:first-child,
	table.index tbody td[rowspan]:first-child{
		border-left: 0;
		border-right: 1px solid silver;
	}
*/

/******************************************************************************/
/*                                  Indices                                   */
/******************************************************************************/


/** Table of Contents *********************************************************/

	.toc a {
		/* More spacing; use padding to make it part of the click target. */
		padding: 0.1rem 1px 0;
		/* Larger, more consistently-sized click target */
		display: block;
		/* Switch to using border-bottom for underlines */
		text-decoration: none;
		border-bottom: 1px solid;
		/* Reverse color scheme */
		color: black;
		color: var(--toclink-text);
		border-color: #3980b5;
		border-color: var(--toclink-underline);
	}
	.toc a:visited {
		color: black;
		color: var(--toclink-visited-text);
		border-color: #054572;
		border-color: var(--toclink-visited-underline);
	}
	.toc a:focus,
	.toc a:hover {
		background: rgba(75%, 75%, 75%, .25);
		background: var(--a-hover-bg);
		border-bottom-width: 3px;
		margin-bottom: -2px;
	}
	.toc a:not(:focus):not(:hover) {
		/* Allow colors to cascade through from link styling */
		border-bottom-color: transparent;
	}

	.toc, .toc ol, .toc ul, .toc li {
		list-style: none; /* Numbers must be inlined into source */
		/* because generated content isn't search/selectable and markers can't do multilevel yet */
		margin:  0;
		padding: 0;
	}
	.toc {
		line-height: 1.1em;
	}

	/* ToC not indented until third level, but font style & margins show hierarchy */
	.toc > li			{ font-weight: bold;   }
	.toc > li li		 { font-weight: normal; }
	.toc > li li li	  { font-size:   95%;	}
	.toc > li li li li	{ font-size:   90%;	}
	.toc > li li li li li { font-size:   85%;	}

	/* @supports not (display:grid) { */
		.toc > li			{ margin: 1.5rem 0;	}
		.toc > li li		 { margin: 0.3rem 0;	}
		.toc > li li li	  { margin-left: 2rem;   }

		/* Section numbers in a column of their own */
		.toc .secno {
			float: left;
			width: 4rem;
			white-space: nowrap;
		}
		.toc > li li li li .secno { font-size: 85%; }
		.toc > li li li li li .secno { font-size: 100%; }

		.toc li {
			clear: both;
		}

		:not(li) > .toc			 { margin-left:  5rem; }
		.toc .secno				 { margin-left: -5rem; }
		.toc > li li li .secno	  { margin-left: -7rem; }
		.toc > li li li li .secno	{ margin-left: -9rem; }
		.toc > li li li li li .secno { margin-left: -11rem; }

		/* Tighten up indentation in narrow ToCs */
		@media (max-width: 30em) {
			:not(li) > .toc			 { margin-left:  4rem; }
			.toc .secno				 { margin-left: -4rem; }
			.toc > li li li			 { margin-left:  1rem; }
			.toc > li li li .secno	  { margin-left: -5rem; }
			.toc > li li li li .secno	{ margin-left: -6rem; }
			.toc > li li li li li .secno { margin-left: -7rem; }
		}
		/* Loosen it on wide screens */
		@media screen and (min-width: 78em) {
			body:not(.toc-inline) :not(li) > .toc			 { margin-left:  4rem; }
			body:not(.toc-inline) .toc .secno				 { margin-left: -4rem; }
			body:not(.toc-inline) .toc > li li li			 { margin-left:  1rem; }
			body:not(.toc-inline) .toc > li li li .secno	  { margin-left: -5rem; }
			body:not(.toc-inline) .toc > li li li li .secno	{ margin-left: -6rem; }
			body:not(.toc-inline) .toc > li li li li li .secno { margin-left: -7rem; }
	}
	/* } */

	@supports (display:grid) and (display:contents) {
		/* Use #toc over .toc to override non-@supports rules. */
		#toc {
			display: grid;
			align-content: start;
			grid-template-columns: auto 1fr;
			grid-column-gap: 1rem;
			column-gap: 1rem;
			grid-row-gap: .6rem;
			row-gap: .6rem;
		}
		#toc h2 {
			grid-column: 1 / -1;
			margin-bottom: 0;
		}
		#toc ol,
		#toc li,
		#toc a {
			display: contents;
			/* Switch <a> to subgrid when supported */
		}
		#toc span {
			margin: 0;
		}
		#toc > .toc > li > a > span {
			/* The spans of the top-level list,
			  comprising the first items of each top-level section. */
			margin-top: 1.1rem;
		}
		#toc#toc .secno { /* Ugh, need more specificity to override base.css */
			grid-column: 1;
			width: auto;
			margin-left: 0;
		}
		#toc .content {
			grid-column: 2;
			width: auto;
			margin-right: 1rem;
		}
		#toc .content:hover,
		#toc .content:focus {
			background: rgba(75%, 75%, 75%, .25);
			background: var(--a-hover-bg);
			border-bottom: 3px solid #054572;
			border-bottom: 3px solid var(--toclink-underline);
			margin-bottom: -3px;
		}
		#toc li li li .content {
			margin-left: 1rem;
		}
		#toc li li li li .content {
			margin-left: 2rem;
		}
	}


/** Index *********************************************************************/

	/* Index Lists: Layout */
	ul.index	  { margin-left: 0; columns: 15em; text-indent: 1em hanging; }
	ul.index li	{ margin-left: 0; list-style: none; break-inside: avoid; }
	ul.index li li { margin-left: 1em; }
	ul.index dl	{ margin-top: 0; }
	ul.index dt	{ margin: .2em 0 .2em 20px;}
	ul.index dd	{ margin: .2em 0 .2em 40px;}
	/* Index Lists: Typography */
	ul.index ul,
	ul.index dl { font-size: smaller; }
	@media not print {
		ul.index li span:not(.dfn-paneled) {
			white-space: nowrap;
			color: transparent; }
		ul.index li a:hover + span,
		ul.index li a:focus + span {
			color: #707070;
			color: var(--indexinfo-text);
		}
	}

/** Index Tables *****************************************************/
	/* See also the data table styling section, which this effectively subclasses */

	table.index {
		font-size: small;
		border-collapse: collapse;
		border-spacing: 0;
		text-align: left;
		margin: 1em 0;
	}

	table.index td,
	table.index th {
		padding: 0.4em;
	}

	table.index tr:hover td:not([rowspan]),
	table.index tr:hover th:not([rowspan]) {
		color: black;
		color: var(--indextable-hover-text);
		background: #f7f8f9;
		background: var(--indextable-hover-bg);
	}

	/* The link in the first column in the property table (formerly a TD) */
	table.index th:first-child a {
		font-weight: bold;
	}

/** Outdated warning **********************************************************/

.outdated-spec {
	color: black;
	color: var(--outdatedspec-text);
	background-color: rgba(0,0,0,0.5);
	background-color: var(--outdatedspec-bg);
}

.outdated-warning {
	position: fixed;
	bottom: 50%;
	left: 0;
	right: 0;
	margin: 0 auto;
	width: 50%;
	background: maroon;
	background: var(--outdated-bg);
	color: white;
	color: var(--outdated-text);
	border-radius: 1em;
	box-shadow: 0 0 1em red;
	box-shadow: 0 0 1em var(--outdated-shadow);
	padding: 2em;
	text-align: center;
	z-index: 2;
}

.outdated-warning a {
	color: currentcolor;
	background: transparent;
}

.edited-rec-warning {
	background: darkorange;
	background: var(--editedrec-bg);
	box-shadow: 0 0 1em;
}

.outdated-warning button {
	color: var(--outdated-text);
	border-radius: 1em;
	box-shadow: 0 0 1em red;
	box-shadow: 0 0 1em var(--outdated-shadow);
	padding: 2em;
	text-align: center;
	z-index: 2;
}

.outdated-warning a {
	color: currentcolor;
	background: transparent;
}

.edited-rec-warning {
	background: darkorange;
	background: var(--editedrec-bg);
	box-shadow: 0 0 1em;
}

.outdated-warning button {
	position: absolute;
	top: 0;
	right:0;
	margin: 0;
	border: 0;
	padding: 0.25em 0.5em;
	background: transparent;
	color: white;
	color: var(--outdated-text);
	font:1em sans-serif;
	text-align:center;
}

.outdated-warning span {
	display: block;
}

.outdated-collapsed {
	bottom: 0;
	border-radius: 0;
	width: 100%;
	padding: 0;
}

/******************************************************************************/
/*                                    Print                                   */
/******************************************************************************/

	@media print {
		/* Pages have their own margins. */
		html {
			margin: 0;
		}
		/* Serif for print. */
		body {
			font-family: serif;
		}

		.outdated-warning {
			position: absolute;
			border-style: solid;
			border-color: red;
		}

		.outdated-warning input {
			display: none;
		}
	}
	@page {
		margin: 1.5cm 1.1cm;
	}



/******************************************************************************/
/*                             Overflow Control                               */
/******************************************************************************/

	.figure .caption, .sidefigure .caption, figcaption {
		/* in case figure is overlarge, limit caption to 50em */
		max-width: 50rem;
		margin-left: auto;
		margin-right: auto;
	}
	.overlarge {
		/* Magic to create good item positioning:
		  "content column" is 50ems wide at max; less on smaller screens.
		  Extra space (after ToC + content) is empty on the right.

		  1. When item < content column, centers item in column.
		  2. When content < item < available, left-aligns.
		  3. When item > available, fills available + scroll bar.
		*/
		display: grid;
		grid-template-columns: minmax(0, 50em);
	}
	.overlarge > table {
		/* limit preferred width of table */
		max-width: 50em;
		margin-left: auto;
		margin-right: auto;
	}

	@media (min-width: 55em) {
		.overlarge {
			margin-right: calc(13px + 26.5rem - 50vw);
			max-width: none;
		}
	}
	@media screen and (min-width: 78em) {
		body:not(.toc-inline) .overlarge {
			/* 30.5em body padding 50em content area */
			margin-right: calc(40em - 50vw) !important;
		}
	}
	@media screen and (min-width: 90em) {
		body:not(.toc-inline) .overlarge {
			/* 4em html margin 30.5em body padding 50em content area */
			margin-right: calc(84.5em - 100vw) !important;
		}
	}

	@media not print {
		.overlarge {
			overflow-x: auto;
			/* See Lea Verou's explanation background-attachment:
			* http://lea.verou.me/2012/04/background-attachment-local/
			*
			background: top left  / 4em 100% linear-gradient(to right,  #ffffff, rgba(255, 255, 255, 0)) local,
						top right / 4em 100% linear-gradient(to left, #ffffff, rgba(255, 255, 255, 0)) local,
						top left  / 1em 100% linear-gradient(to right,  #c3c3c5, rgba(195, 195, 197, 0)) scroll,
						top right / 1em 100% linear-gradient(to left, #c3c3c5, rgba(195, 195, 197, 0)) scroll,
						white;
			background-repeat: no-repeat;
			*/
		}
	}
</style>
<style type="text/css">
    table, th, td {
      border: 1px solid black;
      border-collapse: collapse;
      vertical-align: top;
    }
    th, td {
      border-left: none;
      border-right: none;
      padding: 0px 10px;
    }
    th {
      text-align: center;
    }

    del { background: #fcc; color: #000; text-decoration: line-through; }
    ins { background: #cfc; color: #000; }
    blockquote .highlight:not(.idl) { background: initial; margin: initial; padding: 0.5em }
    blockquote ul { background: inherit; }
    blockquote code.highlight:not(.idl) { padding: initial; }
    blockquote c-[a] { color: inherit; } /* Keyword.Declaration */
    blockquote c-[b] { color: inherit; } /* Keyword.Type */
    blockquote c-[c] { color: inherit; } /* Comment */
    blockquote c-[d] { color: inherit; } /* Comment.Multiline */
    blockquote c-[e] { color: inherit; } /* Name.Attribute */
    blockquote c-[f] { color: inherit; } /* Name.Tag */
    blockquote c-[g] { color: inherit; } /* Name.Variable */
    blockquote c-[k] { color: inherit; } /* Keyword */
    blockquote c-[l] { color: inherit; } /* Literal */
    blockquote c-[m] { color: inherit; } /* Literal.Number */
    blockquote c-[n] { color: inherit; } /* Name */
    blockquote c-[o] { color: inherit; } /* Operator */
    blockquote c-[p] { color: inherit; } /* Punctuation */
    blockquote c-[s] { color: inherit; } /* Literal.String */
    blockquote c-[t] { color: inherit; } /* Literal.String.Single */
    blockquote c-[u] { color: inherit; } /* Literal.String.Double */
    blockquote c-[cp] { color: inherit; } /* Comment.Preproc */
    blockquote c-[c1] { color: inherit; } /* Comment.Single */
    blockquote c-[cs] { color: inherit; } /* Comment.Special */
    blockquote c-[kc] { color: inherit; } /* Keyword.Constant */
    blockquote c-[kn] { color: inherit; } /* Keyword.Namespace */
    blockquote c-[kp] { color: inherit; } /* Keyword.Pseudo */
    blockquote c-[kr] { color: inherit; } /* Keyword.Reserved */
    blockquote c-[ld] { color: inherit; } /* Literal.Date */
    blockquote c-[nc] { color: inherit; } /* Name.Class */
    blockquote c-[no] { color: inherit; } /* Name.Constant */
    blockquote c-[nd] { color: inherit; } /* Name.Decorator */
    blockquote c-[ni] { color: inherit; } /* Name.Entity */
    blockquote c-[ne] { color: inherit; } /* Name.Exception */
    blockquote c-[nf] { color: inherit; } /* Name.Function */
    blockquote c-[nl] { color: inherit; } /* Name.Label */
    blockquote c-[nn] { color: inherit; } /* Name.Namespace */
    blockquote c-[py] { color: inherit; } /* Name.Property */
    blockquote c-[ow] { color: inherit; } /* Operator.Word */
    blockquote c-[mb] { color: inherit; } /* Literal.Number.Bin */
    blockquote c-[mf] { color: inherit; } /* Literal.Number.Float */
    blockquote c-[mh] { color: inherit; } /* Literal.Number.Hex */
    blockquote c-[mi] { color: inherit; } /* Literal.Number.Integer */
    blockquote c-[mo] { color: inherit; } /* Literal.Number.Oct */
    blockquote c-[sb] { color: inherit; } /* Literal.String.Backtick */
    blockquote c-[sc] { color: inherit; } /* Literal.String.Char */
    blockquote c-[sd] { color: inherit; } /* Literal.String.Doc */
    blockquote c-[se] { color: inherit; } /* Literal.String.Escape */
    blockquote c-[sh] { color: inherit; } /* Literal.String.Heredoc */
    blockquote c-[si] { color: inherit; } /* Literal.String.Interpol */
    blockquote c-[sx] { color: inherit; } /* Literal.String.Other */
    blockquote c-[sr] { color: inherit; } /* Literal.String.Regex */
    blockquote c-[ss] { color: inherit; } /* Literal.String.Symbol */
    blockquote c-[vc] { color: inherit; } /* Name.Variable.Class */
    blockquote c-[vg] { color: inherit; } /* Name.Variable.Global */
    blockquote c-[vi] { color: inherit; } /* Name.Variable.Instance */
    blockquote c-[il] { color: inherit; } /* Literal.Number.Integer.Long */
  </style>
  <meta content="Bikeshed version a210b7d86, updated Thu Sep 16 13:45:19 2021 -0700" name="generator">
  <link href="https://wg21.link/P0323R11" rel="canonical">
  <link href="https://isocpp.org/favicon.ico" rel="icon">
  <meta content="4bfcc881f9dc0f95aebe7113345860b8b8bb4708" name="document-revision">
<style>
table, th, td { border:1px solid grey; }
</style>
<style>/* style-autolinks */

.css.css, .property.property, .descriptor.descriptor {
    color: var(--a-normal-text);
    font-size: inherit;
    font-family: inherit;
}
.css::before, .property::before, .descriptor::before {
    content: "‘";
}
.css::after, .property::after, .descriptor::after {
    content: "’";
}
.property, .descriptor {
    /* Don't wrap property and descriptor names */
    white-space: nowrap;
}
.type { /* CSS value <type> */
    font-style: italic;
}
pre .property::before, pre .property::after {
    content: "";
}
[data-link-type="property"]::before,
[data-link-type="propdesc"]::before,
[data-link-type="descriptor"]::before,
[data-link-type="value"]::before,
[data-link-type="function"]::before,
[data-link-type="at-rule"]::before,
[data-link-type="selector"]::before,
[data-link-type="maybe"]::before {
    content: "‘";
}
[data-link-type="property"]::after,
[data-link-type="propdesc"]::after,
[data-link-type="descriptor"]::after,
[data-link-type="value"]::after,
[data-link-type="function"]::after,
[data-link-type="at-rule"]::after,
[data-link-type="selector"]::after,
[data-link-type="maybe"]::after {
    content: "’";
}

[data-link-type].production::before,
[data-link-type].production::after,
.prod [data-link-type]::before,
.prod [data-link-type]::after {
    content: "";
}

[data-link-type=element],
[data-link-type=element-attr] {
    font-family: Menlo, Consolas, "DejaVu Sans Mono", monospace;
    font-size: .9em;
}
[data-link-type=element]::before { content: "<" }
[data-link-type=element]::after  { content: ">" }

[data-link-type=biblio] {
    white-space: pre;
}</style>
<style>/* style-colors */

/* Any --*-text not paired with a --*-bg is assumed to have a transparent bg */
:root {
    color-scheme: light dark;

    --text: black;
    --bg: white;

    --unofficial-watermark: url(https://www.w3.org/StyleSheets/TR/2016/logos/UD-watermark);

    --logo-bg: #1a5e9a;
    --logo-active-bg: #c00;
    --logo-text: white;

    --tocnav-normal-text: #707070;
    --tocnav-normal-bg: var(--bg);
    --tocnav-hover-text: var(--tocnav-normal-text);
    --tocnav-hover-bg: #f8f8f8;
    --tocnav-active-text: #c00;
    --tocnav-active-bg: var(--tocnav-normal-bg);

    --tocsidebar-text: var(--text);
    --tocsidebar-bg: #f7f8f9;
    --tocsidebar-shadow: rgba(0,0,0,.1);
    --tocsidebar-heading-text: hsla(203,20%,40%,.7);

    --toclink-text: var(--text);
    --toclink-underline: #3980b5;
    --toclink-visited-text: var(--toclink-text);
    --toclink-visited-underline: #054572;

    --heading-text: #005a9c;

    --hr-text: var(--text);

    --algo-border: #def;

    --del-text: red;
    --del-bg: transparent;
    --ins-text: #080;
    --ins-bg: transparent;

    --a-normal-text: #034575;
    --a-normal-underline: #bbb;
    --a-visited-text: var(--a-normal-text);
    --a-visited-underline: #707070;
    --a-hover-bg: rgba(75%, 75%, 75%, .25);
    --a-active-text: #c00;
    --a-active-underline: #c00;

    --blockquote-border: silver;
    --blockquote-bg: transparent;
    --blockquote-text: currentcolor;

    --issue-border: #e05252;
    --issue-bg: #fbe9e9;
    --issue-text: var(--text);
    --issueheading-text: #831616;

    --example-border: #e0cb52;
    --example-bg: #fcfaee;
    --example-text: var(--text);
    --exampleheading-text: #574b0f;

    --note-border: #52e052;
    --note-bg: #e9fbe9;
    --note-text: var(--text);
    --noteheading-text: hsl(120, 70%, 30%);
    --notesummary-underline: silver;

    --assertion-border: #aaa;
    --assertion-bg: #eee;
    --assertion-text: black;

    --advisement-border: orange;
    --advisement-bg: #fec;
    --advisement-text: var(--text);
    --advisementheading-text: #b35f00;

    --warning-border: red;
    --warning-bg: hsla(40,100%,50%,0.95);
    --warning-text: var(--text);

    --amendment-border: #330099;
    --amendment-bg: #F5F0FF;
    --amendment-text: var(--text);
    --amendmentheading-text: #220066;

    --def-border: #8ccbf2;
    --def-bg: #def;
    --def-text: var(--text);
    --defrow-border: #bbd7e9;

    --datacell-border: silver;

    --indexinfo-text: #707070;

    --indextable-hover-text: black;
    --indextable-hover-bg: #f7f8f9;

    --outdatedspec-bg: rgba(0, 0, 0, .5);
    --outdatedspec-text: black;
    --outdated-bg: maroon;
    --outdated-text: white;
    --outdated-shadow: red;

    --editedrec-bg: darkorange;
}</style>
<style>/* style-counters */

body {
    counter-reset: example figure issue;
}
.issue {
    counter-increment: issue;
}
.issue:not(.no-marker)::before {
    content: "Issue " counter(issue);
}

.example {
    counter-increment: example;
}
.example:not(.no-marker)::before {
    content: "Example " counter(example);
}
.invalid.example:not(.no-marker)::before,
.illegal.example:not(.no-marker)::before {
    content: "Invalid Example" counter(example);
}

figcaption {
    counter-increment: figure;
}
figcaption:not(.no-marker)::before {
    content: "Figure " counter(figure) " ";
}</style>
<style>/* style-md-lists */

/* This is a weird hack for me not yet following the commonmark spec
   regarding paragraph and lists. */
[data-md] > :first-child {
    margin-top: 0;
}
[data-md] > :last-child {
    margin-bottom: 0;
}</style>
<style>/* style-selflinks */

:root {
    --selflink-text: white;
    --selflink-bg: gray;
    --selflink-hover-text: black;
}
.heading, .issue, .note, .example, li, dt {
    position: relative;
}
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;
}
a.self-link:hover {
    opacity: 1;
}
.heading > a.self-link {
    font-size: 83%;
}
li > a.self-link {
    left: calc(-1 * (3.5rem - 26px) - 2em);
}
dfn > a.self-link {
    top: auto;
    left: auto;
    opacity: 0;
    width: 1.5em;
    height: 1.5em;
    background: var(--selflink-bg);
    color: var(--selflink-text);
    font-style: normal;
    transition: opacity .2s, background-color .2s, color .2s;
}
dfn:hover > a.self-link {
    opacity: 1;
}
dfn > a.self-link:hover {
    color: var(--selflink-hover-text);
}

a.self-link::before            { content: "¶"; }
.heading > a.self-link::before { content: "§"; }
dfn > a.self-link::before      { content: "#"; }
</style>
<style>/* style-syntax-highlighting */

code.highlight { padding: .1em; border-radius: .3em; }
pre.highlight, pre > code.highlight { display: block; padding: 1em; margin: .5em 0; overflow: auto; border-radius: 0; }

.highlight:not(.idl) { background: rgba(0, 0, 0, .03); }
c-[a] { color: #990055 } /* Keyword.Declaration */
c-[b] { color: #990055 } /* Keyword.Type */
c-[c] { color: #708090 } /* Comment */
c-[d] { color: #708090 } /* Comment.Multiline */
c-[e] { color: #0077aa } /* Name.Attribute */
c-[f] { color: #669900 } /* Name.Tag */
c-[g] { color: #222222 } /* Name.Variable */
c-[k] { color: #990055 } /* Keyword */
c-[l] { color: #000000 } /* Literal */
c-[m] { color: #000000 } /* Literal.Number */
c-[n] { color: #0077aa } /* Name */
c-[o] { color: #999999 } /* Operator */
c-[p] { color: #999999 } /* Punctuation */
c-[s] { color: #a67f59 } /* Literal.String */
c-[t] { color: #a67f59 } /* Literal.String.Single */
c-[u] { color: #a67f59 } /* Literal.String.Double */
c-[cp] { color: #708090 } /* Comment.Preproc */
c-[c1] { color: #708090 } /* Comment.Single */
c-[cs] { color: #708090 } /* Comment.Special */
c-[kc] { color: #990055 } /* Keyword.Constant */
c-[kn] { color: #990055 } /* Keyword.Namespace */
c-[kp] { color: #990055 } /* Keyword.Pseudo */
c-[kr] { color: #990055 } /* Keyword.Reserved */
c-[ld] { color: #000000 } /* Literal.Date */
c-[nc] { color: #0077aa } /* Name.Class */
c-[no] { color: #0077aa } /* Name.Constant */
c-[nd] { color: #0077aa } /* Name.Decorator */
c-[ni] { color: #0077aa } /* Name.Entity */
c-[ne] { color: #0077aa } /* Name.Exception */
c-[nf] { color: #0077aa } /* Name.Function */
c-[nl] { color: #0077aa } /* Name.Label */
c-[nn] { color: #0077aa } /* Name.Namespace */
c-[py] { color: #0077aa } /* Name.Property */
c-[ow] { color: #999999 } /* Operator.Word */
c-[mb] { color: #000000 } /* Literal.Number.Bin */
c-[mf] { color: #000000 } /* Literal.Number.Float */
c-[mh] { color: #000000 } /* Literal.Number.Hex */
c-[mi] { color: #000000 } /* Literal.Number.Integer */
c-[mo] { color: #000000 } /* Literal.Number.Oct */
c-[sb] { color: #a67f59 } /* Literal.String.Backtick */
c-[sc] { color: #a67f59 } /* Literal.String.Char */
c-[sd] { color: #a67f59 } /* Literal.String.Doc */
c-[se] { color: #a67f59 } /* Literal.String.Escape */
c-[sh] { color: #a67f59 } /* Literal.String.Heredoc */
c-[si] { color: #a67f59 } /* Literal.String.Interpol */
c-[sx] { color: #a67f59 } /* Literal.String.Other */
c-[sr] { color: #a67f59 } /* Literal.String.Regex */
c-[ss] { color: #a67f59 } /* Literal.String.Symbol */
c-[vc] { color: #0077aa } /* Name.Variable.Class */
c-[vg] { color: #0077aa } /* Name.Variable.Global */
c-[vi] { color: #0077aa } /* Name.Variable.Instance */
c-[il] { color: #000000 } /* Literal.Number.Integer.Long */
</style>
<style>/* style-darkmode */

@media (prefers-color-scheme: dark) {
    :root {
        --text: #ddd;
        --bg: black;

        --unofficial-watermark: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='400' height='400'%3E%3Cg fill='%23100808' transform='translate(200 200) rotate(-45) translate(-200 -200)' stroke='%23100808' stroke-width='3'%3E%3Ctext x='50%25' y='220' style='font: bold 70px sans-serif; text-anchor: middle; letter-spacing: 6px;'%3EUNOFFICIAL%3C/text%3E%3Ctext x='50%25' y='305' style='font: bold 70px sans-serif; text-anchor: middle; letter-spacing: 6px;'%3EDRAFT%3C/text%3E%3C/g%3E%3C/svg%3E");

        --logo-bg: #1a5e9a;
        --logo-active-bg: #c00;
        --logo-text: white;

        --tocnav-normal-text: #999;
        --tocnav-normal-bg: var(--bg);
        --tocnav-hover-text: var(--tocnav-normal-text);
        --tocnav-hover-bg: #080808;
        --tocnav-active-text: #f44;
        --tocnav-active-bg: var(--tocnav-normal-bg);

        --tocsidebar-text: var(--text);
        --tocsidebar-bg: #080808;
        --tocsidebar-shadow: rgba(255,255,255,.1);
        --tocsidebar-heading-text: hsla(203,20%,40%,.7);

        --toclink-text: var(--text);
        --toclink-underline: #6af;
        --toclink-visited-text: var(--toclink-text);
        --toclink-visited-underline: #054572;

        --heading-text: #8af;

        --hr-text: var(--text);

        --algo-border: #456;

        --del-text: #f44;
        --del-bg: transparent;
        --ins-text: #4a4;
        --ins-bg: transparent;

        --a-normal-text: #6af;
        --a-normal-underline: #555;
        --a-visited-text: var(--a-normal-text);
        --a-visited-underline: var(--a-normal-underline);
        --a-hover-bg: rgba(25%, 25%, 25%, .2);
        --a-active-text: #f44;
        --a-active-underline: var(--a-active-text);

        --borderedblock-bg: rgba(255, 255, 255, .05);

        --blockquote-border: silver;
        --blockquote-bg: var(--borderedblock-bg);
        --blockquote-text: currentcolor;

        --issue-border: #e05252;
        --issue-bg: var(--borderedblock-bg);
        --issue-text: var(--text);
        --issueheading-text: hsl(0deg, 70%, 70%);

        --example-border: hsl(50deg, 90%, 60%);
        --example-bg: var(--borderedblock-bg);
        --example-text: var(--text);
        --exampleheading-text: hsl(50deg, 70%, 70%);

        --note-border: hsl(120deg, 100%, 35%);
        --note-bg: var(--borderedblock-bg);
        --note-text: var(--text);
        --noteheading-text: hsl(120, 70%, 70%);
        --notesummary-underline: silver;

        --assertion-border: #444;
        --assertion-bg: var(--borderedblock-bg);
        --assertion-text: var(--text);

        --advisement-border: orange;
        --advisement-bg: #222218;
        --advisement-text: var(--text);
        --advisementheading-text: #f84;

        --warning-border: red;
        --warning-bg: hsla(40,100%,20%,0.95);
        --warning-text: var(--text);

        --amendment-border: #330099;
        --amendment-bg: #080010;
        --amendment-text: var(--text);
        --amendmentheading-text: #cc00ff;

        --def-border: #8ccbf2;
        --def-bg: #080818;
        --def-text: var(--text);
        --defrow-border: #136;

        --datacell-border: silver;

        --indexinfo-text: #aaa;

        --indextable-hover-text: var(--text);
        --indextable-hover-bg: #181818;

        --outdatedspec-bg: rgba(255, 255, 255, .5);
        --outdatedspec-text: black;
        --outdated-bg: maroon;
        --outdated-text: white;
        --outdated-shadow: red;

        --editedrec-bg: darkorange;
    }
    /* In case a transparent-bg image doesn't expect to be on a dark bg,
       which is quite common in practice... */
    img { background: white; }
}
@media (prefers-color-scheme: dark) {
    :root {
        --selflink-text: black;
        --selflink-bg: silver;
        --selflink-hover-text: white;
    }
}

@media (prefers-color-scheme: dark) {
    .highlight:not(.idl) { background: rgba(255, 255, 255, .05); }

    c-[a] { color: #d33682 } /* Keyword.Declaration */
    c-[b] { color: #d33682 } /* Keyword.Type */
    c-[c] { color: #2aa198 } /* Comment */
    c-[d] { color: #2aa198 } /* Comment.Multiline */
    c-[e] { color: #268bd2 } /* Name.Attribute */
    c-[f] { color: #b58900 } /* Name.Tag */
    c-[g] { color: #cb4b16 } /* Name.Variable */
    c-[k] { color: #d33682 } /* Keyword */
    c-[l] { color: #657b83 } /* Literal */
    c-[m] { color: #657b83 } /* Literal.Number */
    c-[n] { color: #268bd2 } /* Name */
    c-[o] { color: #657b83 } /* Operator */
    c-[p] { color: #657b83 } /* Punctuation */
    c-[s] { color: #6c71c4 } /* Literal.String */
    c-[t] { color: #6c71c4 } /* Literal.String.Single */
    c-[u] { color: #6c71c4 } /* Literal.String.Double */
    c-[ch] { color: #2aa198 } /* Comment.Hashbang */
    c-[cp] { color: #2aa198 } /* Comment.Preproc */
    c-[cpf] { color: #2aa198 } /* Comment.PreprocFile */
    c-[c1] { color: #2aa198 } /* Comment.Single */
    c-[cs] { color: #2aa198 } /* Comment.Special */
    c-[kc] { color: #d33682 } /* Keyword.Constant */
    c-[kn] { color: #d33682 } /* Keyword.Namespace */
    c-[kp] { color: #d33682 } /* Keyword.Pseudo */
    c-[kr] { color: #d33682 } /* Keyword.Reserved */
    c-[ld] { color: #657b83 } /* Literal.Date */
    c-[nc] { color: #268bd2 } /* Name.Class */
    c-[no] { color: #268bd2 } /* Name.Constant */
    c-[nd] { color: #268bd2 } /* Name.Decorator */
    c-[ni] { color: #268bd2 } /* Name.Entity */
    c-[ne] { color: #268bd2 } /* Name.Exception */
    c-[nf] { color: #268bd2 } /* Name.Function */
    c-[nl] { color: #268bd2 } /* Name.Label */
    c-[nn] { color: #268bd2 } /* Name.Namespace */
    c-[py] { color: #268bd2 } /* Name.Property */
    c-[ow] { color: #657b83 } /* Operator.Word */
    c-[mb] { color: #657b83 } /* Literal.Number.Bin */
    c-[mf] { color: #657b83 } /* Literal.Number.Float */
    c-[mh] { color: #657b83 } /* Literal.Number.Hex */
    c-[mi] { color: #657b83 } /* Literal.Number.Integer */
    c-[mo] { color: #657b83 } /* Literal.Number.Oct */
    c-[sa] { color: #6c71c4 } /* Literal.String.Affix */
    c-[sb] { color: #6c71c4 } /* Literal.String.Backtick */
    c-[sc] { color: #6c71c4 } /* Literal.String.Char */
    c-[dl] { color: #6c71c4 } /* Literal.String.Delimiter */
    c-[sd] { color: #6c71c4 } /* Literal.String.Doc */
    c-[se] { color: #6c71c4 } /* Literal.String.Escape */
    c-[sh] { color: #6c71c4 } /* Literal.String.Heredoc */
    c-[si] { color: #6c71c4 } /* Literal.String.Interpol */
    c-[sx] { color: #6c71c4 } /* Literal.String.Other */
    c-[sr] { color: #6c71c4 } /* Literal.String.Regex */
    c-[ss] { color: #6c71c4 } /* Literal.String.Symbol */
    c-[fm] { color: #268bd2 } /* Name.Function.Magic */
    c-[vc] { color: #cb4b16 } /* Name.Variable.Class */
    c-[vg] { color: #cb4b16 } /* Name.Variable.Global */
    c-[vi] { color: #cb4b16 } /* Name.Variable.Instance */
    c-[vm] { color: #cb4b16 } /* Name.Variable.Magic */
    c-[il] { color: #657b83 } /* Literal.Number.Integer.Long */
}
</style>
 </head><body class="h-entry toc-sidebar"><p id="toc-nav"><a id="toc-jump" href="#toc"><span aria-hidden="true">↑</span> <span>Jump to Table of Contents</span></a><a id="toc-toggle" href="#toc"><span aria-hidden="true">←</span> <span>Collapse Sidebar</span></a></p>
  <div class="head">
   <p data-fill-with="logo"></p>
   <h1 class="p-name no-ref" id="title">P0323R12<br>std::expected</h1>
   <h2 class="no-num no-toc no-ref heading settled" id="profile-and-date"><span class="content">Published Proposal, <time class="dt-updated" datetime="2022-01-07">2022-01-07</time></span></h2>
   <div data-fill-with="spec-metadata">
    <dl>
     <dt>This version:
     </dt><dd><a class="u-url" href="https://wg21.link/P0323R11">https://wg21.link/P0323R11</a>
     </dd><dt class="editor">Authors:
     </dt><dd class="editor p-author h-card vcard"><a class="p-name fn u-email email" href="mailto:vicente.botet@nokia.com">Vicente Botet</a> (<span class="p-org org">Nokia</span>)
     </dd><dd class="editor p-author h-card vcard"><a class="p-name fn u-email email" href="mailto:cxx@jfbastien.com">JF Bastien</a> (<span class="p-org org">Woven Planet</span>)
     </dd><dd class="editor p-author h-card vcard"><a class="p-name fn u-email email" href="mailto:cxx@kayari.org">Jonathan Wakely</a> (<span class="p-org org">Red Hat</span>)
     </dd><dt>Audience:
     </dt><dd>LWG
     </dd><dt>Project:
     </dt><dd>ISO/IEC JTC1/SC22/WG21 14882: Programming Language — C++
     </dd><dt>Source:
     </dt><dd><a href="https://github.com/jfbastien/papers/blob/master/source/P0323R11.bs">github.com/jfbastien/papers/blob/master/source/P0323R11.bs</a>
    </dd></dl>
   </div>
   <div data-fill-with="warning"></div>
   <hr title="Separator for header">
  </div>
  <nav data-fill-with="table-of-contents" id="toc">
   <h2 class="no-num no-toc no-ref" id="contents">Table of Contents</h2>
   <ol class="toc" role="directory">
    <li><a href="#cool-story"><span class="secno">1</span> <span class="content">Revision History</span></a>
    </li><li>
     <a href="#yay"><span class="secno">2</span> <span class="content">Motivation</span></a>
     <ol class="toc">
      <li><a href="#usecase"><span class="secno">2.1</span> <span class="content">Sample Usecase</span></a>
      </li><li><a href="#ret"><span class="secno">2.2</span> <span class="content">Error retrieval and correction</span></a>
      </li><li><a href="#impact"><span class="secno">2.3</span> <span class="content">Impact on the standard</span></a>
     </li></ol>
    </li><li>
     <a href="#rationale"><span class="secno">3</span> <span class="content">Design rationale</span></a>
     <ol class="toc">
      <li><a href="#model"><span class="secno">3.1</span> <span class="content">Conceptual model of <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-></code></span></a>
      </li><li><a href="#default-E"><span class="secno">3.2</span> <span class="content">Default <code class="highlight"><c- n="">E</c-></code> template paremeter type</span></a>
      </li><li><a href="#init"><span class="secno">3.3</span> <span class="content">Initialization of <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-></code></span></a>
      </li><li><a href="#never-empty"><span class="secno">3.4</span> <span class="content">Never-empty guarantee</span></a>
      </li><li><a href="#default-ctor"><span class="secno">3.5</span> <span class="content">The default constructor</span></a>
      </li><li><a href="#void-error"><span class="secno">3.6</span> <span class="content">Could <code class="highlight"><c- n="">Error</c-></code> be <code class="highlight"><c- b="">void</c-></code></span></a>
      </li><li><a href="#conv-T"><span class="secno">3.7</span> <span class="content">Conversion from <code class="highlight"><c- n="">T</c-></code></span></a>
      </li><li><a href="#conv-E"><span class="secno">3.8</span> <span class="content">Conversion from <code class="highlight"><c- n="">E</c-></code></span></a>
      </li><li><a href="#exp2"><span class="secno">3.9</span> <span class="content">Should we support the <code class="highlight"><c- n="">exp2</c-> <c- o="">=</c-> <c- p="">{}</c-></code>?</span></a>
      </li><li><a href="#observers"><span class="secno">3.10</span> <span class="content">Observers</span></a>
      </li><li><a href="#explicit-bool"><span class="secno">3.11</span> <span class="content">Explicit conversion to <code class="highlight"><c- b="">bool</c-></code></span></a>
      </li><li><a href="#p0032"><span class="secno">3.12</span> <span class="content"><code class="highlight"><c- n="">has_value</c-><c- p="">()</c-></code> following P0032</span></a>
      </li><li><a href="#contained-value"><span class="secno">3.13</span> <span class="content">Accessing the contained value</span></a>
      </li><li><a href="#deref"><span class="secno">3.14</span> <span class="content">Dereference operator</span></a>
      </li><li><a href="#func-val"><span class="secno">3.15</span> <span class="content">Function value</span></a>
      </li><li><a href="#bad-expected"><span class="secno">3.16</span> <span class="content">Should <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;::</c-><c- n="">value</c-><c- p="">()</c-></code> throw <code class="highlight"><c- n="">E</c-></code> instead of <code class="highlight"><c- n="">bad_expected_access</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-></code>?</span></a>
      </li><li><a href="#access-error"><span class="secno">3.17</span> <span class="content">Accessing the contained error</span></a>
      </li><li><a href="#unexpected-conv"><span class="secno">3.18</span> <span class="content">Conversion to the unexpected value</span></a>
      </li><li><a href="#value-or"><span class="secno">3.19</span> <span class="content">Function <code class="highlight"><c- n="">value_or</c-></code></span></a>
      </li><li><a href="#eq"><span class="secno">3.20</span> <span class="content">Equality operators</span></a>
      </li><li><a href="#comparison"><span class="secno">3.21</span> <span class="content">Comparison operators</span></a>
      </li><li><a href="#modifiers"><span class="secno">3.22</span> <span class="content">Modifiers</span></a>
      </li><li><a href="#reset"><span class="secno">3.23</span> <span class="content">Resetting the value</span></a>
      </li><li><a href="#in_place"><span class="secno">3.24</span> <span class="content">Tag <code class="highlight"><c- n="">in_place</c-></code></span></a>
      </li><li><a href="#unexpect"><span class="secno">3.25</span> <span class="content">Tag <code class="highlight"><c- n="">unexpect</c-></code></span></a>
      </li><li><a href="#requirements"><span class="secno">3.26</span> <span class="content">Requirements on <code class="highlight"><c- n="">T</c-></code> and <code class="highlight"><c- n="">E</c-></code></span></a>
      </li><li><a href="#expected-references"><span class="secno">3.27</span> <span class="content">Expected references</span></a>
      </li><li><a href="#void"><span class="secno">3.28</span> <span class="content">Expected <code class="highlight"><c- b="">void</c-></code></span></a>
      </li><li><a href="#literal"><span class="secno">3.29</span> <span class="content">Making expected a literal type</span></a>
      </li><li><a href="#moved-from"><span class="secno">3.30</span> <span class="content">Moved from state</span></a>
      </li><li><a href="#io"><span class="secno">3.31</span> <span class="content">I/O operations</span></a>
      </li><li><a href="#status"><span class="secno">3.32</span> <span class="content">What happens when <code class="highlight"><c- n="">E</c-></code> is a status?</span></a>
      </li><li><a href="#error_or"><span class="secno">3.33</span> <span class="content">Do we need an <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;::</c-><c- n="">error_or</c-></code> function?</span></a>
      </li><li><a href="#check_error"><span class="secno">3.34</span> <span class="content">Do we need a <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;::</c-><c- n="">check_error</c-></code> function?</span></a>
      </li><li><a href="#adapt_error"><span class="secno">3.35</span> <span class="content">Do we need a <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-><c- n="">G</c-><c- o="">&gt;::</c-><c- n="">adapt_error</c-><c- p="">(</c-><c- n="">function</c-><c- o="">&lt;</c-><c- n="">E</c-><c- p="">(</c-><c- n="">G</c-><c- p="">))</c-></code> function?</span></a>
      </li><li><a href="#🧟‍♂️"><span class="secno">3.36</span> <span class="content">Zombie name</span></a>
     </li></ol>
    </li><li>
     <a href="#word"><span class="secno">4</span> <span class="content">Wording</span></a>
     <ol class="toc">
      <li><a href="#macro"><span class="secno">4.1</span> <span class="content">Feature test macro</span></a>
      </li><li><a href="#expected"><span class="secno">4.2</span> <span class="content">�.� Expected objects [<em>expected</em>]</span></a>
      </li><li><a href="#expected.general"><span class="secno">4.3</span> <span class="content">�.�.1 In general [<em>expected.general</em>]</span></a>
     </li></ol>
    </li><li>
     <a href="#expected.syn"><span class="secno">5</span> <span class="content">�.�.2 Header <code class="highlight"><c- o="">&lt;</c-><c- n="">expected</c-><c- o="">&gt;</c-></code> synopsis [<em>expected.syn</em>]</span></a>
     <ol class="toc">
      <li><a href="#expected.un"><span class="secno">5.1</span> <span class="content">�.�.3 Unexpected objects [<em>expected.unexpected</em>]</span></a>
      </li><li><a href="#expected.un.general"><span class="secno">5.2</span> <span class="content">�.�.3.1 General [<em>expected.un.general</em>]</span></a>
      </li><li>
       <a href="#expected.un.object"><span class="secno">5.3</span> <span class="content">�.�.3.2 Class template <code class="highlight"><c- n="">unexpected</c-></code> [<em>expected.un.object</em>]</span></a>
       <ol class="toc">
        <li><a href="#expected.un.ctor"><span class="secno">5.3.1</span> <span class="content">�.�.3.2.1 Constructors [<em>expected.un.ctor</em>]</span></a>
        </li><li><a href="#expected.un.observe"><span class="secno">5.3.2</span> <span class="content">�.�.3.2.3 Observers [<em>expected.un.observe</em>]</span></a>
        </li><li><a href="#expected.un.swap"><span class="secno">5.3.3</span> <span class="content">�.�.3.2.4 Swap [<em>expected.un.swap</em>]</span></a>
       </li></ol>
      </li><li><a href="#expected.un.eq"><span class="secno">5.4</span> <span class="content">�.�.3.2.5 Equality operators [<em>expected.un.eq</em>]</span></a>
      </li><li><a href="#expected.bad"><span class="secno">5.5</span> <span class="content">�.�.4 Class template <code class="highlight"><c- n="">bad_expected_access</c-></code> [<em>expected.bad</em>]</span></a>
      </li><li><a href="#expected.bad.void"><span class="secno">5.6</span> <span class="content">�.�.5 Class template specialization <code class="highlight"><c- n="">bad_expected_access</c-><c- o="">&lt;</c-><c- b="">void</c-><c- o="">&gt;</c-></code> [<em>expected.bad.void</em>]</span></a>
      </li><li><a href="#expected.expected"><span class="secno">5.7</span> <span class="content">�.�.7 Class template expected [<em>expected.expected</em>]</span></a>
      </li><li><a href="#expected.object.ctor"><span class="secno">5.8</span> <span class="content">�.�.7.1 Constructors [<em>expected.object.ctor</em>]</span></a>
      </li><li><a href="#expected.object.dtor"><span class="secno">5.9</span> <span class="content">�.�.7.2 Destructor [<em>expected.object.dtor</em>]</span></a>
      </li><li><a href="#expected.object.assign"><span class="secno">5.10</span> <span class="content">�.�.7.3 Assignment [<em>expected.object.assign</em>]</span></a>
      </li><li><a href="#expected.object.swap"><span class="secno">5.11</span> <span class="content">�.�.7.4 Swap [<em>expected.object.swap</em>]</span></a>
      </li><li><a href="#expected.object.observe"><span class="secno">5.12</span> <span class="content">�.�.7.5 Observers [<em>expected.object.observe</em>]</span></a>
      </li><li><a href="#expected.object.eq"><span class="secno">5.13</span> <span class="content">�.�.7.6 Expected Equality operators [<em>expected.object.eq</em>]</span></a>
      </li><li><a href="#expected.void"><span class="secno">5.14</span> <span class="content">�.�.8 Partial specialization of expected for void types [<em>expected.void</em>]</span></a>
      </li><li><a href="#expected.void.ctor"><span class="secno">5.15</span> <span class="content">�.�.8.1 Constructors [<em>expected.void.ctor</em>]</span></a>
      </li><li><a href="#expected.void.dtor"><span class="secno">5.16</span> <span class="content">�.�.8.2 Destructor [<em>expected.void.dtor</em>]</span></a>
      </li><li><a href="#expected.void.assign"><span class="secno">5.17</span> <span class="content">�.�.8.3 Assignment [<em>expected.void.assign</em>]</span></a>
      </li><li><a href="#expected.void.swap"><span class="secno">5.18</span> <span class="content">�.�.8.4 Swap [<em>expected.void.swap</em>]</span></a>
      </li><li><a href="#expected.void.observe"><span class="secno">5.19</span> <span class="content">�.�.8.5 Observers [<em>expected.void.observe</em>]</span></a>
      </li><li><a href="#expected.void.eq"><span class="secno">5.20</span> <span class="content">�.�.8.6 Expected Equality operators [<em>expected.void.eq</em>]</span></a>
      </li><li><a href="#zombie.names"><span class="secno">5.21</span> <span class="content">16.4.5.3.2 Zombie names [<em>zombie.names</em>]</span></a>
     </li></ol>
    </li><li>
     <a href="#use"><span class="secno">6</span> <span class="content">Implementation &amp; Usage Experience</span></a>
     <ol class="toc">
      <li><a href="#💜"><span class="secno">6.1</span> <span class="content">Sy Brand</span></a>
      </li><li><a href="#viboes"><span class="secno">6.2</span> <span class="content">Vicente J. Botet Escriba</span></a>
      </li><li><a href="#🕸🐈"><span class="secno">6.3</span> <span class="content">WebKit</span></a>
     </li></ol>
    </li><li>
     <a href="#references"><span class="secno"></span> <span class="content">References</span></a>
     <ol class="toc">
      <li><a href="#informative"><span class="secno"></span> <span class="content">Informative References</span></a>
     </li></ol>
   </li></ol>
  </nav>
  <main>
   <p>Class template <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-></code> is a vocabulary type which contains an expected value of type <code class="highlight"><c- n="">T</c-></code>, or an error <code class="highlight"><c- n="">E</c-></code>. The class skews towards behaving like a <code class="highlight"><c- n="">T</c-></code>,
 because its intended use is when the expected type is contained. When 
something unexpected occurs, more typing is required. When all is good, 
code mostly looks as if a <code class="highlight"><c- n="">T</c-></code> were being handled.</p>
   <p>Class template <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-></code> contains either:</p>
   <ul>
    <li data-md="">
     <p>A value of type <code class="highlight"><c- n="">T</c-></code>, the expected value type; or</p>
    </li><li data-md="">
     <p>A value of type <code class="highlight"><c- n="">E</c-></code>, an error type used when an unexpected outcome occured.</p>
   </li></ul>
   <p>The interface can be queried as to whether the underlying value is the expected value (of type <code class="highlight"><c- n="">T</c-></code>) or an unexpected value (of type <code class="highlight"><c- n="">E</c-></code>). The original idea comes from Andrei Alexandrescu C++ and Beyond 2012: Systematic Error Handling in C++ <a href="http://channel9.msdn.com/Shows/Going+Deep/C-and-Beyond-2012-Andrei-Alexandrescu-Systematic-Error-Handling-in-C">Alexandrescu.Expected</a>, which he <a href="https://www.youtube.com/watch?v=PH4WBuE1BHI&amp;t=1825s">revisited in CppCon 2018</a>, including mentions of this paper.</p>
   <p>The interface and the rational are based on <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">optional</c-></code> <a data-link-type="biblio" href="#biblio-n3793">[N3793]</a>. We consider <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-></code> as a supplement to <code class="highlight"><c- n="">optional</c-><c- o="">&lt;</c-><c- n="">T</c-><c- o="">&gt;</c-></code>, expressing why an expected value isn’t contained in the object.</p>
   <h2 class="heading settled" data-level="1" id="cool-story"><span class="secno">1. </span><span class="content">Revision History</span><a class="self-link" href="#cool-story"></a></h2>
   <p>This paper updates <a data-link-type="biblio" href="#biblio-p0323r10">[P0323r10]</a> following a few LWG reviews on 2021-09-10 and later. Remove conversions from <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">unexpected</c-></code>. Rationalize constraints and effects throughout. Define separate partial specialization for <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">cv</c-> <c- b="">void</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-></code>. Many other small edits.</p>
   <p>In the 2021-04-06 LEWG telecon, LEWG decided to target the IS instead of a TS.</p>
   <p><strong>Poll:</strong> <a data-link-type="biblio" href="#biblio-p0323r9">[P0323r9]</a> should add a feature test macro, change the
namespace/header from <code class="highlight"><c- n="">experimental</c-></code> to <code class="highlight"><c- n="">std</c-></code> to be re-targeted to the IS,
forward it to electronic polling to forward to LWG</p>
   <table>
    <thead>
     <tr>
      <td>SF
      </td><td>F
      </td><td>N
      </td><td>A
      </td><td>SA
    </td></tr></thead><tbody>
     <tr>
      <td>6
      </td><td>6
      </td><td>5
      </td><td>1
      </td><td>0
   </td></tr></tbody></table>
   <p>Various iterations of this paper have been reviewed by WG21 over time:</p>
   <ul>
    <li data-md="">
     <p><a href="https://wiki.edg.com/bin/view/Wg21telecons2021/P0323-20210910">LWG Telecon 2021</a></p>
    </li><li data-md="">
     <p><a href="https://wiki.edg.com/bin/view/Wg21telecons2021/P0323">LEWG Telecon 2021</a></p>
    </li><li data-md="">
     <p><a href="https://wiki.edg.com/bin/view/Wg21jacksonville2018/LWGThuPM2">LWG Jacksonville 2018</a></p>
    </li><li data-md="">
     <p><a href="https://wiki.edg.com/bin/view/Wg21rapperswil2018/P0323">LWG Rapperswil 2018</a></p>
    </li><li data-md="">
     <p><a href="https://wiki.edg.com/bin/view/Wg21albuquerque/P0323R3">EWG Albuquerque 2017</a></p>
    </li><li data-md="">
     <p><a href="https://wiki.edg.com/bin/view/Wg21albuquerque/P0323">LEWG Albuquerque 2017</a></p>
    </li><li data-md="">
     <p><a href="https://wiki.edg.com/bin/view/Wg21toronto2017/P0323">LEWG Toronto 2017</a></p>
    </li><li data-md="">
     <p><a href="https://wiki.edg.com/bin/view/Wg21oulu/P0323">LEWG Oulu 2016</a></p>
    </li><li data-md="">
     <p><a href="https://wiki.edg.com/bin/view/Wg21oulu/SG14AtGDC2016#Paul_Hampson_p_hampson_wargaming">SG14 GDC 2016</a></p>
    </li><li data-md="">
     <p><a href="http://wiki.edg.com/twiki/bin/view/Wg21rapperswil2014/N4015">LEWG Rapperswil 2014</a></p>
   </li></ul>
   <p>Related papers:</p>
   <ul>
    <li data-md="">
     <p>This proposal dates back to <a data-link-type="biblio" href="#biblio-n4015">[N4015]</a> and <a data-link-type="biblio" href="#biblio-n4109">[N4109]</a>.</p>
    </li><li data-md="">
     <p><a data-link-type="biblio" href="#biblio-p0323r3">[P0323r3]</a> 
was the last paper with a rationale. LEWG asked that the rationale be 
dropped from r4 onwards. The rationale is now back in r10, to follow the
 new LEWG policy of preserving rationales.</p>
    </li><li data-md="">
     <p>Some design issues were discussed by LWG and answered in <a data-link-type="biblio" href="#biblio-p1051r0">[P1051r0]</a>.</p>
    </li><li data-md="">
     <p><a data-link-type="biblio" href="#biblio-p0650r2">[P0650r2]</a> proposes monadic interfaces for <code class="highlight"><c- n="">expected</c-></code> and other types.</p>
    </li><li data-md="">
     <p><a data-link-type="biblio" href="#biblio-p0343r1">[P0343r1]</a> proposes meta-programming high-order functions.</p>
    </li><li data-md="">
     <p><a data-link-type="biblio" href="#biblio-p0262r1">[P0262r1]</a> is a related proposal for status / optional value.</p>
    </li><li data-md="">
     <p><a data-link-type="biblio" href="#biblio-p0157r0">[P0157R0]</a> describes when to use each of the different error report mechanism.</p>
    </li><li data-md="">
     <p><a data-link-type="biblio" href="#biblio-p0762r0">[P0762r0]</a> discussed how this paper interacts with boost.Outcome.</p>
    </li><li data-md="">
     <p><a data-link-type="biblio" href="#biblio-p1095r0">[P1095r0]</a> proposes zero overhead deterministic failure.</p>
    </li><li data-md="">
     <p><a data-link-type="biblio" href="#biblio-p0709r4">[P0709r4]</a> discussed zero-overhead deterministic exceptions.</p>
    </li><li data-md="">
     <p><a data-link-type="biblio" href="#biblio-p1028r3">[P1028R3]</a> proposes <code class="highlight"><c- n="">status_code</c-></code> and standard <code class="highlight"><c- n="">error</c-></code> object.</p>
   </li></ul>
   <h2 class="heading settled" data-level="2" id="yay"><span class="secno">2. </span><span class="content">Motivation</span><a class="self-link" href="#yay"></a></h2>
   <p>C++'s two main error mechanisms are exceptions and return codes. Characteristics of a good error mechanism are:</p>
   <ol>
    <li data-md="">
     <p><strong>Error visibility:</strong> Failure cases should appear throughout the code review: debugging can be painful if errors are hidden.</p>
    </li><li data-md="">
     <p><strong>Information on errors:</strong> Errors should carry information from their origin, causes and possibly the ways to resolve it.</p>
    </li><li data-md="">
     <p><strong>Clean code:</strong> Treatment of errors should be in a 
separate layer of code and as invisible as possible. The reader could 
notice the presence of exceptional cases without needing to stop 
reading.</p>
    </li><li data-md="">
     <p><strong>Non-Intrusive error:</strong> Errors should not 
monopolize the communication channel dedicated to normal code flow. They
 must be as discrete as possible. For instance, the return of a function
 is a channel that should not be exclusively reserved for errors.</p>
   </li></ol>
   <p>The first and the third characteristic seem contradictory and 
deserve further explanation. The former points out that errors not 
handled should appear clearly in the code. The latter
tells us that error handling must not interfere with the legibility, 
meaning that it clearly shows the normal execution flow.</p>
   <p>Here is a comparison between the exception and return
codes:</p>
   <table>
    <thead>
     <tr>
      <td>
      </td><td>Exception
      </td><td>Return error code
    </td></tr></thead><tbody>
     <tr>
      <td>Visibility
      </td><td>Not visible without further analysis of the code. However, if an exception is thrown, we can follow the stack
trace.
      </td><td>Visible at the first sight by watching the prototype of 
the called function. However ignoring return code can lead to undefined 
results and it can be hard to figure out the
problem.
     </td></tr><tr>
      <td>Informations
      </td><td>Exceptions can be arbitrarily rich.
      </td><td>Historically a simple integer. Nowadays, the header &lt;system_error&gt; provides richer error code.
     </td></tr><tr>
      <td>Clean code
      </td><td>Provides clean code, exceptions can be completely invisible for the caller.
      </td><td>Force you to add, at least, a if statement after each function call.
     </td></tr><tr>
      <td>Non-Intrusive
      </td><td>Proper communication channel.
      </td><td>Monopolization of the return channel.
   </td></tr></tbody></table>
   <p>We can do the same analysis for the <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-></code> class and observe the advantages over the classic error reporting systems.</p>
   <ol>
    <li data-md="">
     <p><strong>Error visibility:</strong> It takes the best of the exception and error code. It’s visible because the return type is <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-></code> and users cannot ignore the error case if they want to retrieve the contained value.</p>
    </li><li data-md="">
     <p><strong>Information:</strong> Arbitrarily rich.</p>
    </li><li data-md="">
     <p><strong>Clean code:</strong> The monadic interface of expected provides a framework delegating the error handling to another layer of code. Note that <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-></code> can also act as a bridge between an exception-oriented code and a nothrow world.</p>
    </li><li data-md="">
     <p><strong>Non-Intrusive:</strong> Use the return channel without monopolizing it.</p>
   </li></ol>
   <p>Other notable characteristics of <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-></code> include:</p>
   <ul>
    <li data-md="">
     <p>Associates errors with computational goals.</p>
    </li><li data-md="">
     <p>Naturally allows multiple errors inflight.</p>
    </li><li data-md="">
     <p>Teleportation possible.</p>
    </li><li data-md="">
     <p>Across thread boundaries.</p>
    </li><li data-md="">
     <p>On weak executors which don’t support thread-local storage.</p>
    </li><li data-md="">
     <p>Across no-throw subsystem boundaries.</p>
    </li><li data-md="">
     <p>Across time: save now, throw later.</p>
    </li><li data-md="">
     <p>Collect, group, combine errors.</p>
    </li><li data-md="">
     <p>Much simpler for a compiler to optimize.</p>
   </li></ul>
   <h3 class="heading settled" data-level="2.1" id="usecase"><span class="secno">2.1. </span><span class="content">Sample Usecase</span><a class="self-link" href="#usecase"></a></h3>
   <p>The following is how WebKit-based browsers <a href="https://trac.webkit.org/browser/webkit/trunk/Source/WebCore/platform/URLParser.cpp?rev=+219458#L2192">parse URLs</a> and use <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">expected</c-></code> to denote failure:</p>
<pre class="highlight"><c- k="">template</c-><c- o="">&lt;</c-><c- k="">typename</c-> <c- nc="">CharacterType</c-><c- o="">&gt;</c->
<c- n="">Expected</c-><c- o="">&lt;</c-><c- b="">uint32_t</c-><c- p="">,</c-> <c- n="">URLParser</c-><c- o="">::</c-><c- n="">IPv4PieceParsingError</c-><c- o="">&gt;</c-> <c- n="">URLParser</c-><c- o="">::</c-><c- n="">parseIPv4Piece</c-><c- p="">(</c-><c- n="">CodePointIterator</c-><c- o="">&lt;</c-><c- n="">CharacterType</c-><c- o="">&gt;&amp;</c-> <c- n="">iterator</c-><c- p="">,</c-> <c- b="">bool</c-><c- o="">&amp;</c-> <c- n="">didSeeSyntaxViolation</c-><c- p="">)</c->
<c- p="">{</c->
    <c- k="">enum</c-> <c- k="">class</c-> <c- nc="">State</c-> <c- o="">:</c-> <c- b="">uint8_t</c-> <c- p="">{</c->
        <c- n="">UnknownBase</c-><c- p="">,</c->
        <c- n="">Decimal</c-><c- p="">,</c->
        <c- n="">OctalOrHex</c-><c- p="">,</c->
        <c- n="">Octal</c-><c- p="">,</c->
        <c- n="">Hex</c-><c- p="">,</c->
    <c- p="">};</c->
    <c- n="">State</c-> <c- n="">state</c-> <c- o="">=</c-> <c- n="">State</c-><c- o="">::</c-><c- n="">UnknownBase</c-><c- p="">;</c->
    <c- n="">Checked</c-><c- o="">&lt;</c-><c- b="">uint32_t</c-><c- p="">,</c-> <c- n="">RecordOverflow</c-><c- o="">&gt;</c-> <c- n="">value</c-> <c- o="">=</c-> <c- mi="">0</c-><c- p="">;</c->
    <c- k="">if</c-> <c- p="">(</c-><c- o="">!</c-><c- n="">iterator</c-><c- p="">.</c-><c- n="">atEnd</c-><c- p="">()</c-> <c- o="">&amp;&amp;</c-> <c- o="">*</c-><c- n="">iterator</c-> <c- o="">==</c-> <c- sc="">'.'</c-><c- p="">)</c->
        <c- k="">return</c-> <c- n="">makeUnexpected</c-><c- p="">(</c-><c- n="">IPv4PieceParsingError</c-><c- o="">::</c-><c- n="">Failure</c-><c- p="">);</c->
    <c- k="">while</c-> <c- p="">(</c-><c- o="">!</c-><c- n="">iterator</c-><c- p="">.</c-><c- n="">atEnd</c-><c- p="">())</c-> <c- p="">{</c->
        <c- k="">if</c-> <c- p="">(</c-><c- n="">isTabOrNewline</c-><c- p="">(</c-><c- o="">*</c-><c- n="">iterator</c-><c- p="">))</c-> <c- p="">{</c->
            <c- n="">didSeeSyntaxViolation</c-> <c- o="">=</c-> true<c- p="">;</c->
            <c- o="">++</c-><c- n="">iterator</c-><c- p="">;</c->
            <c- k="">continue</c-><c- p="">;</c->
        <c- p="">}</c->
        <c- k="">if</c-> <c- p="">(</c-><c- o="">*</c-><c- n="">iterator</c-> <c- o="">==</c-> <c- sc="">'.'</c-><c- p="">)</c-> <c- p="">{</c->
            <c- n="">ASSERT</c-><c- p="">(</c-><c- o="">!</c-><c- n="">value</c-><c- p="">.</c-><c- n="">hasOverflowed</c-><c- p="">());</c->
            <c- k="">return</c-> <c- n="">value</c-><c- p="">.</c-><c- n="">unsafeGet</c-><c- p="">();</c->
        <c- p="">}</c->
        <c- k="">switch</c-> <c- p="">(</c-><c- n="">state</c-><c- p="">)</c-> <c- p="">{</c->
        <c- k="">case</c-> <c- n="">State</c-><c- o="">::</c-><c- nl="">UnknownBase</c-><c- p="">:</c->
            <c- k="">if</c-> <c- p="">(</c-><c- n="">UNLIKELY</c-><c- p="">(</c-><c- o="">*</c-><c- n="">iterator</c-> <c- o="">==</c-> <c- sc="">'0'</c-><c- p="">))</c-> <c- p="">{</c->
                <c- o="">++</c-><c- n="">iterator</c-><c- p="">;</c->
                <c- n="">state</c-> <c- o="">=</c-> <c- n="">State</c-><c- o="">::</c-><c- n="">OctalOrHex</c-><c- p="">;</c->
                <c- k="">break</c-><c- p="">;</c->
            <c- p="">}</c->
            <c- n="">state</c-> <c- o="">=</c-> <c- n="">State</c-><c- o="">::</c-><c- n="">Decimal</c-><c- p="">;</c->
            <c- k="">break</c-><c- p="">;</c->
        <c- k="">case</c-> <c- n="">State</c-><c- o="">::</c-><c- nl="">OctalOrHex</c-><c- p="">:</c->
            <c- n="">didSeeSyntaxViolation</c-> <c- o="">=</c-> true<c- p="">;</c->
            <c- k="">if</c-> <c- p="">(</c-><c- o="">*</c-><c- n="">iterator</c-> <c- o="">==</c-> <c- sc="">'x'</c-> <c- o="">||</c-> <c- o="">*</c-><c- n="">iterator</c-> <c- o="">==</c-> <c- sc="">'X'</c-><c- p="">)</c-> <c- p="">{</c->
                <c- o="">++</c-><c- n="">iterator</c-><c- p="">;</c->
                <c- n="">state</c-> <c- o="">=</c-> <c- n="">State</c-><c- o="">::</c-><c- n="">Hex</c-><c- p="">;</c->
                <c- k="">break</c-><c- p="">;</c->
            <c- p="">}</c->
            <c- n="">state</c-> <c- o="">=</c-> <c- n="">State</c-><c- o="">::</c-><c- n="">Octal</c-><c- p="">;</c->
            <c- k="">break</c-><c- p="">;</c->
        <c- k="">case</c-> <c- n="">State</c-><c- o="">::</c-><c- nl="">Decimal</c-><c- p="">:</c->
            <c- k="">if</c-> <c- p="">(</c-><c- o="">!</c-><c- n="">isASCIIDigit</c-><c- p="">(</c-><c- o="">*</c-><c- n="">iterator</c-><c- p="">))</c->
                <c- k="">return</c-> <c- n="">makeUnexpected</c-><c- p="">(</c-><c- n="">IPv4PieceParsingError</c-><c- o="">::</c-><c- n="">Failure</c-><c- p="">);</c->
            <c- n="">value</c-> <c- o="">*=</c-> <c- mi="">10</c-><c- p="">;</c->
            <c- n="">value</c-> <c- o="">+=</c-> <c- o="">*</c-><c- n="">iterator</c-> <c- o="">-</c-> <c- sc="">'0'</c-><c- p="">;</c->
            <c- k="">if</c-> <c- p="">(</c-><c- n="">UNLIKELY</c-><c- p="">(</c-><c- n="">value</c-><c- p="">.</c-><c- n="">hasOverflowed</c-><c- p="">()))</c->
                <c- k="">return</c-> <c- n="">makeUnexpected</c-><c- p="">(</c-><c- n="">IPv4PieceParsingError</c-><c- o="">::</c-><c- n="">Overflow</c-><c- p="">);</c->
            <c- o="">++</c-><c- n="">iterator</c-><c- p="">;</c->
            <c- k="">break</c-><c- p="">;</c->
        <c- k="">case</c-> <c- n="">State</c-><c- o="">::</c-><c- nl="">Octal</c-><c- p="">:</c->
            <c- n="">ASSERT</c-><c- p="">(</c-><c- n="">didSeeSyntaxViolation</c-><c- p="">);</c->
            <c- k="">if</c-> <c- p="">(</c-><c- o="">*</c-><c- n="">iterator</c-> <c- o="">&lt;</c-> <c- sc="">'0'</c-> <c- o="">||</c-> <c- o="">*</c-><c- n="">iterator</c-> <c- o="">&gt;</c-> <c- sc="">'7'</c-><c- p="">)</c->
                <c- k="">return</c-> <c- n="">makeUnexpected</c-><c- p="">(</c-><c- n="">IPv4PieceParsingError</c-><c- o="">::</c-><c- n="">Failure</c-><c- p="">);</c->
            <c- n="">value</c-> <c- o="">*=</c-> <c- mi="">8</c-><c- p="">;</c->
            <c- n="">value</c-> <c- o="">+=</c-> <c- o="">*</c-><c- n="">iterator</c-> <c- o="">-</c-> <c- sc="">'0'</c-><c- p="">;</c->
            <c- k="">if</c-> <c- p="">(</c-><c- n="">UNLIKELY</c-><c- p="">(</c-><c- n="">value</c-><c- p="">.</c-><c- n="">hasOverflowed</c-><c- p="">()))</c->
                <c- k="">return</c-> <c- n="">makeUnexpected</c-><c- p="">(</c-><c- n="">IPv4PieceParsingError</c-><c- o="">::</c-><c- n="">Overflow</c-><c- p="">);</c->
            <c- o="">++</c-><c- n="">iterator</c-><c- p="">;</c->
            <c- k="">break</c-><c- p="">;</c->
        <c- k="">case</c-> <c- n="">State</c-><c- o="">::</c-><c- nl="">Hex</c-><c- p="">:</c->
            <c- n="">ASSERT</c-><c- p="">(</c-><c- n="">didSeeSyntaxViolation</c-><c- p="">);</c->
            <c- k="">if</c-> <c- p="">(</c-><c- o="">!</c-><c- n="">isASCIIHexDigit</c-><c- p="">(</c-><c- o="">*</c-><c- n="">iterator</c-><c- p="">))</c->
                <c- k="">return</c-> <c- n="">makeUnexpected</c-><c- p="">(</c-><c- n="">IPv4PieceParsingError</c-><c- o="">::</c-><c- n="">Failure</c-><c- p="">);</c->
            <c- n="">value</c-> <c- o="">*=</c-> <c- mi="">16</c-><c- p="">;</c->
            <c- n="">value</c-> <c- o="">+=</c-> <c- n="">toASCIIHexValue</c-><c- p="">(</c-><c- o="">*</c-><c- n="">iterator</c-><c- p="">);</c->
            <c- k="">if</c-> <c- p="">(</c-><c- n="">UNLIKELY</c-><c- p="">(</c-><c- n="">value</c-><c- p="">.</c-><c- n="">hasOverflowed</c-><c- p="">()))</c->
                <c- k="">return</c-> <c- n="">makeUnexpected</c-><c- p="">(</c-><c- n="">IPv4PieceParsingError</c-><c- o="">::</c-><c- n="">Overflow</c-><c- p="">);</c->
            <c- o="">++</c-><c- n="">iterator</c-><c- p="">;</c->
            <c- k="">break</c-><c- p="">;</c->
        <c- p="">}</c->
    <c- p="">}</c->
    <c- n="">ASSERT</c-><c- p="">(</c-><c- o="">!</c-><c- n="">value</c-><c- p="">.</c-><c- n="">hasOverflowed</c-><c- p="">());</c->
    <c- k="">return</c-> <c- n="">value</c-><c- p="">.</c-><c- n="">unsafeGet</c-><c- p="">();</c->
<c- p="">}</c->
</pre>
   <p>These results are then accumulated in a vector , and different 
failure conditions are handled differently. An important fact to 
internalize is that the first failure encountered isn’t necessarily the 
one which is returned, which is why exceptions aren’t a good solution 
here: parsing must continue.</p>
<pre class="highlight"><c- k="">template</c-><c- o="">&lt;</c-><c- k="">typename</c-> <c- nc="">CharacterTypeForSyntaxViolation</c-><c- p="">,</c-> <c- k="">typename</c-> <c- nc="">CharacterType</c-><c- o="">&gt;</c->
<c- n="">Expected</c-><c- o="">&lt;</c-><c- n="">URLParser</c-><c- o="">::</c-><c- n="">IPv4Address</c-><c- p="">,</c-> <c- n="">URLParser</c-><c- o="">::</c-><c- n="">IPv4ParsingError</c-><c- o="">&gt;</c-> <c- n="">URLParser</c-><c- o="">::</c-><c- n="">parseIPv4Host</c-><c- p="">(</c-><c- k="">const</c-> <c- n="">CodePointIterator</c-><c- o="">&lt;</c-><c- n="">CharacterTypeForSyntaxViolation</c-><c- o="">&gt;&amp;</c-> <c- n="">iteratorForSyntaxViolationPosition</c-><c- p="">,</c-> <c- n="">CodePointIterator</c-><c- o="">&lt;</c-><c- n="">CharacterType</c-><c- o="">&gt;</c-> <c- n="">iterator</c-><c- p="">)</c->
<c- p="">{</c->
    <c- n="">Vector</c-><c- o="">&lt;</c-><c- n="">Expected</c-><c- o="">&lt;</c-><c- b="">uint32_t</c-><c- p="">,</c-> <c- n="">URLParser</c-><c- o="">::</c-><c- n="">IPv4PieceParsingError</c-><c- o="">&gt;</c-><c- p="">,</c-> <c- mi="">4</c-><c- o="">&gt;</c-> <c- n="">items</c-><c- p="">;</c->
    <c- b="">bool</c-> <c- n="">didSeeSyntaxViolation</c-> <c- o="">=</c-> false<c- p="">;</c->
    <c- k="">if</c-> <c- p="">(</c-><c- o="">!</c-><c- n="">iterator</c-><c- p="">.</c-><c- n="">atEnd</c-><c- p="">()</c-> <c- o="">&amp;&amp;</c-> <c- o="">*</c-><c- n="">iterator</c-> <c- o="">==</c-> <c- sc="">'.'</c-><c- p="">)</c->
        <c- k="">return</c-> <c- n="">makeUnexpected</c-><c- p="">(</c-><c- n="">IPv4ParsingError</c-><c- o="">::</c-><c- n="">NotIPv4</c-><c- p="">);</c->
    <c- k="">while</c-> <c- p="">(</c-><c- o="">!</c-><c- n="">iterator</c-><c- p="">.</c-><c- n="">atEnd</c-><c- p="">())</c-> <c- p="">{</c->
        <c- k="">if</c-> <c- p="">(</c-><c- n="">isTabOrNewline</c-><c- p="">(</c-><c- o="">*</c-><c- n="">iterator</c-><c- p="">))</c-> <c- p="">{</c->
            <c- n="">didSeeSyntaxViolation</c-> <c- o="">=</c-> true<c- p="">;</c->
            <c- o="">++</c-><c- n="">iterator</c-><c- p="">;</c->
            <c- k="">continue</c-><c- p="">;</c->
        <c- p="">}</c->
        <c- k="">if</c-> <c- p="">(</c-><c- n="">items</c-><c- p="">.</c-><c- n="">size</c-><c- p="">()</c-> <c- o="">&gt;=</c-> <c- mi="">4</c-><c- p="">)</c->
            <c- k="">return</c-> <c- n="">makeUnexpected</c-><c- p="">(</c-><c- n="">IPv4ParsingError</c-><c- o="">::</c-><c- n="">NotIPv4</c-><c- p="">);</c->
        <c- n="">items</c-><c- p="">.</c-><c- n="">append</c-><c- p="">(</c-><c- n="">parseIPv4Piece</c-><c- p="">(</c-><c- n="">iterator</c-><c- p="">,</c-> <c- n="">didSeeSyntaxViolation</c-><c- p="">));</c->
        <c- k="">if</c-> <c- p="">(</c-><c- o="">!</c-><c- n="">iterator</c-><c- p="">.</c-><c- n="">atEnd</c-><c- p="">()</c-> <c- o="">&amp;&amp;</c-> <c- o="">*</c-><c- n="">iterator</c-> <c- o="">==</c-> <c- sc="">'.'</c-><c- p="">)</c-> <c- p="">{</c->
            <c- o="">++</c-><c- n="">iterator</c-><c- p="">;</c->
            <c- k="">if</c-> <c- p="">(</c-><c- n="">iterator</c-><c- p="">.</c-><c- n="">atEnd</c-><c- p="">())</c->
                <c- n="">syntaxViolation</c-><c- p="">(</c-><c- n="">iteratorForSyntaxViolationPosition</c-><c- p="">);</c->
            <c- k="">else</c-> <c- nf="">if</c-> <c- p="">(</c-><c- o="">*</c-><c- n="">iterator</c-> <c- o="">==</c-> <c- sc="">'.'</c-><c- p="">)</c->
                <c- k="">return</c-> <c- n="">makeUnexpected</c-><c- p="">(</c-><c- n="">IPv4ParsingError</c-><c- o="">::</c-><c- n="">NotIPv4</c-><c- p="">);</c->
        <c- p="">}</c->
    <c- p="">}</c->
    <c- k="">if</c-> <c- p="">(</c-><c- o="">!</c-><c- n="">iterator</c-><c- p="">.</c-><c- n="">atEnd</c-><c- p="">()</c-> <c- o="">||</c-> <c- o="">!</c-><c- n="">items</c-><c- p="">.</c-><c- n="">size</c-><c- p="">()</c-> <c- o="">||</c-> <c- n="">items</c-><c- p="">.</c-><c- n="">size</c-><c- p="">()</c-> <c- o="">&gt;</c-> <c- mi="">4</c-><c- p="">)</c->
        <c- k="">return</c-> <c- n="">makeUnexpected</c-><c- p="">(</c-><c- n="">IPv4ParsingError</c-><c- o="">::</c-><c- n="">NotIPv4</c-><c- p="">);</c->
    <c- k="">for</c-> <c- p="">(</c-><c- k="">const</c-> <c- k="">auto</c-><c- o="">&amp;</c-> <c- nl="">item</c-> <c- p="">:</c-> <c- n="">items</c-><c- p="">)</c-> <c- p="">{</c->
        <c- k="">if</c-> <c- p="">(</c-><c- o="">!</c-><c- n="">item</c-><c- p="">.</c-><c- n="">hasValue</c-><c- p="">()</c-> <c- o="">&amp;&amp;</c-> <c- n="">item</c-><c- p="">.</c-><c- n="">error</c-><c- p="">()</c-> <c- o="">==</c-> <c- n="">IPv4PieceParsingError</c-><c- o="">::</c-><c- n="">Failure</c-><c- p="">)</c->
            <c- k="">return</c-> <c- n="">makeUnexpected</c-><c- p="">(</c-><c- n="">IPv4ParsingError</c-><c- o="">::</c-><c- n="">NotIPv4</c-><c- p="">);</c->
    <c- p="">}</c->
    <c- k="">for</c-> <c- p="">(</c-><c- k="">const</c-> <c- k="">auto</c-><c- o="">&amp;</c-> <c- nl="">item</c-> <c- p="">:</c-> <c- n="">items</c-><c- p="">)</c-> <c- p="">{</c->
        <c- k="">if</c-> <c- p="">(</c-><c- o="">!</c-><c- n="">item</c-><c- p="">.</c-><c- n="">hasValue</c-><c- p="">()</c-> <c- o="">&amp;&amp;</c-> <c- n="">item</c-><c- p="">.</c-><c- n="">error</c-><c- p="">()</c-> <c- o="">==</c-> <c- n="">IPv4PieceParsingError</c-><c- o="">::</c-><c- n="">Overflow</c-><c- p="">)</c->
            <c- k="">return</c-> <c- n="">makeUnexpected</c-><c- p="">(</c-><c- n="">IPv4ParsingError</c-><c- o="">::</c-><c- n="">Failure</c-><c- p="">);</c->
    <c- p="">}</c->
    <c- k="">if</c-> <c- p="">(</c-><c- n="">items</c-><c- p="">.</c-><c- n="">size</c-><c- p="">()</c-> <c- o="">&gt;</c-> <c- mi="">1</c-><c- p="">)</c-> <c- p="">{</c->
        <c- k="">for</c-> <c- p="">(</c-><c- b="">size_t</c-> <c- n="">i</c-> <c- o="">=</c-> <c- mi="">0</c-><c- p="">;</c-> <c- n="">i</c-> <c- o="">&lt;</c-> <c- n="">items</c-><c- p="">.</c-><c- n="">size</c-><c- p="">()</c-> <c- o="">-</c-> <c- mi="">1</c-><c- p="">;</c-> <c- n="">i</c-><c- o="">++</c-><c- p="">)</c-> <c- p="">{</c->
            <c- k="">if</c-> <c- p="">(</c-><c- n="">items</c-><c- p="">[</c-><c- n="">i</c-><c- p="">].</c-><c- n="">value</c-><c- p="">()</c-> <c- o="">&gt;</c-> <c- mi="">255</c-><c- p="">)</c->
                <c- k="">return</c-> <c- n="">makeUnexpected</c-><c- p="">(</c-><c- n="">IPv4ParsingError</c-><c- o="">::</c-><c- n="">Failure</c-><c- p="">);</c->
        <c- p="">}</c->
    <c- p="">}</c->
    <c- k="">if</c-> <c- p="">(</c-><c- n="">items</c-><c- p="">[</c-><c- n="">items</c-><c- p="">.</c-><c- n="">size</c-><c- p="">()</c-> <c- o="">-</c-> <c- mi="">1</c-><c- p="">].</c-><c- n="">value</c-><c- p="">()</c-> <c- o="">&gt;=</c-> <c- n="">pow256</c-><c- p="">(</c-><c- mi="">5</c-> <c- o="">-</c-> <c- n="">items</c-><c- p="">.</c-><c- n="">size</c-><c- p="">()))</c->
        <c- k="">return</c-> <c- n="">makeUnexpected</c-><c- p="">(</c-><c- n="">IPv4ParsingError</c-><c- o="">::</c-><c- n="">Failure</c-><c- p="">);</c->

    <c- k="">if</c-> <c- p="">(</c-><c- n="">didSeeSyntaxViolation</c-><c- p="">)</c->
        <c- n="">syntaxViolation</c-><c- p="">(</c-><c- n="">iteratorForSyntaxViolationPosition</c-><c- p="">);</c->
    <c- k="">for</c-> <c- p="">(</c-><c- k="">const</c-> <c- k="">auto</c-><c- o="">&amp;</c-> <c- nl="">item</c-> <c- p="">:</c-> <c- n="">items</c-><c- p="">)</c-> <c- p="">{</c->
        <c- k="">if</c-> <c- p="">(</c-><c- n="">item</c-><c- p="">.</c-><c- n="">value</c-><c- p="">()</c-> <c- o="">&gt;</c-> <c- mi="">255</c-><c- p="">)</c->
            <c- n="">syntaxViolation</c-><c- p="">(</c-><c- n="">iteratorForSyntaxViolationPosition</c-><c- p="">);</c->
    <c- p="">}</c->

    <c- k="">if</c-> <c- p="">(</c-><c- n="">UNLIKELY</c-><c- p="">(</c-><c- n="">items</c-><c- p="">.</c-><c- n="">size</c-><c- p="">()</c-> <c- o="">!=</c-> <c- mi="">4</c-><c- p="">))</c->
        <c- n="">syntaxViolation</c-><c- p="">(</c-><c- n="">iteratorForSyntaxViolationPosition</c-><c- p="">);</c->

    <c- n="">IPv4Address</c-> <c- n="">ipv4</c-> <c- o="">=</c-> <c- n="">items</c-><c- p="">.</c-><c- n="">takeLast</c-><c- p="">().</c-><c- n="">value</c-><c- p="">();</c->
    <c- k="">for</c-> <c- p="">(</c-><c- b="">size_t</c-> <c- n="">counter</c-> <c- o="">=</c-> <c- mi="">0</c-><c- p="">;</c-> <c- n="">counter</c-> <c- o="">&lt;</c-> <c- n="">items</c-><c- p="">.</c-><c- n="">size</c-><c- p="">();</c-> <c- o="">++</c-><c- n="">counter</c-><c- p="">)</c->
        <c- n="">ipv4</c-> <c- o="">+=</c-> <c- n="">items</c-><c- p="">[</c-><c- n="">counter</c-><c- p="">].</c-><c- n="">value</c-><c- p="">()</c-> <c- o="">*</c-> <c- n="">pow256</c-><c- p="">(</c-><c- mi="">3</c-> <c- o="">-</c-> <c- n="">counter</c-><c- p="">);</c->
    <c- k="">return</c-> <c- n="">ipv4</c-><c- p="">;</c->
<c- p="">}</c->
</pre>
   <h3 class="heading settled" data-level="2.2" id="ret"><span class="secno">2.2. </span><span class="content">Error retrieval and correction</span><a class="self-link" href="#ret"></a></h3>
   <p>The major advantage of <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-></code> over <code class="highlight"><c- n="">optional</c-><c- o="">&lt;</c-><c- n="">T</c-><c- o="">&gt;</c-></code> is the ability to transport an error. Programmer do the following when a function call returns an error:</p>
   <ol>
    <li data-md="">
     <p>Ignore it.</p>
    </li><li data-md="">
     <p>Delegate the responsibility of error handling to higher layer.</p>
    </li><li data-md="">
     <p>Try to resolve the error.</p>
   </li></ol>
   <p>Because the first behavior might lead to buggy application, we 
ignore the usecase. The handling is dependent of the underlying error 
type, we consider the <code class="highlight"><c- n="">exception_ptr</c-></code> and the <code class="highlight"><c- n="">errc</c-></code> types.</p>
   <h3 class="heading settled" data-level="2.3" id="impact"><span class="secno">2.3. </span><span class="content">Impact on the standard</span><a class="self-link" href="#impact"></a></h3>
   <p>These changes are entirely based on library extensions and do not require any
language features beyond what is available in C++20.</p>
   <h2 class="heading settled" data-level="3" id="rationale"><span class="secno">3. </span><span class="content">Design rationale</span><a class="self-link" href="#rationale"></a></h2>
   <p>The same rationale described in <a data-link-type="biblio" href="#biblio-n3672">[N3672]</a> for <code class="highlight"><c- n="">optional</c-><c- o="">&lt;</c-><c- n="">T</c-><c- o="">&gt;</c-></code> applies to <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-></code> and <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">nullopt_t</c-><c- o="">&gt;</c-></code> should behave almost the same as <code class="highlight"><c- n="">optional</c-><c- o="">&lt;</c-><c- n="">T</c-><c- o="">&gt;</c-></code> (though we advise using <code class="highlight"><c- n="">optional</c-></code> in that case). The following
sections presents the rationale in N3672 applied to <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-></code>.</p>
   <h3 class="heading settled" data-level="3.1" id="model"><span class="secno">3.1. </span><span class="content">Conceptual model of <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-></code></span><a class="self-link" href="#model"></a></h3>
   <p><code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-></code> models a discriminated union of types <code class="highlight"><c- n="">T</c-></code> and <code class="highlight"><c- n="">unexpected</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-></code>. <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-></code> is viewed as a value of type <code class="highlight"><c- n="">T</c-></code> or value of
type <code class="highlight"><c- n="">unexpected</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-></code>, allocated in the same storage, along with observers to
determine which of the two it is.</p>
   <p>The interface in this model requires operations such as comparison to <code class="highlight"><c- n="">T</c-></code>,
comparison to <code class="highlight"><c- n="">E</c-></code>, assignment and creation from either. It is easy to determine
what the value of the expected object is in this model: the type it stores (<code class="highlight"><c- n="">T</c-></code> or <code class="highlight"><c- n="">E</c-></code>) and either the value of <code class="highlight"><c- n="">T</c-></code> or the value of <code class="highlight"><c- n="">E</c-></code>.</p>
   <p>Additionally, within the affordable limits, we propose the view that <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-></code> extends the set of the values of <code class="highlight"><c- n="">T</c-></code> by the values of type <code class="highlight"><c- n="">E</c-></code>. This is reflected in initialization, assignment, ordering, and equality
comparison with both <code class="highlight"><c- n="">T</c-></code> and <code class="highlight"><c- n="">E</c-></code>. In the case of <code class="highlight"><c- n="">optional</c-><c- o="">&lt;</c-><c- n="">T</c-><c- o="">&gt;</c-></code>, <code class="highlight"><c- n="">T</c-></code> cannot be a <code class="highlight"><c- n="">nullopt_t</c-></code>. As the types <code class="highlight"><c- n="">T</c-></code> and <code class="highlight"><c- n="">E</c-></code> could be the same in <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-></code>,
there is need to tag the values of <code class="highlight"><c- n="">E</c-></code> to avoid ambiguous expressions. The <code class="highlight"><c- n="">unexpected</c-><c- p="">(</c-><c- n="">E</c-><c- p="">)</c-></code> deduction guide is proposed for this purpose. However <code class="highlight"><c- n="">T</c-></code> cannot
be <code class="highlight"><c- n="">unexpected</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-></code> for a given <code class="highlight"><c- n="">E</c-></code>.</p>
<pre class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- b="">int</c-><c- p="">,</c-> <c- n="">string</c-><c- o="">&gt;</c-> <c- n="">ei</c-> <c- o="">=</c-> <c- mi="">0</c-><c- p="">;</c->
<c- n="">expected</c-><c- o="">&lt;</c-><c- b="">int</c-><c- p="">,</c-> <c- n="">string</c-><c- o="">&gt;</c-> <c- n="">ej</c-> <c- o="">=</c-> <c- mi="">1</c-><c- p="">;</c->
<c- n="">expected</c-><c- o="">&lt;</c-><c- b="">int</c-><c- p="">,</c-> <c- n="">string</c-><c- o="">&gt;</c-> <c- n="">ek</c-> <c- o="">=</c-> <c- n="">unexpected</c-><c- p="">(</c-><c- n="">string</c-><c- p="">());</c->

<c- n="">ei</c-> <c- o="">=</c-> <c- mi="">1</c-><c- p="">;</c->
<c- n="">ej</c-> <c- o="">=</c-> <c- n="">unexpected</c-><c- p="">(</c-><c- n="">E</c-><c- p="">());;</c->
<c- n="">ek</c-> <c- o="">=</c-> <c- mi="">0</c-><c- p="">;</c->

<c- n="">ei</c-> <c- o="">=</c-> <c- n="">unexpected</c-><c- p="">(</c-><c- n="">E</c-><c- p="">());;</c->
<c- n="">ej</c-> <c- o="">=</c-> <c- mi="">0</c-><c- p="">;</c->
<c- n="">ek</c-> <c- o="">=</c-> <c- mi="">1</c-><c- p="">;</c->
</pre>
   <h3 class="heading settled" data-level="3.2" id="default-E"><span class="secno">3.2. </span><span class="content">Default <code class="highlight"><c- n="">E</c-></code> template paremeter type</span><a class="self-link" href="#default-E"></a></h3>
   <p>At the Toronto meeting LEWG decided against having a default <code class="highlight"><c- n="">E</c-></code> template
parameter type (<code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">error_code</c-></code> or other). This prevents us from providing an <code class="highlight"><c- n="">expected</c-></code> deduction guides for error construction which is a <em>good thing</em>: an
error was <strong>not</strong> expected, a <code class="highlight"><c- n="">T</c-></code> was expected, it’s therefore sensible to force
spelling out unexpected outcomes when generating them.</p>
   <h3 class="heading settled" data-level="3.3" id="init"><span class="secno">3.3. </span><span class="content">Initialization of <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-></code></span><a class="self-link" href="#init"></a></h3>
   <p>In cases where <code class="highlight"><c- n="">T</c-></code> and <code class="highlight"><c- n="">E</c-></code> have value semantic types capable of storing <code class="highlight"><c- n="">n</c-></code> and <code class="highlight"><c- n="">m</c-></code> distinct values respectively, <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-></code> can be seen as an extended <code class="highlight"><c- n="">T</c-></code> capable of storing <code class="highlight"><c- n="">n</c-> <c- o="">+</c-> <c- n="">m</c-></code> values: these <code class="highlight"><c- n="">T</c-></code> and <code class="highlight"><c- n="">E</c-></code> stores. Any valid
initialization scheme must provide a way to put an expected object to any of
these states. In addition, some <code class="highlight"><c- n="">T</c-></code>s aren’t <code class="highlight"><c- n="">CopyConstructible</c-></code> and their
expected variants still should be constructible with any set of arguments that
work for <code class="highlight"><c- n="">T</c-></code>.</p>
   <p>As in <a data-link-type="biblio" href="#biblio-n3672">[N3672]</a>, the model retained is to initialize either by providing an
already constructed <code class="highlight"><c- n="">T</c-></code> or a tagged <code class="highlight"><c- n="">E</c-></code>. The default constructor required <code class="highlight"><c- n="">T</c-></code> to
be default-constructible (since <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- o="">&gt;</c-></code> should behave like <code class="highlight"><c- n="">T</c-></code> as much as
possible).</p>
<pre class="language-c++ highlight"><c- n="">string</c-> <c- n="">s</c-><c- p="">{</c-><c- s="">"STR"</c-><c- p="">};</c->

<c- n="">expected</c-><c- o="">&lt;</c-><c- n="">string</c-><c- p="">,</c-> <c- n="">errc</c-><c- o="">&gt;</c-> <c- n="">es</c-><c- p="">{</c-><c- n="">s</c-><c- p="">};</c-> <c- c1="">// requires Copyable&lt;T&gt;</c->
<c- n="">expected</c-><c- o="">&lt;</c-><c- n="">string</c-><c- p="">,</c-> <c- n="">errc</c-><c- o="">&gt;</c-> <c- n="">et</c-> <c- o="">=</c-> <c- n="">s</c-><c- p="">;</c-> <c- c1="">// requires Copyable&lt;T&gt;</c->
<c- n="">expected</c-><c- o="">&lt;</c-><c- n="">string</c-><c- p="">,</c-> <c- n="">errc</c-><c- o="">&gt;</c-> <c- n="">ev</c-> <c- o="">=</c-> <c- n="">string</c-><c- p="">{</c-><c- s="">"STR"</c-><c- p="">};</c-> <c- c1="">// requires Movable&lt;T&gt;</c->

<c- n="">expected</c-><c- o="">&lt;</c-><c- n="">string</c-><c- p="">,</c-> <c- n="">errc</c-><c- o="">&gt;</c-> <c- n="">ew</c-><c- p="">;</c-> <c- c1="">// expected value</c->
<c- n="">expected</c-><c- o="">&lt;</c-><c- n="">string</c-><c- p="">,</c-> <c- n="">errc</c-><c- o="">&gt;</c-> <c- n="">ex</c-><c- p="">{};</c-> <c- c1="">// expected value</c->
<c- n="">expected</c-><c- o="">&lt;</c-><c- n="">string</c-><c- p="">,</c-> <c- n="">errc</c-><c- o="">&gt;</c-> <c- n="">ey</c-> <c- o="">=</c-> <c- p="">{};</c-> <c- c1="">// expected value</c->
<c- n="">expected</c-><c- o="">&lt;</c-><c- n="">string</c-><c- p="">,</c-> <c- n="">errc</c-><c- o="">&gt;</c-> <c- n="">ez</c-> <c- o="">=</c-> <c- n="">expected</c-><c- o="">&lt;</c-><c- n="">string</c-><c- p="">,</c-><c- n="">errc</c-><c- o="">&gt;</c-><c- p="">{};</c-> <c- c1="">// expected value</c->
</pre>
   <p>In order to create an unexpected object, the deduction guide <code class="highlight"><c- n="">unexpected</c-></code> needs
to be used:</p>
<pre class="language-c++ highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">string</c-><c- p="">,</c-> <c- b="">int</c-><c- o="">&gt;</c-> <c- n="">ep</c-><c- p="">{</c-><c- n="">unexpected</c-><c- p="">(</c-><c- mi="">-1</c-><c- p="">)};</c-> <c- c1="">// unexpected value, requires Movable&lt;E&gt;</c->
<c- n="">expected</c-><c- o="">&lt;</c-><c- n="">string</c-><c- p="">,</c-> <c- b="">int</c-><c- o="">&gt;</c-> <c- n="">eq</c-> <c- o="">=</c-> <c- n="">unexpected</c-><c- p="">(</c-><c- mi="">-1</c-><c- p="">);</c-> <c- c1="">// unexpected value, requires Movable&lt;E&gt;</c->
</pre>
   <p>As in <a data-link-type="biblio" href="#biblio-n3672">[N3672]</a>, and in order to avoid calling move/copy constructor of <code class="highlight"><c- n="">T</c-></code>, we
use a “tagged” placement constructor:</p>
<pre class="language-c++ highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">MoveOnly</c-><c- p="">,</c-> <c- n="">errc</c-><c- o="">&gt;</c-> <c- n="">eg</c-><c- p="">;</c-> <c- c1="">// expected value</c->
<c- n="">expected</c-><c- o="">&lt;</c-><c- n="">MoveOnly</c-><c- p="">,</c-> <c- n="">errc</c-><c- o="">&gt;</c-> <c- n="">eh</c-><c- p="">{};</c-> <c- c1="">// expected value</c->
<c- n="">expected</c-><c- o="">&lt;</c-><c- n="">MoveOnly</c-><c- p="">,</c-> <c- n="">errc</c-><c- o="">&gt;</c-> <c- n="">ei</c-><c- p="">{</c-><c- n="">in_place</c-><c- p="">};</c-> <c- c1="">// calls MoveOnly{} in place</c->
<c- n="">expected</c-><c- o="">&lt;</c-><c- n="">MoveOnly</c-><c- p="">,</c-> <c- n="">errc</c-><c- o="">&gt;</c-> <c- n="">ej</c-><c- p="">{</c-><c- n="">in_place</c-><c- p="">,</c-> <c- s="">"arg"</c-><c- p="">};</c-> <c- c1="">// calls MoveOnly{"arg"} in place</c->
</pre>
   <p>To avoid calling move/copy constructor of <code class="highlight"><c- n="">E</c-></code>, we use a “tagged” placement
constructor:</p>
<pre class="language-c++ highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- b="">int</c-><c- p="">,</c-> <c- n="">string</c-><c- o="">&gt;</c-> <c- n="">ei</c-><c- p="">{</c-><c- n="">unexpect</c-><c- p="">};</c-> <c- c1="">// unexpected value, calls string{} in place</c->
<c- n="">expected</c-><c- o="">&lt;</c-><c- b="">int</c-><c- p="">,</c-> <c- n="">string</c-><c- o="">&gt;</c-> <c- n="">ej</c-><c- p="">{</c-><c- n="">unexpect</c-><c- p="">,</c-> <c- s="">"arg"</c-><c- p="">};</c-> <c- c1="">// unexpected value, calls string{"arg"} in place</c->
</pre>
   <p>An alternative name for <code class="highlight"><c- n="">in_place</c-></code> that is coherent with <code class="highlight"><c- n="">unexpect</c-></code> could be <code class="highlight"><c- n="">expect</c-></code>. Being compatible with <code class="highlight"><c- n="">optional</c-><c- o="">&lt;</c-><c- n="">T</c-><c- o="">&gt;</c-></code> seems more important. So this
proposal doesn’t propose such an <code class="highlight"><c- n="">expect</c-></code> tag.</p>
   <p>The alternative and also comprehensive initialization approach, which is
compatible with the default construction of <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-></code> as <code class="highlight"><c- n="">T</c-><c- p="">()</c-></code>, could
have been a variadic perfect forwarding constructor that just forwards any set
of arguments to the constructor of the contained object of type <code class="highlight"><c- n="">T</c-></code>.</p>
   <h3 class="heading settled" data-level="3.4" id="never-empty"><span class="secno">3.4. </span><span class="content">Never-empty guarantee</span><a class="self-link" href="#never-empty"></a></h3>
   <p>As for <code class="highlight"><c- n="">boost</c-><c- o="">::</c-><c- n="">variant</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">unexpected</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;&gt;</c-></code>, <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-></code> ensures that it is
never empty. All instances <code class="highlight"><c- n="">v</c-></code> of type <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-></code> guarantee <code class="highlight"><c- n="">v</c-></code> has
constructed content of one of the types <code class="highlight"><c- n="">T</c-></code> or <code class="highlight"><c- n="">E</c-></code>, even if an operation on <code class="highlight"><c- n="">v</c-></code> has previously failed.</p>
   <p>This implies that <code class="highlight"><c- n="">expected</c-></code> may be viewed precisely as a union of exactly its
bounded types. This "never-empty" property insulates the user from the
possibility of undefined <code class="highlight"><c- n="">expected</c-></code> content or an <code class="highlight"><c- n="">expected</c-></code> <code class="highlight"><c- n="">valueless_by_exception</c-></code> as <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">variant</c-></code> and the significant additional
complexity-of-use attendant with such a possibility.</p>
   <p>In order to ensure this property the types <code class="highlight"><c- n="">T</c-></code> and <code class="highlight"><c- n="">E</c-></code> must satisfy the
requirements as described in <a data-link-type="biblio" href="#biblio-p0110r0">[P0110R0]</a>. Given the nature of the parameter <code class="highlight"><c- n="">E</c-></code>,
that is, to transport an error, it is expected to be <code class="highlight"><c- n="">is_nothrow_copy_constructible</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-></code>, <code class="highlight"><c- n="">is_nothrow_move_constructible</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-></code>, <code class="highlight"><c- n="">is_nothrow_copy_assignable</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-></code> and <code class="highlight"><c- n="">is_nothrow_move_assignable</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-></code>.</p>
   <p>Note however that these constraints are applied only to the operations that need
them.</p>
   <p>If <code class="highlight"><c- n="">is_nothrow_constructible</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">Args</c-><c- p="">...</c-><c- o="">&gt;</c-></code> is <code class="highlight">false</code>, the <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;::</c-><c- n="">emplace</c-><c- p="">(</c-><c- n="">Args</c-><c- p="">...)</c-></code> function is not defined. In this case, it is the
responsibility of the user to create a temporary and move or copy it.</p>
   <h3 class="heading settled" data-level="3.5" id="default-ctor"><span class="secno">3.5. </span><span class="content">The default constructor</span><a class="self-link" href="#default-ctor"></a></h3>
   <p>Similar data structure includes <code class="highlight"><c- n="">optional</c-><c- o="">&lt;</c-><c- n="">T</c-><c- o="">&gt;</c-></code>, <code class="highlight"><c- n="">variant</c-><c- o="">&lt;</c-><c- n="">T1</c-><c- p="">,...,</c-><c- n="">Tn</c-><c- o="">&gt;</c-></code> and <code class="highlight"><c- n="">future</c-><c- o="">&lt;</c-><c- n="">T</c-><c- o="">&gt;</c-></code>. We can compare how they are default constructed.</p>
   <ul>
    <li data-md="">
     <p><code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">optional</c-><c- o="">&lt;</c-><c- n="">T</c-><c- o="">&gt;</c-></code> default constructs to an optional with no value.</p>
    </li><li data-md="">
     <p><code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">variant</c-><c- o="">&lt;</c-><c- n="">T1</c-><c- p="">,...,</c-><c- n="">Tn</c-><c- o="">&gt;</c-></code> default constructs to <code class="highlight"><c- n="">T1</c-></code> if default constructible or it is ill-formed</p>
    </li><li data-md="">
     <p><code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">future</c-><c- o="">&lt;</c-><c- n="">T</c-><c- o="">&gt;</c-></code> default constructs to an invalid future with no shared state associated, that is, no value and no exception.</p>
    </li><li data-md="">
     <p><code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">optional</c-><c- o="">&lt;</c-><c- n="">T</c-><c- o="">&gt;</c-></code> default constructor is equivalent to <code class="highlight"><c- n="">boost</c-><c- o="">::</c-><c- n="">variant</c-><c- o="">&lt;</c-><c- n="">nullopt_t</c-><c- p="">,</c-> <c- n="">T</c-><c- o="">&gt;</c-></code>.</p>
   </li></ul>
   <p>This raises several questions about <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-></code>:</p>
   <ul>
    <li data-md="">
     <p>Should the default constructor of <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-></code> behave like <code class="highlight"><c- n="">variant</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">unexpected</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;&gt;</c-></code> or as <code class="highlight"><c- n="">variant</c-><c- o="">&lt;</c-><c- n="">unexpected</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-><c- p="">,</c-><c- n="">T</c-><c- o="">&gt;</c-></code>?</p>
    </li><li data-md="">
     <p>Should the default constructor of <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">nullopt_t</c-><c- o="">&gt;</c-></code> behave like <code class="highlight"><c- n="">optional</c-><c- o="">&lt;</c-><c- n="">T</c-><c- o="">&gt;</c-></code>? If yes, how should behave the default constructor of <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-></code>? As if initialized with <code class="highlight"><c- n="">unexpected</c-><c- p="">(</c-><c- n="">E</c-><c- p="">())</c-></code>? This would be equivalent to the initialization of <code class="highlight"><c- n="">variant</c-><c- o="">&lt;</c-><c- n="">unexpected</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-><c- p="">,</c-><c- n="">T</c-><c- o="">&gt;</c-></code>.</p>
    </li><li data-md="">
     <p>Should <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-></code> provide a default constructor at all? <a data-link-type="biblio" href="#biblio-n3527">[N3527]</a> presents valid arguments against this approach, e.g. <code class="highlight"><c- n="">array</c-><c- o="">&lt;</c-><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;&gt;</c-></code> would not be possible.</p>
   </li></ul>
   <p>Requiring <code class="highlight"><c- n="">E</c-></code> to be default constructible seems less constraining than requiring <code class="highlight"><c- n="">T</c-></code> to be default constructible (e.g. consider the <code class="highlight"><c- n="">Date</c-></code> example in <a data-link-type="biblio" href="#biblio-n3527">[N3527]</a>). With the same semantics <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">Date</c-><c- p="">,</c-><c- n="">E</c-><c- o="">&gt;</c-></code> would be <code class="highlight"><c- n="">Regular</c-></code> with a
meaningful not-a-date state created by default.</p>
   <p>The authors consider the arguments in <a data-link-type="biblio" href="#biblio-n3527">[N3527]</a> valid for <code class="highlight"><c- n="">optional</c-><c- o="">&lt;</c-><c- n="">T</c-><c- o="">&gt;</c-></code> and <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-></code>, however the committee requested that <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-></code> default
constructor should behave as constructed with <code class="highlight"><c- n="">T</c-><c- p="">()</c-></code> if <code class="highlight"><c- n="">T</c-></code> is default
constructible.</p>
   <h3 class="heading settled" data-level="3.6" id="void-error"><span class="secno">3.6. </span><span class="content">Could <code class="highlight"><c- n="">Error</c-></code> be <code class="highlight"><c- b="">void</c-></code></span><a class="self-link" href="#void-error"></a></h3>
   <p><code class="highlight"><c- b="">void</c-></code> isn’t a sensible <code class="highlight"><c- n="">E</c-></code> template parameter type: the <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- b="">void</c-><c- o="">&gt;</c-></code> vocabularity type means "I expect a <code class="highlight"><c- n="">T</c-></code>, but I may have nothing for you". This
is literally what <code class="highlight"><c- n="">optional</c-><c- o="">&lt;</c-><c- n="">T</c-><c- o="">&gt;</c-></code> is for. If the error is a unit type the user can
use <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">monostate</c-></code> or <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">nullopt</c-></code>.</p>
   <h3 class="heading settled" data-level="3.7" id="conv-T"><span class="secno">3.7. </span><span class="content">Conversion from <code class="highlight"><c- n="">T</c-></code></span><a class="self-link" href="#conv-T"></a></h3>
   <p>An object of type <code class="highlight"><c- n="">T</c-></code> is implicitly convertible to an expected object of type <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-></code>:</p>
<pre class="language-c++ highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- b="">int</c-><c- p="">,</c-> <c- n="">errc</c-><c- o="">&gt;</c-> <c- n="">ei</c-> <c- o="">=</c-> <c- mi="">1</c-><c- p="">;</c-> <c- c1="">// works</c->
</pre>
   <p>This convenience feature is not strictly necessary because you can achieve the
same effect by using tagged forwarding constructor:</p>
<pre class="language-c++ highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- b="">int</c-><c- p="">,</c-> <c- n="">errc</c-><c- o="">&gt;</c-> <c- n="">ei</c-><c- p="">{</c-><c- n="">in_place</c-><c- p="">,</c-> <c- mi="">1</c-><c- p="">};</c->
</pre>
   <p>It has been demonstrated that this implicit conversion is dangerous
[a-gotcha-with-optional].</p>
   <p>An alternative will be to make it explicit and add a <code class="highlight"><c- n="">success</c-><c- o="">&lt;</c-><c- n="">T</c-><c- o="">&gt;</c-></code> (similar to <code class="highlight"><c- n="">unexpected</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-></code> explicitly convertible from <code class="highlight"><c- n="">T</c-></code> and implicitly convertible to <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-></code>.</p>
<pre class="language-c++ highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- b="">int</c-><c- p="">,</c-> <c- n="">errc</c-><c- o="">&gt;</c-> <c- n="">ei</c-> <c- o="">=</c-> <c- n="">success</c-><c- p="">(</c-><c- mi="">1</c-><c- p="">);</c->
<c- n="">expected</c-><c- o="">&lt;</c-><c- b="">int</c-><c- p="">,</c-> <c- n="">errc</c-><c- o="">&gt;</c-> <c- n="">ej</c-> <c- o="">=</c-> <c- n="">unexpected</c-><c- p="">(</c-><c- n="">ec</c-><c- p="">);</c->
</pre>
   <p>The authors consider that it is safer to have the explicit conversion, the
implicit conversion is so friendly that we don’t propose yet an explicit
conversion. In addition <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">optional</c-></code> has already be delivered in C++17 and it
has this gotcha.</p>
   <p>Further, having <code class="highlight"><c- n="">success</c-></code> makes code much more verbose than the current implicit
conversion. Forcing the usage of <code class="highlight"><c- n="">success</c-></code> would make <code class="highlight"><c- n="">expected</c-></code> a much less
useful vocabulary type: if success is expected then success need not be called
out.</p>
   <h3 class="heading settled" data-level="3.8" id="conv-E"><span class="secno">3.8. </span><span class="content">Conversion from <code class="highlight"><c- n="">E</c-></code></span><a class="self-link" href="#conv-E"></a></h3>
   <p>An object of type <code class="highlight"><c- n="">E</c-></code> is not convertible to an unexpected object of type <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-></code> since <code class="highlight"><c- n="">E</c-></code> and <code class="highlight"><c- n="">T</c-></code> can be of the same type. The proposed
interface uses a special tag <code class="highlight"><c- n="">unexpect</c-></code> and <code class="highlight"><c- n="">unexpected</c-></code> deduction guide to
indicate an unexpected state for <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-></code>. It is used for construction
and assignment. This might raise a couple of objections. First, this duplication
is not strictly necessary because you can achieve the same effect by using the <code class="highlight"><c- n="">unexpect</c-></code> tag forwarding constructor:</p>
<pre class="language-c++ highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">string</c-><c- p="">,</c-> <c- n="">errc</c-><c- o="">&gt;</c-> <c- n="">exp1</c-> <c- o="">=</c-> <c- n="">unexpected</c-><c- p="">(</c-><c- mi="">1</c-><c- p="">);</c->
<c- n="">expected</c-><c- o="">&lt;</c-><c- n="">string</c-><c- p="">,</c-> <c- n="">errc</c-><c- o="">&gt;</c-> <c- n="">exp2</c-> <c- o="">=</c-> <c- p="">{</c-><c- n="">unexpect</c-><c- p="">,</c-> <c- mi="">1</c-><c- p="">};</c->
<c- n="">exp1</c-> <c- o="">=</c-> <c- n="">unexpected</c-><c- p="">(</c-><c- mi="">1</c-><c- p="">);</c->
<c- n="">exp2</c-> <c- o="">=</c-> <c- p="">{</c-><c- n="">unexpect</c-><c- p="">,</c-> <c- mi="">1</c-><c- p="">};</c->
</pre>
   <p>or simply using deduced template parameter for constructors</p>
<pre class="language-c++ highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">string</c-><c- p="">,</c-> <c- n="">errc</c-><c- o="">&gt;</c-> <c- n="">exp1</c-> <c- o="">=</c-> <c- n="">unexpected</c-><c- p="">(</c-><c- mi="">1</c-><c- p="">);</c->
<c- n="">exp1</c-> <c- o="">=</c-> <c- n="">unexpected</c-><c- p="">(</c-><c- mi="">1</c-><c- p="">);</c->
</pre>
   <p>While some situations would work with the <code class="highlight"><c- p="">{</c-><c- n="">unexpect</c-><c- p="">,</c-> <c- p="">...}</c-></code> syntax, using <code class="highlight"><c- n="">unexpected</c-></code> makes the programmer’s intention as clear and less cryptic. Compare
these:</p>
<pre class="language-c++ highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">vector</c-><c- o="">&lt;</c-><c- b="">int</c-><c- o="">&gt;</c-><c- p="">,</c-> <c- n="">errc</c-><c- o="">&gt;</c-> <c- n="">get1</c-><c- p="">()</c-> <c- p="">{}</c->
    <c- k="">return</c-> <c- p="">{</c-><c- n="">unexpect</c-><c- p="">,</c-> <c- mi="">1</c-><c- p="">};</c->
<c- p="">}</c->
<c- n="">expected</c-><c- o="">&lt;</c-><c- n="">vector</c-><c- o="">&lt;</c-><c- b="">int</c-><c- o="">&gt;</c-><c- p="">,</c-> <c- n="">errc</c-><c- o="">&gt;</c-> <c- n="">get2</c-><c- p="">()</c-> <c- p="">{</c->
    <c- k="">return</c-> <c- nf="">unexpected</c-><c- p="">(</c-><c- mi="">1</c-><c- p="">);</c->
<c- p="">}</c->
<c- n="">expected</c-><c- o="">&lt;</c-><c- n="">vector</c-><c- o="">&lt;</c-><c- b="">int</c-><c- o="">&gt;</c-><c- p="">,</c-> <c- n="">errc</c-><c- o="">&gt;</c-> <c- n="">get3</c-><c- p="">()</c-> <c- p="">{</c->
    <c- k="">return</c-> <c- n="">expected</c-><c- o="">&lt;</c-><c- n="">vector</c-><c- o="">&lt;</c-><c- b="">int</c-><c- o="">&gt;</c-><c- p="">,</c-> <c- b="">int</c-><c- o="">&gt;</c-><c- p="">{</c-><c- n="">unexpect</c-><c- p="">,</c-> <c- mi="">1</c-><c- p="">};</c->
<c- p="">}</c->
<c- n="">expected</c-><c- o="">&lt;</c-><c- n="">vector</c-><c- o="">&lt;</c-><c- b="">int</c-><c- o="">&gt;</c-><c- p="">,</c-> <c- n="">errc</c-><c- o="">&gt;</c-> <c- n="">get2</c-><c- p="">()</c-> <c- p="">{</c->
    <c- k="">return</c-> <c- nf="">unexpected</c-><c- p="">(</c-><c- mi="">1</c-><c- p="">);</c->
<c- p="">}</c->
</pre>
   <p>The usage of <code class="highlight"><c- n="">unexpected</c-></code> is also a consequence of the adapted model for <code class="highlight"><c- n="">expected</c-></code>: a discriminated union of <code class="highlight"><c- n="">T</c-></code> and <code class="highlight"><c- n="">unexpected</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-></code>.</p>
   <h3 class="heading settled" data-level="3.9" id="exp2"><span class="secno">3.9. </span><span class="content">Should we support the <code class="highlight"><c- n="">exp2</c-> <c- o="">=</c-> <c- p="">{}</c-></code>?</span><a class="self-link" href="#exp2"></a></h3>
   <p>Note also that the definition of <code class="highlight"><c- n="">unexpected</c-></code> has an explicitly deleted default
constructor. This was in order to enable the reset idiom <code class="highlight"><c- n="">exp2</c-> <c- o="">=</c-> <c- p="">{}</c-></code> which would
otherwise not work due to the ambiguity when deducing the right-hand side
argument.</p>
   <p>Now that <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-></code> defaults to <code class="highlight"><c- n="">T</c-><c- p="">{}</c-></code> the meaning of <code class="highlight"><c- n="">exp2</c-> <c- o="">=</c-> <c- p="">{}</c-></code> is to
assign <code class="highlight"><c- n="">T</c-><c- p="">{}</c-></code>.</p>
   <h3 class="heading settled" data-level="3.10" id="observers"><span class="secno">3.10. </span><span class="content">Observers</span><a class="self-link" href="#observers"></a></h3>
   <p>In order to be as efficient as possible, this proposal includes observers with
narrow and wide contracts. Thus, the <code class="highlight"><c- n="">value</c-><c- p="">()</c-></code> function has a wide contract. If
the expected object does not contain a value, an exception is thrown. However,
when the user knows that the expected object is valid, the use of <code class="highlight"><c- k="">operator</c-><c- o="">*</c-></code> would be more appropriated.</p>
   <h3 class="heading settled" data-level="3.11" id="explicit-bool"><span class="secno">3.11. </span><span class="content">Explicit conversion to <code class="highlight"><c- b="">bool</c-></code></span><a class="self-link" href="#explicit-bool"></a></h3>
   <p>The rational described in <a data-link-type="biblio" href="#biblio-n3672">[N3672]</a> for <code class="highlight"><c- n="">optional</c-><c- o="">&lt;</c-><c- n="">T</c-><c- o="">&gt;</c-></code> applies to <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-></code>. The following example therefore combines initialization and value-checking
in a boolean context.</p>
<pre class="language-c++ highlight"><c- k="">if</c-> <c- p="">(</c-><c- n="">expected</c-><c- o="">&lt;</c-><c- b="">char</c-><c- p="">,</c-> <c- n="">errc</c-><c- o="">&gt;</c-> <c- n="">ch</c-> <c- o="">=</c-> <c- n="">readNextChar</c-><c- p="">())</c-> <c- p="">{</c->
<c- c1="">// ...</c->
<c- p="">}</c->
</pre>
   <h3 class="heading settled" data-level="3.12" id="p0032"><span class="secno">3.12. </span><span class="content"><code class="highlight"><c- n="">has_value</c-><c- p="">()</c-></code> following P0032</span><a class="self-link" href="#p0032"></a></h3>
   <p><code class="highlight"><c- n="">has_value</c-><c- p="">()</c-></code> has been added to follow <a data-link-type="biblio" href="#biblio-p0032r2">[P0032R2]</a>.</p>
   <h3 class="heading settled" data-level="3.13" id="contained-value"><span class="secno">3.13. </span><span class="content">Accessing the contained value</span><a class="self-link" href="#contained-value"></a></h3>
   <p>Even if <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-></code> has not been used in practice for enough time as <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">optional</c-></code> or Boost.Optional, we consider that following the same interface
as <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">optional</c-><c- o="">&lt;</c-><c- n="">T</c-><c- o="">&gt;</c-></code> makes the C++ standard library more homogeneous.</p>
   <p>The rational described in <a data-link-type="biblio" href="#biblio-n3672">[N3672]</a> for <code class="highlight"><c- n="">optional</c-><c- o="">&lt;</c-><c- n="">T</c-><c- o="">&gt;</c-></code> applies to <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-></code>.</p>
   <h3 class="heading settled" data-level="3.14" id="deref"><span class="secno">3.14. </span><span class="content">Dereference operator</span><a class="self-link" href="#deref"></a></h3>
   <p>The indirection operator was chosen because, along with explicit conversion to <code class="highlight"><c- b="">bool</c-></code>, it is a very common pattern for accessing a value that might not be
there:</p>
<pre class="language-c++ highlight"><c- k="">if</c-> <c- p="">(</c-><c- n="">p</c-><c- p="">)</c-> <c- n="">use</c-><c- p="">(</c-><c- o="">*</c-><c- n="">p</c-><c- p="">);</c->
</pre>
   <p>This pattern is used for all sort of pointers (smart or raw) and <code class="highlight"><c- n="">optional</c-></code>; it
clearly indicates the fact that the value may be missing and that we return a
reference rather than a value. The indirection operator created some objections
because it may incorrectly imply <code class="highlight"><c- n="">expected</c-></code> and <code class="highlight"><c- n="">optional</c-></code> are a (possibly
smart) pointer, and thus provides shallow copy and comparison semantics. All
library components so far use indirection operator to return an object that is
not part of the pointer’s/iterator’s value. In contrast, <code class="highlight"><c- n="">expected</c-></code> as well as <code class="highlight"><c- n="">optional</c-></code> indirects to the part of its own state. We do not consider it a
problem in the design; it is more like an unprecedented usage of indirection
operator. We believe that the cost of potential confusion is overweighted by the
benefit of an intuitive interface for accessing the contained value.</p>
   <p>We do not think that providing an implicit conversion to <code class="highlight"><c- n="">T</c-></code> would be a good
choice. First, it would require different way of checking for the empty state;
and second, such implicit conversion is not perfect and still requires other
means of accessing the contained value if we want to call a member function on
it.</p>
   <p>Using the indirection operator for an object that does not contain a value is
undefined behavior. This behavior offers maximum runtime performance.</p>
   <h3 class="heading settled" data-level="3.15" id="func-val"><span class="secno">3.15. </span><span class="content">Function value</span><a class="self-link" href="#func-val"></a></h3>
   <p>In addition to the indirection operator, we propose the member function <code class="highlight"><c- n="">value</c-></code> as in <a data-link-type="biblio" href="#biblio-n3672">[N3672]</a> that returns a reference to the contained value if one exists or
throw an exception otherwise.</p>
<pre class="language-c++ highlight"><c- b="">void</c-> <c- nf="">interact</c-><c- p="">()</c-> <c- p="">{</c->
    <c- n="">string</c-> <c- n="">s</c-><c- p="">;</c->
    <c- n="">cout</c-> <c- o="">&lt;&lt;</c-> <c- s="">"enter number: "</c-><c- p="">;</c->
    <c- n="">cin</c-> <c- o="">&gt;&gt;</c-> <c- n="">s</c-><c- p="">;</c->
    <c- n="">expected</c-><c- o="">&lt;</c-><c- b="">int</c-><c- p="">,</c-> <c- n="">error</c-><c- o="">&gt;</c-> <c- n="">ei</c-> <c- o="">=</c-> <c- n="">str2int</c-><c- p="">(</c-><c- n="">s</c-><c- p="">);</c->
    <c- n="">try</c-> <c- p="">{</c->
        <c- n="">process_int</c-><c- p="">(</c-><c- n="">ei</c-><c- p="">.</c-><c- n="">value</c-><c- p="">());</c->
    <c- p="">}</c->
    <c- n="">catch</c-><c- p="">(</c-><c- n="">bad_expected_access</c-><c- o="">&lt;</c-><c- n="">error</c-><c- o="">&gt;</c-><c- p="">)</c-> <c- p="">{</c->
        <c- n="">cout</c-> <c- o="">&lt;&lt;</c-> <c- s="">"this was not a number."</c-><c- p="">;</c->
    <c- p="">}</c->
<c- p="">}</c->
</pre>
   <p>The exception thrown is <code class="highlight"><c- n="">bad_expected_access</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-></code> (derived from <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">exception</c-></code>) which will contain the stored error.</p>
   <p><code class="highlight"><c- n="">bad_expected_access</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-></code> and <code class="highlight"><c- n="">bad_optional_access</c-></code> could inherit both from a <code class="highlight"><c- n="">bad_access</c-></code> exception derived from <code class="highlight"><c- n="">exception</c-></code>, but this is not proposed yet.</p>
   <h3 class="heading settled" data-level="3.16" id="bad-expected"><span class="secno">3.16. </span><span class="content">Should <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;::</c-><c- n="">value</c-><c- p="">()</c-></code> throw <code class="highlight"><c- n="">E</c-></code> instead of <code class="highlight"><c- n="">bad_expected_access</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-></code>?</span><a class="self-link" href="#bad-expected"></a></h3>
   <p>As any type can be thrown as an exception, should <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-></code> throw <code class="highlight"><c- n="">E</c-></code> instead of <code class="highlight"><c- n="">bad_expected_access</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-></code>?</p>
   <p>Some argument that standard function should throw exceptions that inherit from <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">exception</c-></code>, but here the exception throw is given by the user via the type <code class="highlight"><c- n="">E</c-></code>, it is not the standard library that throws explicitly an exception that
don’t inherit from <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">exception</c-></code>.</p>
   <p>This could be convenient as the user will have directly the <code class="highlight"><c- n="">E</c-></code> exception. However it will be more difficult to identify that this was due to a
bad expected access.</p>
   <p>If yes, should <code class="highlight"><c- n="">optional</c-><c- o="">&lt;</c-><c- n="">T</c-><c- o="">&gt;</c-></code> throw <code class="highlight"><c- n="">nullopt_t</c-></code> instead of <code class="highlight"><c- n="">bad_optional_access</c-></code> to be coherent?</p>
   <p>We don’t propose this.</p>
   <p>Other have suggested to throw <code class="highlight"><c- n="">system_error</c-></code> if <code class="highlight"><c- n="">E</c-></code> is <code class="highlight"><c- n="">error_code</c-></code>, rethrow if <code class="highlight"><c- n="">E</c-></code> is <code class="highlight"><c- n="">exception_ptr</c-></code>, <code class="highlight"><c- n="">E</c-></code> if it inherits from <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">exception</c-></code> and <code class="highlight"><c- n="">bad_expected_access</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-></code> otherwise.</p>
   <p>An alternative would be to add some customization point that state which
exception is thrown but we don’t propose it in this proposal. See the Appendix I.</p>
   <h3 class="heading settled" data-level="3.17" id="access-error"><span class="secno">3.17. </span><span class="content">Accessing the contained error</span><a class="self-link" href="#access-error"></a></h3>
   <p>Usually, accessing the contained error is done once we know the expected object
has no value. This is why the <code class="highlight"><c- n="">error</c-><c- p="">()</c-></code> function has a narrow contract: it works
only if <code class="highlight"><c- o="">*</c-><c- k="">this</c-></code> does not contain a value.</p>
<pre class="language-c++ highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- b="">int</c-><c- p="">,</c-> <c- n="">errc</c-><c- o="">&gt;</c-> <c- n="">getIntOrZero</c-><c- p="">(</c-><c- n="">istream_range</c-><c- o="">&amp;</c-> <c- n="">r</c-><c- p="">)</c-> <c- p="">{</c->
    <c- k="">auto</c-> <c- n="">r</c-> <c- o="">=</c-> <c- n="">getInt</c-><c- p="">();</c-> <c- c1="">// won’t throw</c->
    <c- k="">if</c-> <c- p="">(</c-><c- o="">!</c-><c- n="">r</c-> <c- o="">&amp;&amp;</c-> <c- n="">r</c-><c- p="">.</c-><c- n="">error</c-><c- p="">()</c-> <c- o="">==</c-> <c- n="">errc</c-><c- o="">::</c-><c- n="">empty_stream</c-><c- p="">)</c-> <c- p="">{</c->
        <c- k="">return</c-> <c- mi="">0</c-><c- p="">;</c->
    <c- p="">}</c->
    <c- k="">return</c-> <c- n="">r</c-><c- p="">;</c->
<c- p="">}</c->
</pre>
   <p>This behavior could not be obtained with the <code class="highlight"><c- n="">value_or</c-><c- p="">()</c-></code> method since we want
to return <code class="highlight"><c- mi="">0</c-></code> only if the error is equal to <code class="highlight"><c- n="">empty_stream</c-></code>.</p>
   <p>We could as well provide an error access function with a wide contract. We just
need to see how to name each one.</p>
   <h3 class="heading settled" data-level="3.18" id="unexpected-conv"><span class="secno">3.18. </span><span class="content">Conversion to the unexpected value</span><a class="self-link" href="#unexpected-conv"></a></h3>
   <p>The <code class="highlight"><c- n="">error</c-><c- p="">()</c-></code> function is used to propagate errors, as for example in the next
example:</p>
<pre class="language-c++ highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">pair</c-><c- o="">&lt;</c-><c- b="">int</c-><c- p="">,</c-> <c- b="">int</c-><c- o="">&gt;</c-><c- p="">,</c-> <c- n="">errc</c-><c- o="">&gt;</c-> <c- n="">getIntRange</c-><c- p="">(</c-><c- n="">istream_range</c-><c- o="">&amp;</c-> <c- n="">r</c-><c- p="">)</c-> <c- p="">{</c->
    <c- k="">auto</c-> <c- n="">f</c-> <c- o="">=</c-> <c- n="">getInt</c-><c- p="">(</c-><c- n="">r</c-><c- p="">);</c->
    <c- k="">if</c-> <c- p="">(</c-><c- o="">!</c-><c- n="">f</c-><c- p="">)</c-> <c- k="">return</c-> <c- n="">unexpected</c-><c- p="">(</c-><c- n="">f</c-><c- p="">.</c-><c- n="">error</c-><c- p="">());</c->
    <c- k="">auto</c-> <c- n="">m</c-> <c- o="">=</c-> <c- n="">matchedString</c-><c- p="">(</c-><c- s="">".."</c-><c- p="">,</c-> <c- n="">r</c-><c- p="">);</c->
    <c- k="">if</c-> <c- p="">(</c-><c- o="">!</c-><c- n="">m</c-><c- p="">)</c-> <c- k="">return</c-> <c- n="">unexpected</c-><c- p="">(</c-><c- n="">m</c-><c- p="">.</c-><c- n="">error</c-><c- p="">());</c->
    <c- k="">auto</c-> <c- n="">l</c-> <c- o="">=</c-> <c- n="">getInt</c-><c- p="">(</c-><c- n="">r</c-><c- p="">);</c->
    <c- k="">if</c-> <c- p="">(</c-><c- o="">!</c-><c- n="">l</c-><c- p="">)</c-> <c- k="">return</c-> <c- n="">unexpected</c-><c- p="">(</c-><c- n="">l</c-><c- p="">.</c-><c- n="">error</c-><c- p="">());</c->
    <c- k="">return</c-> <c- n="">std</c-><c- o="">::</c-><c- n="">make_pair</c-><c- p="">(</c-><c- o="">*</c-><c- n="">f</c-><c- p="">,</c-> <c- o="">*</c-><c- n="">l</c-><c- p="">);</c->
<c- p="">}</c->
</pre>
   <h3 class="heading settled" data-level="3.19" id="value-or"><span class="secno">3.19. </span><span class="content">Function <code class="highlight"><c- n="">value_or</c-></code></span><a class="self-link" href="#value-or"></a></h3>
   <p>The function member <code class="highlight"><c- n="">value_or</c-><c- p="">()</c-></code> has the same semantics than <code class="highlight"><c- n="">optional</c-></code> <a data-link-type="biblio" href="#biblio-n3672">[N3672]</a> since the type of <code class="highlight"><c- n="">E</c-></code> doesn’t matter; hence we can consider that <code class="highlight"><c- n="">E</c-> <c- o="">==</c-> <c- n="">nullopt_t</c-></code> and the <code class="highlight"><c- n="">optional</c-></code> semantics yields.</p>
   <p>This function is a convenience function that should be a non-member function for <code class="highlight"><c- n="">optional</c-></code> and <code class="highlight"><c- n="">expected</c-></code>, however as it is already part of the <code class="highlight"><c- n="">optional</c-></code> interface we propose to have it also for <code class="highlight"><c- n="">expected</c-></code>.</p>
   <h3 class="heading settled" data-level="3.20" id="eq"><span class="secno">3.20. </span><span class="content">Equality operators</span><a class="self-link" href="#eq"></a></h3>
   <p>As for <code class="highlight"><c- n="">optional</c-></code> and <code class="highlight"><c- n="">variant</c-></code>, one of the design goals of <code class="highlight"><c- n="">expected</c-></code> is that
objects of type <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-></code> should be valid elements in STL containers and
usable with STL algorithms (at least if objects of type <code class="highlight"><c- n="">T</c-></code> and <code class="highlight"><c- n="">E</c-></code> are). Equality comparison is essential for <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-></code> to model concept <code class="highlight"><c- n="">Regular</c-></code>. C++ does not have concepts yet, but being regular is still essential
for the type to be effectively used with STL.</p>
   <h3 class="heading settled" data-level="3.21" id="comparison"><span class="secno">3.21. </span><span class="content">Comparison operators</span><a class="self-link" href="#comparison"></a></h3>
   <p>Comparison operators between <code class="highlight"><c- n="">expected</c-></code> objects, and between mixed <code class="highlight"><c- n="">expected</c-></code> and <code class="highlight"><c- n="">unexpected</c-></code>, aren’t required at this time. A future proposal could re-adopt
the comparisons as defined in <a data-link-type="biblio" href="#biblio-p0323r2">[P0323R2]</a>.</p>
   <h3 class="heading settled" data-level="3.22" id="modifiers"><span class="secno">3.22. </span><span class="content">Modifiers</span><a class="self-link" href="#modifiers"></a></h3>
   <h3 class="heading settled" data-level="3.23" id="reset"><span class="secno">3.23. </span><span class="content">Resetting the value</span><a class="self-link" href="#reset"></a></h3>
   <p>Reseting the value of <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-></code> is similar to <code class="highlight"><c- n="">optional</c-><c- o="">&lt;</c-><c- n="">T</c-><c- o="">&gt;</c-></code> but instead
of building a disengaged <code class="highlight"><c- n="">optional</c-><c- o="">&lt;</c-><c- n="">T</c-><c- o="">&gt;</c-></code>, we build an erroneous <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-></code>. Hence, the semantics and rationale is the same than in <a data-link-type="biblio" href="#biblio-n3672">[N3672]</a>.</p>
   <h3 class="heading settled" data-level="3.24" id="in_place"><span class="secno">3.24. </span><span class="content">Tag <code class="highlight"><c- n="">in_place</c-></code></span><a class="self-link" href="#in_place"></a></h3>
   <p>This proposal makes use of the "in-place" tag as defined in [C++17]. This
proposal provides the same kind of "in-place" constructor that forwards
(perfectly) the arguments provided to <code class="highlight"><c- n="">expected</c-></code>'s constructor into the
constructor of <code class="highlight"><c- n="">T</c-></code>.</p>
   <p>In order to trigger this constructor one has to use the tag <code class="highlight"><c- n="">in_place</c-></code>. We need
the extra tag to disambiguate certain situations, like calling <code class="highlight"><c- n="">expected</c-></code>'s
default constructor and requesting <code class="highlight"><c- n="">T</c-></code>'s default construction:</p>
<pre class="language-c++ highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">Big</c-><c- p="">,</c-> <c- n="">error</c-><c- o="">&gt;</c-> <c- n="">eb</c-><c- p="">{</c-><c- n="">in_place</c-><c- p="">,</c-> <c- s="">"1"</c-><c- p="">};</c-> <c- c1="">// calls Big{"1"} in place (no moving)</c->
<c- n="">expected</c-><c- o="">&lt;</c-><c- n="">Big</c-><c- p="">,</c-> <c- n="">error</c-><c- o="">&gt;</c-> <c- n="">ec</c-><c- p="">{</c-><c- n="">in_place</c-><c- p="">};</c-> <c- c1="">// calls Big{} in place (no moving)</c->
<c- n="">expected</c-><c- o="">&lt;</c-><c- n="">Big</c-><c- p="">,</c-> <c- n="">error</c-><c- o="">&gt;</c-> <c- n="">ed</c-><c- p="">{};</c-> <c- c1="">// calls Big{} (expected state)</c->
</pre>
   <h3 class="heading settled" data-level="3.25" id="unexpect"><span class="secno">3.25. </span><span class="content">Tag <code class="highlight"><c- n="">unexpect</c-></code></span><a class="self-link" href="#unexpect"></a></h3>
   <p>This proposal provides an "unexpect" constructor that forwards (perfectly) the
arguments provided to <code class="highlight"><c- n="">expected</c-></code>'s constructor into the constructor of <code class="highlight"><c- n="">E</c-></code>. In
order to trigger this constructor one has to use the tag <code class="highlight"><c- n="">unexpect</c-></code>.</p>
   <p>We need the extra tag to disambiguate certain situations, notably if <code class="highlight"><c- n="">T</c-></code> and <code class="highlight"><c- n="">E</c-></code> are the same type.</p>
<pre class="language-c++ highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">Big</c-><c- p="">,</c-> <c- n="">error</c-><c- o="">&gt;</c-> <c- n="">eb</c-><c- p="">{</c-><c- n="">unexpect</c-><c- p="">,</c-> <c- s="">"1"</c-><c- p="">};</c-> <c- c1="">// calls error{"1"} in place (no moving)</c->
<c- n="">expected</c-><c- o="">&lt;</c-><c- n="">Big</c-><c- p="">,</c-> <c- n="">error</c-><c- o="">&gt;</c-> <c- n="">ec</c-><c- p="">{</c-><c- n="">unexpect</c-><c- p="">};</c-> <c- c1="">// calls error{} in place (no moving)</c->
</pre>
   <p>In order to make the tag uniform an additional "expect" constructor could be
provided but this proposal doesn’t propose it.</p>
   <h3 class="heading settled" data-level="3.26" id="requirements"><span class="secno">3.26. </span><span class="content">Requirements on <code class="highlight"><c- n="">T</c-></code> and <code class="highlight"><c- n="">E</c-></code></span><a class="self-link" href="#requirements"></a></h3>
   <p>Class template <code class="highlight"><c- n="">expected</c-></code> imposes little requirements on <code class="highlight"><c- n="">T</c-></code> and <code class="highlight"><c- n="">E</c-></code>: they have
to be complete object type satisfying the requirements of <code class="highlight"><c- n="">Destructible</c-></code>. Each
operations on <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-></code> have different requirements and may be disable if <code class="highlight"><c- n="">T</c-></code> or <code class="highlight"><c- n="">E</c-></code> doesn’t respect these requirements. For example, <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-></code>'s
move constructor requires that <code class="highlight"><c- n="">T</c-></code> and <code class="highlight"><c- n="">E</c-></code> are <code class="highlight"><c- n="">MoveConstructible</c-></code>, <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-></code>'s copy constructor requires that <code class="highlight"><c- n="">T</c-></code> and <code class="highlight"><c- n="">E</c-></code> are <code class="highlight"><c- n="">CopyConstructible</c-></code>, and so
on. This is because <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-></code> is a wrapper for <code class="highlight"><c- n="">T</c-></code> or <code class="highlight"><c- n="">E</c-></code>: it should
resemble <code class="highlight"><c- n="">T</c-></code> or <code class="highlight"><c- n="">E</c-></code> as much as possible. If <code class="highlight"><c- n="">T</c-></code> and <code class="highlight"><c- n="">E</c-></code> are <code class="highlight"><c- n="">EqualityComparable</c-></code> then (and only then) we expect <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-></code> to be <code class="highlight"><c- n="">EqualityComparable</c-></code>.</p>
   <p>However in order to ensure the never empty guaranties, <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-></code> requires <code class="highlight"><c- n="">E</c-></code> to be no throw move constructible. This is normal as the <code class="highlight"><c- n="">E</c-></code> stands for an
error, and throwing while reporting an error is a very bad thing.</p>
   <h3 class="heading settled" data-level="3.27" id="expected-references"><span class="secno">3.27. </span><span class="content">Expected references</span><a class="self-link" href="#expected-references"></a></h3>
   <p>This proposal doesn’t include <code class="highlight"><c- n="">expected</c-></code> references as <code class="highlight"><c- n="">optional</c-></code> C++17
doesn’t include references either.</p>
   <p>We need a future proposal.</p>
   <h3 class="heading settled" data-level="3.28" id="void"><span class="secno">3.28. </span><span class="content">Expected <code class="highlight"><c- b="">void</c-></code></span><a class="self-link" href="#void"></a></h3>
   <p>While it could seem weird to instantiate <code class="highlight"><c- n="">optional</c-></code> with <code class="highlight"><c- b="">void</c-></code>, it has more
sense for <code class="highlight"><c- n="">expected</c-></code> as it conveys in addition, as <code class="highlight"><c- n="">future</c-><c- o="">&lt;</c-><c- n="">T</c-><c- o="">&gt;</c-></code>, an error
state. The type <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- b="">void</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-></code> means "nothing is expected, but an error
could occur".</p>
   <h3 class="heading settled" data-level="3.29" id="literal"><span class="secno">3.29. </span><span class="content">Making expected a literal type</span><a class="self-link" href="#literal"></a></h3>
   <p>In <a data-link-type="biblio" href="#biblio-n3672">[N3672]</a>, they propose to make <code class="highlight"><c- n="">optional</c-></code> a literal type, the same reasoning
can be applied to expected. Under some conditions, such that <code class="highlight"><c- n="">T</c-></code> and <code class="highlight"><c- n="">E</c-></code> are
trivially destructible, and the same described for <code class="highlight"><c- n="">optional</c-></code>, we propose that <code class="highlight"><c- n="">expected</c-></code> be a literal type.</p>
   <h3 class="heading settled" data-level="3.30" id="moved-from"><span class="secno">3.30. </span><span class="content">Moved from state</span><a class="self-link" href="#moved-from"></a></h3>
   <p>We follow the approach taken in <code class="highlight"><c- n="">optional</c-></code> <a data-link-type="biblio" href="#biblio-n3672">[N3672]</a>. Moving <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-></code> does
not modify the state of the source (valued or erroneous) of <code class="highlight"><c- n="">expected</c-></code> and the
move semantics is up to <code class="highlight"><c- n="">T</c-></code> or <code class="highlight"><c- n="">E</c-></code>.</p>
   <h3 class="heading settled" data-level="3.31" id="io"><span class="secno">3.31. </span><span class="content">I/O operations</span><a class="self-link" href="#io"></a></h3>
   <p>For the same reasons as <code class="highlight"><c- n="">optional</c-></code> <a data-link-type="biblio" href="#biblio-n3672">[N3672]</a> we do not add <code class="highlight"><c- k="">operator</c-><c- o="">&lt;&lt;</c-></code> and <code class="highlight"><c- k="">operator</c-><c- o="">&gt;&gt;</c-></code> I/O operations.</p>
   <h3 class="heading settled" data-level="3.32" id="status"><span class="secno">3.32. </span><span class="content">What happens when <code class="highlight"><c- n="">E</c-></code> is a status?</span><a class="self-link" href="#status"></a></h3>
   <p>When <code class="highlight"><c- n="">E</c-></code> is a status, as most of the error codes are, and has more than one
value that mean success, setting an <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-></code> with a successful <code class="highlight"><c- n="">e</c-></code> value
could be misleading if the user expect in this case to have also a <code class="highlight"><c- n="">T</c-></code>. In this
case the user should use the proposed <code class="highlight"><c- n="">status_value</c-><c- o="">&lt;</c-><c- n="">E</c-><c- p="">,</c-> <c- n="">T</c-><c- o="">&gt;</c-></code> class. However, if
there is only one value <code class="highlight"><c- n="">e</c-></code> that mean success, there is no such need and <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-></code> compose better with the monadic interface <a data-link-type="biblio" href="#biblio-p0650r0">[P0650R0]</a>.</p>
   <h3 class="heading settled" data-level="3.33" id="error_or"><span class="secno">3.33. </span><span class="content">Do we need an <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;::</c-><c- n="">error_or</c-></code> function?</span><a class="self-link" href="#error_or"></a></h3>
   <p>See <a data-link-type="biblio" href="#biblio-p0786r0">[P0786R0]</a>.</p>
   <p>Do we need to add such an <code class="highlight"><c- n="">error_or</c-></code> function? as member?</p>
   <p>This function should work for all the <em>ValueOrError</em> types and so could belong
to a future <em>ValueOrError</em> proposal.</p>
   <p>Not in this proposal.</p>
   <h3 class="heading settled" data-level="3.34" id="check_error"><span class="secno">3.34. </span><span class="content">Do we need a <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;::</c-><c- n="">check_error</c-></code> function?</span><a class="self-link" href="#check_error"></a></h3>
   <p>See <a data-link-type="biblio" href="#biblio-p0786r0">[P0786R0]</a>.</p>
   <p>Do we want to add such a <code class="highlight"><c- n="">check_error</c-></code> function? as member?</p>
   <p>This function should work for all the <em>ValueOrError</em> types and so could belong
to a future <em>ValueOrError</em> proposal.</p>
   <p>Not in this proposal.</p>
   <h3 class="heading settled" data-level="3.35" id="adapt_error"><span class="secno">3.35. </span><span class="content">Do we need a <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-><c- n="">G</c-><c- o="">&gt;::</c-><c- n="">adapt_error</c-><c- p="">(</c-><c- n="">function</c-><c- o="">&lt;</c-><c- n="">E</c-><c- p="">(</c-><c- n="">G</c-><c- p="">))</c-></code> function?</span><a class="self-link" href="#adapt_error"></a></h3>
   <p>We have the constructor <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-><c- p="">(</c-><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-><c- n="">G</c-><c- o="">&gt;</c-><c- p="">)</c-></code> that allows to transport
explicitly the contained error as soon as it is convertible.</p>
   <p>However sometimes we cannot change either of the error types and we could need
to do this transformation. This function help to achieve this goal. The
parameter is the function doing the error transformation.</p>
   <p>This function can be defined on top of the existing interface.</p>
<pre class="language-c++ highlight"><c- n="">template</c-> <c- o="">&lt;</c-><c- n="">class</c-> <c- n="">T</c-><c- p="">,</c-> <c- n="">class</c-> <c- n="">E</c-><c- o="">&gt;</c->
<c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-><c- n="">G</c-><c- o="">&gt;</c-> <c- n="">adapt_error</c-><c- p="">(</c-><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-> <c- k="">const</c-><c- o="">&amp;</c-> <c- n="">e</c-><c- p="">,</c-> <c- n="">function</c-><c- o="">&lt;</c-><c- n="">G</c-><c- p="">(</c-><c- n="">E</c-><c- p="">)</c-><c- o="">&gt;</c-> <c- n="">adaptor</c-><c- p="">)</c-> <c- p="">{</c->
    <c- k="">if</c-> <c- p="">(</c-> <c- o="">!</c-><c- n="">e</c-> <c- p="">)</c-> <c- k="">return</c-> <c- n="">adaptor</c-><c- p="">(</c-><c- n="">e</c-><c- p="">.</c-><c- n="">error</c-><c- p="">());</c->
    <c- k="">else</c-> <c- k="">return</c-> <c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-><c- n="">G</c-><c- o="">&gt;</c-><c- p="">(</c-><c- o="">*</c-><c- n="">e</c-><c- p="">);</c->
<c- p="">}</c->
</pre>
   <p>Do we want to add such a <code class="highlight"><c- n="">adapt_error</c-></code> function? as member?</p>
   <p>This function should work for all the <em>ValueOrError</em> types and so could belong
to a future <em>ValueOrError</em> proposal.</p>
   <p>Not in this proposal.</p>
   <h3 class="heading settled" data-level="3.36" id="🧟‍♂️"><span class="secno">3.36. </span><span class="content">Zombie name</span><a class="self-link" href="#🧟‍♂️"></a></h3>
   <p><code class="highlight"><c- n="">unexpected</c-></code> is a zombie name in C++20. It was deprecated in C++11, removed in
C++17. It used to be called by the C++ runtime when a dynamic exception
specification was violated.</p>
   <p>Re-using the <code class="highlight"><c- n="">unexpected</c-></code> zombie name is why we have zombie names in the first
place. This was discussed in the 2021-04-06 LEWG telecon, and it was pointed out
that <a href="https://codesearch.isocpp.org/cgi-bin/cgi_ppsearch?q=std%3A%3Aunexpected&amp;search=Search"><code class="highlight"><c- n="">unexpected</c-></code> isn’t used much in open source code besides standard library tests</a>. The
valid uses are in older code which is unlikely to update to C++23, and if it did
the breakage would not be silent because the <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">unexpected</c-><c- p="">()</c-></code> function call
wouldn’t be compatible with the <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">unexpected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- o="">&gt;</c-></code> type proposed in this
paper.</p>
   <h2 class="heading settled" data-level="4" id="word"><span class="secno">4. </span><span class="content">Wording</span><a class="self-link" href="#word"></a></h2>
   <h3 class="heading settled" data-level="4.1" id="macro"><span class="secno">4.1. </span><span class="content">Feature test macro</span><a class="self-link" href="#macro"></a></h3>
   <p>Add the following line to 17.3.2 [version.syn]:</p>
   <blockquote>
<pre class="highlight"><c- cp="">#define __cpp_lib_execution      201903L </c-><em><c- c1="">// also in</c-></em><c- c1=""> &lt;execution&gt;</c->
<ins><c- cp="">#define __cpp_lib_expected       20yymmL </c-><em><c- c1="">// also in</c-></em><c- c1=""> &lt;expected&gt;</c-></ins>
<c- cp="">#define __cpp_lib_filesystem     201703L </c-><em><c- c1="">// also in</c-></em><c- c1=""> &lt;filesystem&gt;</c->
</pre>
   </blockquote>
   <p>Below, substitute the <code class="highlight">�</code> character with a number or name the editor finds
appropriate for the sub-section.</p>
   <h3 class="heading settled" data-level="4.2" id="expected"><span class="secno">4.2. </span><span class="content">�.� Expected objects [<em>expected</em>]</span><a class="self-link" href="#expected"></a></h3>
   <h3 class="heading settled" data-level="4.3" id="expected.general"><span class="secno">4.3. </span><span class="content">�.�.1 In general [<em>expected.general</em>]</span><a class="self-link" href="#expected.general"></a></h3>
   <p>This subclause describes class template <code class="highlight"><c- n="">expected</c-></code> that represents expected
objects. An <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-></code> object holds an object of type <code class="highlight"><c- n="">T</c-></code> or an object of
type <code class="highlight"><c- n="">unexpected</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-></code> and manages the lifetime of the contained objects.</p>
   <h2 class="heading settled" data-level="5" id="expected.syn"><span class="secno">5. </span><span class="content">�.�.2 Header <code class="highlight"><c- o="">&lt;</c-><c- n="">expected</c-><c- o="">&gt;</c-></code> synopsis [<em>expected.syn</em>]</span><a class="self-link" href="#expected.syn"></a></h2>
<pre class="language-c++ highlight"><c- n="">namespace</c-> <c- n="">std</c-> <c- p="">{</c->
    <c- c1="">// �.�.3, class template unexpected</c->
    <c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">E</c-><c- o="">&gt;</c-> <c- n="">class</c-> <c- n="">unexpected</c-><c- p="">;</c->

    <c- c1="">// �.�.4, class bad_expected_access</c->
    <c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">E</c-><c- o="">&gt;</c-> <c- n="">class</c-> <c- n="">bad_expected_access</c-><c- p="">;</c->

    <c- c1="">// �.�.5, Specialization for void</c->
    <c- n="">template</c-><c- o="">&lt;&gt;</c-> <c- n="">class</c-> <c- n="">bad_expected_access</c-><c- o="">&lt;</c-><c- b="">void</c-><c- o="">&gt;</c-><c- p="">;</c->

    <c- c1="">// in-place construction of unexpected values</c->
    <c- k="">struct</c-> <c- nc="">unexpect_t</c-><c- p="">{</c->
      <c- n="">explicit</c-> <c- nf="">unexpect_t</c-><c- p="">()</c-> <c- o="">=</c-> <c- k="">default</c-><c- p="">;</c->
    <c- p="">};</c->
    <c- kr="">inline</c-> <c- n="">constexpr</c-> <c- n="">unexpect_t</c-> <c- n="">unexpect</c-><c- p="">{};</c->

    <c- c1="">// �.�.7, class template expected</c->
    <c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">T</c-><c- p="">,</c-> <c- n="">class</c-> <c- n="">E</c-><c- o="">&gt;</c-> <c- n="">class</c-> <c- n="">expected</c-><c- p="">;</c->

    <c- c1="">// �.�.8, class template expected&lt;cv void, E&gt;</c->
    <c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">T</c-><c- p="">,</c-> <c- n="">class</c-> <c- n="">E</c-><c- o="">&gt;</c-> <c- n="">requires</c-> <c- n="">is_void_v</c-><c- o="">&lt;</c-><c- n="">T</c-><c- o="">&gt;</c-> <c- n="">class</c-> <c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-><c- p="">;</c->
<c- p="">}</c->
</pre>
   <h3 class="heading settled" data-level="5.1" id="expected.un"><span class="secno">5.1. </span><span class="content">�.�.3 Unexpected objects [<em>expected.unexpected</em>]</span><a class="self-link" href="#expected.un"></a></h3>
   <h3 class="heading settled" data-level="5.2" id="expected.un.general"><span class="secno">5.2. </span><span class="content">�.�.3.1 General [<em>expected.un.general</em>]</span><a class="self-link" href="#expected.un.general"></a></h3>
   <p>This subclause describes class template <code class="highlight"><c- n="">unexpected</c-></code> that
represents unexpected objects stored in <code class="highlight"><c- n="">expected</c-></code> objects.</p>
   <h3 class="heading settled" data-level="5.3" id="expected.un.object"><span class="secno">5.3. </span><span class="content">�.�.3.2 Class template <code class="highlight"><c- n="">unexpected</c-></code> [<em>expected.un.object</em>]</span><a class="self-link" href="#expected.un.object"></a></h3>
<pre class="language-c++ highlight"><c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">E</c-><c- o="">&gt;</c->
<c- n="">class</c-> <c- n="">unexpected</c-> <c- p="">{</c->
<c- nl="">public</c-><c- p="">:</c->
    <c- n="">constexpr</c-> <c- n="">unexpected</c-><c- p="">(</c-><c- k="">const</c-> <c- n="">unexpected</c-><c- o="">&amp;</c-><c- p="">)</c-> <c- o="">=</c-> <c- k="">default</c-><c- p="">;</c->
    <c- n="">constexpr</c-> <c- nf="">unexpected</c-><c- p="">(</c-><c- n="">unexpected</c-><c- o="">&amp;&amp;</c-><c- p="">)</c-> <c- o="">=</c-> <c- k="">default</c-><c- p="">;</c->
    <c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-><c- p="">...</c-> <c- n="">Args</c-><c- o="">&gt;</c->
        <c- n="">constexpr</c-> <c- n="">explicit</c-> <c- n="">unexpected</c-><c- p="">(</c-><c- n="">in_place_t</c-><c- p="">,</c-> <c- n="">Args</c-><c- o="">&amp;&amp;</c-><c- p="">...);</c->
    <c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">U</c-><c- p="">,</c-> <c- n="">class</c-><c- p="">...</c-> <c- n="">Args</c-><c- o="">&gt;</c->
        <c- n="">constexpr</c-> <c- n="">explicit</c-> <c- n="">unexpected</c-><c- p="">(</c-><c- n="">in_place_t</c-><c- p="">,</c-> <c- n="">initializer_list</c-><c- o="">&lt;</c-><c- n="">U</c-><c- o="">&gt;</c-><c- p="">,</c-> <c- n="">Args</c-><c- o="">&amp;&amp;</c-><c- p="">...);</c->
    <c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">Err</c-> <c- o="">=</c-> <c- n="">E</c-><c- o="">&gt;</c->
        <c- n="">constexpr</c-> <c- n="">explicit</c-> <c- n="">unexpected</c-><c- p="">(</c-><c- n="">Err</c-><c- o="">&amp;&amp;</c-><c- p="">);</c->

    <c- n="">constexpr</c-> <c- n="">unexpected</c-><c- o="">&amp;</c-> <c- n="">operator</c-><c- o="">=</c-><c- p="">(</c-><c- k="">const</c-> <c- n="">unexpected</c-><c- o="">&amp;</c-><c- p="">)</c-> <c- o="">=</c-> <c- k="">default</c-><c- p="">;</c->
    <c- n="">constexpr</c-> <c- n="">unexpected</c-><c- o="">&amp;</c-> <c- n="">operator</c-><c- o="">=</c-><c- p="">(</c-><c- n="">unexpected</c-><c- o="">&amp;&amp;</c-><c- p="">)</c-> <c- o="">=</c-> <c- k="">default</c-><c- p="">;</c->

    <c- n="">constexpr</c-> <c- k="">const</c-> <c- n="">E</c-><c- o="">&amp;</c-> <c- n="">value</c-><c- p="">()</c-> <c- k="">const</c-><c- o="">&amp;</c-> <c- n="">noexcept</c-><c- p="">;</c->
    <c- n="">constexpr</c-> <c- n="">E</c-><c- o="">&amp;</c-> <c- n="">value</c-><c- p="">()</c-> <c- o="">&amp;</c-> <c- n="">noexcept</c-><c- p="">;</c->
    <c- n="">constexpr</c-> <c- k="">const</c-> <c- n="">E</c-><c- o="">&amp;&amp;</c-> <c- n="">value</c-><c- p="">()</c-> <c- k="">const</c-><c- o="">&amp;&amp;</c-> <c- n="">noexcept</c-><c- p="">;</c->
    <c- n="">constexpr</c-> <c- n="">E</c-><c- o="">&amp;&amp;</c-> <c- n="">value</c-><c- p="">()</c-> <c- o="">&amp;&amp;</c-> <c- n="">noexcept</c-><c- p="">;</c->

    <c- n="">constexpr</c-> <c- b="">void</c-> <c- n="">swap</c-><c- p="">(</c-><c- n="">unexpected</c-><c- o="">&amp;</c-> <c- n="">other</c-><c- p="">)</c-> <c- n="">noexcept</c-><c- p="">(</c-><c- n="">see</c-> <c- n="">below</c-><c- p="">);</c->

    <c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">E2</c-><c- o="">&gt;</c->
        <c- n="">friend</c-> <c- n="">constexpr</c-> <c- b="">bool</c->
        <c- n="">operator</c-><c- o="">==</c-><c- p="">(</c-><c- k="">const</c-> <c- n="">unexpected</c-><c- o="">&amp;</c-><c- p="">,</c-> <c- k="">const</c-> <c- n="">unexpected</c-><c- o="">&lt;</c-><c- n="">E2</c-><c- o="">&gt;&amp;</c-><c- p="">);</c->

    <c- n="">friend</c-> <c- n="">constexpr</c-> <c- b="">void</c-> <c- n="">swap</c-><c- p="">(</c-><c- n="">unexpected</c-><c- o="">&amp;</c-> <c- n="">x</c-><c- p="">,</c-> <c- n="">unexpected</c-><c- o="">&amp;</c-> <c- n="">y</c-><c- p="">)</c-> <c- n="">noexcept</c-><c- p="">(</c-><c- n="">noexcept</c-><c- p="">(</c-><c- n="">x</c-><c- p="">.</c-><c- n="">swap</c-><c- p="">(</c-><c- n="">y</c-><c- p="">)));</c->

<c- nl="">private</c-><c- p="">:</c->
    <c- n="">E</c-> <c- n="">val</c-><c- p="">;</c-> <c- c1="">// exposition only</c->
<c- p="">};</c->

<c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">E</c-><c- o="">&gt;</c-> <c- n="">unexpected</c-><c- p="">(</c-><c- n="">E</c-><c- p="">)</c-> <c- o="">-&gt;</c-> <c- n="">unexpected</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-><c- p="">;</c->
</pre>
   <p>A program that instantiates the definition of <code class="highlight"><c- n="">unexpected</c-></code> for a non-object
type, an array type, a specialization of <code class="highlight"><c- n="">unexpected</c-></code> or a cv-qualified type is
ill-formed.</p>
   <h4 class="heading settled" data-level="5.3.1" id="expected.un.ctor"><span class="secno">5.3.1. </span><span class="content">�.�.3.2.1 Constructors [<em>expected.un.ctor</em>]</span><a class="self-link" href="#expected.un.ctor"></a></h4>
<pre class="language-c++ highlight"><c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">Err</c-> <c- o="">=</c-> <c- n="">E</c-><c- o="">&gt;</c->
    <c- n="">constexpr</c-> <c- n="">explicit</c-> <c- n="">unexpected</c-><c- p="">(</c-><c- n="">Err</c-><c- o="">&amp;&amp;</c-> <c- n="">e</c-><c- p="">);</c->
</pre>
   <p><em>Constraints</em>:</p>
   <ul>
    <li data-md="">
     <p><code class="highlight"><c- n="">is_same_v</c-><c- o="">&lt;</c-><c- n="">remove_cvref_t</c-><c- o="">&lt;</c-><c- n="">Err</c-><c- o="">&gt;</c-><c- p="">,</c-> <c- n="">unexpected</c-><c- o="">&gt;</c-></code> is <code class="highlight">false</code>; and</p>
    </li><li data-md="">
     <p><code class="highlight"><c- n="">is_same_v</c-><c- o="">&lt;</c-><c- n="">remove_cvref_t</c-><c- o="">&lt;</c-><c- n="">Err</c-><c- o="">&gt;</c-><c- p="">,</c-> <c- n="">in_place_t</c-><c- o="">&gt;</c-></code> is <code class="highlight">false</code>; and</p>
    </li><li data-md="">
     <p><code class="highlight"><c- n="">is_constructible_v</c-><c- o="">&lt;</c-><c- n="">E</c-><c- p="">,</c-> <c- n="">Err</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code>.</p>
   </li></ul>
   <p><em>Effects</em>: Direct-non-list-initializes <code class="highlight"><c- n="">val</c-></code> with <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">forward</c-><c- o="">&lt;</c-><c- n="">Err</c-><c- o="">&gt;</c-><c- p="">(</c-><c- n="">e</c-><c- p="">)</c-></code>.</p>
   <p><em>Throws</em>: Any exception thrown by the initialization of <code class="highlight"><c- n="">val</c-></code>.</p>
<pre class="language-c++ highlight"><c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-><c- p="">...</c-> <c- n="">Args</c-><c- o="">&gt;</c->
    <c- n="">constexpr</c-> <c- n="">explicit</c-> <c- n="">unexpected</c-><c- p="">(</c-><c- n="">in_place_t</c-><c- p="">,</c-> <c- n="">Args</c-><c- o="">&amp;&amp;</c-><c- p="">...);</c->
</pre>
   <p><em>Constraints</em>: <code class="highlight"><c- n="">is_constructible_v</c-><c- o="">&lt;</c-><c- n="">E</c-><c- p="">,</c-> <c- n="">Args</c-><c- p="">...</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code>.</p>
   <p><em>Effects</em>: Direct-non-list-initializes <code class="highlight"><c- n="">val</c-></code> with <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">forward</c-><c- o="">&lt;</c-><c- n="">Args</c-><c- o="">&gt;</c-><c- p="">(</c-><c- n="">args</c-><c- p="">)...</c-></code>.</p>
   <p><em>Throws</em>: Any exception thrown by the initialization of <code class="highlight"><c- n="">val</c-></code>.</p>
<pre class="language-c++ highlight"><c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">U</c-><c- p="">,</c-> <c- n="">class</c-><c- p="">...</c-> <c- n="">Args</c-><c- o="">&gt;</c->
    <c- n="">constexpr</c-> <c- n="">explicit</c-> <c- n="">unexpected</c-><c- p="">(</c-><c- n="">in_place_t</c-><c- p="">,</c-> <c- n="">initializer_list</c-><c- o="">&lt;</c-><c- n="">U</c-><c- o="">&gt;</c-><c- p="">,</c-> <c- n="">Args</c-><c- o="">&amp;&amp;</c-><c- p="">...);</c->
</pre>
   <p><em>Constraints</em>: <code class="highlight"><c- n="">is_constructible_v</c-><c- o="">&lt;</c-><c- n="">E</c-><c- p="">,</c-> <c- n="">initializer_list</c-><c- o="">&lt;</c-><c- n="">U</c-><c- o="">&gt;&amp;</c-><c- p="">,</c-> <c- n="">Args</c-><c- p="">...</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code>.</p>
   <p><em>Effects</em>: Direct-non-list-initializes <code class="highlight"><c- n="">val</c-></code> with <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">forward</c-><c- o="">&lt;</c-><c- n="">Args</c-><c- o="">&gt;</c-><c- p="">(</c-><c- n="">args</c-><c- p="">)...</c-></code>.</p>
   <p><em>Throws</em>: Any exception thrown by the initialization of <code class="highlight"><c- n="">val</c-></code>.</p>
   <h4 class="heading settled" data-level="5.3.2" id="expected.un.observe"><span class="secno">5.3.2. </span><span class="content">�.�.3.2.3 Observers [<em>expected.un.observe</em>]</span><a class="self-link" href="#expected.un.observe"></a></h4>
<pre class="language-c++ highlight"><c- n="">constexpr</c-> <c- k="">const</c-> <c- n="">E</c-><c- o="">&amp;</c-> <c- n="">value</c-><c- p="">()</c-> <c- k="">const</c-><c- o="">&amp;</c-> <c- n="">noexcept</c-><c- p="">;</c->
<c- n="">constexpr</c-> <c- n="">E</c-><c- o="">&amp;</c-> <c- n="">value</c-><c- p="">()</c-> <c- o="">&amp;</c-> <c- n="">noexcept</c-><c- p="">;</c->
</pre>
   <p><em>Returns</em>: <code class="highlight"><c- n="">val</c-></code>.</p>
<pre class="language-c++ highlight"><c- n="">constexpr</c-> <c- n="">E</c-><c- o="">&amp;&amp;</c-> <c- n="">value</c-><c- p="">()</c-> <c- o="">&amp;&amp;</c-> <c- n="">noexcept</c-><c- p="">;</c->
<c- n="">constexpr</c-> <c- k="">const</c-> <c- n="">E</c-><c- o="">&amp;&amp;</c-> <c- n="">value</c-><c- p="">()</c-> <c- k="">const</c-><c- o="">&amp;&amp;</c-> <c- n="">noexcept</c-><c- p="">;</c->
</pre>
   <p><em>Returns</em>: <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">move</c-><c- p="">(</c-><c- n="">val</c-><c- p="">)</c-></code>.</p>
   <h4 class="heading settled" data-level="5.3.3" id="expected.un.swap"><span class="secno">5.3.3. </span><span class="content">�.�.3.2.4 Swap [<em>expected.un.swap</em>]</span><a class="self-link" href="#expected.un.swap"></a></h4>
<pre class="language-c++ highlight"><c- n="">constexpr</c-> <c- b="">void</c-> <c- n="">swap</c-><c- p="">(</c-><c- n="">unexpected</c-><c- o="">&amp;</c-> <c- n="">other</c-><c- p="">)</c-> <c- n="">noexcept</c-><c- p="">(</c-><c- n="">is_nothrow_swappable_v</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-><c- p="">);</c->
</pre>
   <p><em>Mandates</em>: <code class="highlight"><c- n="">is_swappable_v</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code>.</p>
   <p><em>Effects</em>: Equivalent to <code class="highlight"><c- k="">using</c-> <c- n="">std</c-><c- o="">::</c-><c- n="">swap</c-><c- p="">;</c-> <c- n="">swap</c-><c- p="">(</c-><c- n="">val</c-><c- p="">,</c-> <c- n="">other</c-><c- p="">.</c-><c- n="">val</c-><c- p="">);</c-></code>.</p>
<pre class="language-c++ highlight"><c- n="">friend</c-> <c- n="">constexpr</c-> <c- b="">void</c-> <c- n="">swap</c-><c- p="">(</c-><c- n="">unexpected</c-><c- o="">&amp;</c-> <c- n="">x</c-><c- p="">,</c-> <c- n="">unexpected</c-><c- o="">&amp;</c-> <c- n="">y</c-><c- p="">)</c-> <c- n="">noexcept</c-><c- p="">(</c-><c- n="">noexcept</c-><c- p="">(</c-><c- n="">x</c-><c- p="">.</c-><c- n="">swap</c-><c- p="">(</c-><c- n="">y</c-><c- p="">)));</c->
</pre>
   <p><em>Constraints</em>: <code class="highlight"><c- n="">is_swappable_v</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code>.</p>
   <p><em>Effects</em>: Equivalent to <code class="highlight"><c- n="">x</c-><c- p="">.</c-><c- n="">swap</c-><c- p="">(</c-><c- n="">y</c-><c- p="">)</c-></code>.</p>
   <h3 class="heading settled" data-level="5.4" id="expected.un.eq"><span class="secno">5.4. </span><span class="content">�.�.3.2.5 Equality operators [<em>expected.un.eq</em>]</span><a class="self-link" href="#expected.un.eq"></a></h3>
<pre class="language-c++ highlight"><c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">E2</c-><c- o="">&gt;</c->
    <c- n="">friend</c-> <c- n="">constexpr</c-> <c- b="">bool</c-> <c- n="">operator</c-><c- o="">==</c-><c- p="">(</c-><c- k="">const</c-> <c- n="">unexpected</c-><c- o="">&amp;</c-> <c- n="">x</c-><c- p="">,</c-> <c- k="">const</c-> <c- n="">unexpected</c-><c- o="">&lt;</c-><c- n="">E2</c-><c- o="">&gt;&amp;</c-> <c- n="">y</c-><c- p="">);</c->
</pre>
   <p><em>Mandates</em>: The expression <code class="highlight"><c- n="">x</c-><c- p="">.</c-><c- n="">value</c-><c- p="">()</c-><c- o="">==</c-> <c- n="">y</c-><c- p="">.</c-><c- n="">value</c-><c- p="">()</c-></code> is well-formed and its result
is convertible to <code class="highlight"><c- b="">bool</c-></code>.</p>
   <p><em>Returns</em>: <code class="highlight"><c- n="">x</c-><c- p="">.</c-><c- n="">value</c-><c- p="">()</c-> <c- o="">==</c-> <c- n="">y</c-><c- p="">.</c-><c- n="">value</c-><c- p="">()</c-></code>.</p>
   <h3 class="heading settled" data-level="5.5" id="expected.bad"><span class="secno">5.5. </span><span class="content">�.�.4 Class template <code class="highlight"><c- n="">bad_expected_access</c-></code> [<em>expected.bad</em>]</span><a class="self-link" href="#expected.bad"></a></h3>
<pre class="language-c++ highlight"><c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">E</c-><c- o="">&gt;</c->
<c- n="">class</c-> <c- nl="">bad_expected_access</c-> <c- p="">:</c-> <c- n="">public</c-> <c- n="">bad_expected_access</c-><c- o="">&lt;</c-><c- b="">void</c-><c- o="">&gt;</c-> <c- p="">{</c->
<c- nl="">public</c-><c- p="">:</c->
    <c- n="">explicit</c-> <c- n="">bad_expected_access</c-><c- p="">(</c-><c- n="">E</c-><c- p="">);</c->
    <c- k="">const</c-> <c- b="">char</c-><c- o="">*</c-> <c- n="">what</c-><c- p="">()</c-> <c- k="">const</c-> <c- n="">noexcept</c-> <c- n="">override</c-><c- p="">;</c->
    <c- n="">E</c-><c- o="">&amp;</c-> <c- nf="">error</c-><c- p="">()</c-> <c- o="">&amp;</c-> <c- n="">noexcept</c-><c- p="">;</c->
    <c- k="">const</c-> <c- n="">E</c-><c- o="">&amp;</c-> <c- n="">error</c-><c- p="">()</c-> <c- k="">const</c-><c- o="">&amp;</c-> <c- n="">noexcept</c-><c- p="">;</c->
    <c- n="">E</c-><c- o="">&amp;&amp;</c-> <c- nf="">error</c-><c- p="">()</c-> <c- o="">&amp;&amp;</c-> <c- n="">noexcept</c-><c- p="">;</c->
    <c- k="">const</c-> <c- n="">E</c-><c- o="">&amp;&amp;</c->  <c- n="">error</c-><c- p="">()</c-> <c- k="">const</c-><c- o="">&amp;&amp;</c-> <c- n="">noexcept</c-><c- p="">;</c->
<c- nl="">private</c-><c- p="">:</c->
    <c- n="">E</c-> <c- n="">val</c-><c- p="">;</c-> <c- c1="">// exposition only</c->
<c- p="">};</c->
</pre>
   <p>The template class <code class="highlight"><c- n="">bad_expected_access</c-></code> defines the type of objects thrown as
exceptions to report the situation where an attempt is made to access the value
of <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-></code> object for which <code class="highlight"><c- n="">has_value</c-><c- p="">()</c-></code> is <code class="highlight">false</code>.</p>
<pre class="language-c++ highlight"><c- n="">explicit</c-> <c- nf="">bad_expected_access</c-><c- p="">(</c-><c- n="">E</c-> <c- n="">e</c-><c- p="">);</c->
</pre>
   <p><em>Effects</em>: Initializes <code class="highlight"><c- n="">val</c-></code> with <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">move</c-><c- p="">(</c-><c- n="">e</c-><c- p="">)</c-></code>.</p>
<pre class="language-c++ highlight"><c- k="">const</c-> <c- n="">E</c-><c- o="">&amp;</c-> <c- n="">error</c-><c- p="">()</c-> <c- k="">const</c-><c- o="">&amp;</c-> <c- n="">noexcept</c-><c- p="">;</c->
<c- n="">E</c-><c- o="">&amp;</c-> <c- nf="">error</c-><c- p="">()</c-> <c- o="">&amp;</c-> <c- n="">noexcept</c-><c- p="">;</c->
</pre>
   <p><em>Returns</em>: <code class="highlight"><c- n="">val</c-></code>.</p>
<pre class="language-c++ highlight"><c- n="">E</c-><c- o="">&amp;&amp;</c-> <c- nf="">error</c-><c- p="">()</c-> <c- o="">&amp;&amp;</c-> <c- n="">noexcept</c-><c- p="">;</c->
<c- k="">const</c-> <c- n="">E</c-><c- o="">&amp;&amp;</c-> <c- n="">error</c-><c- p="">()</c-> <c- k="">const</c-><c- o="">&amp;&amp;</c-> <c- n="">noexcept</c-><c- p="">;</c->
</pre>
   <p><em>Returns</em>: <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">move</c-><c- p="">(</c-><c- n="">val</c-><c- p="">)</c-></code>.</p>
<pre class="language-c++ highlight"><c- k="">const</c-> <c- b="">char</c-><c- o="">*</c-> <c- n="">what</c-><c- p="">()</c-> <c- k="">const</c-> <c- n="">noexcept</c-> <c- n="">override</c-><c- p="">;</c->
</pre>
   <p><em>Returns</em>: An implementation-defined NTBS.</p>
   <h3 class="heading settled" data-level="5.6" id="expected.bad.void"><span class="secno">5.6. </span><span class="content">�.�.5 Class template specialization <code class="highlight"><c- n="">bad_expected_access</c-><c- o="">&lt;</c-><c- b="">void</c-><c- o="">&gt;</c-></code> [<em>expected.bad.void</em>]</span><a class="self-link" href="#expected.bad.void"></a></h3>
<pre class="language-c++ highlight"><c- n="">template</c-><c- o="">&lt;&gt;</c->
<c- n="">class</c-> <c- n="">bad_expected_access</c-><c- o="">&lt;</c-><c- b="">void</c-><c- o="">&gt;</c-> <c- o="">:</c-> <c- n="">public</c-> <c- n="">exception</c-> <c- p="">{</c->
<c- nl="">protected</c-><c- p="">:</c->
    <c- n="">bad_expected_access</c-><c- p="">()</c-> <c- n="">noexcept</c-><c- p="">;</c->
    <c- n="">bad_expected_access</c-><c- p="">(</c-><c- k="">const</c-> <c- n="">bad_expected_access</c-><c- o="">&amp;</c-><c- p="">);</c->
    <c- n="">bad_expected_access</c-><c- p="">(</c-><c- n="">bad_expected_access</c-><c- o="">&amp;&amp;</c-><c- p="">);</c->
    <c- n="">bad_expected_access</c-><c- o="">&amp;</c-> <c- n="">operator</c-><c- o="">=</c-><c- p="">(</c-><c- k="">const</c-> <c- n="">bad_expected_access</c-><c- o="">&amp;</c-><c- p="">);</c->
    <c- n="">bad_expected_access</c-><c- o="">&amp;</c-> <c- n="">operator</c-><c- o="">=</c-><c- p="">(</c-><c- n="">bad_expected_access</c-><c- o="">&amp;&amp;</c-><c- p="">);</c->
    <c- o="">~</c-><c- n="">bad_expected_access</c-><c- p="">();</c->

<c- nl="">public</c-><c- p="">:</c->
    <c- k="">const</c-> <c- b="">char</c-><c- o="">*</c-> <c- n="">what</c-><c- p="">()</c-> <c- k="">const</c-> <c- n="">noexcept</c-> <c- n="">override</c-><c- p="">;</c->
<c- p="">};</c->
</pre>
<pre class="language-c++ highlight"><c- k="">const</c-> <c- b="">char</c-><c- o="">*</c-> <c- n="">what</c-><c- p="">()</c-> <c- k="">const</c-> <c- n="">noexcept</c-> <c- n="">override</c-><c- p="">;</c->
</pre>
   <p><em>Returns</em>: An implementation-defined NTBS.</p>
   <h3 class="heading settled" data-level="5.7" id="expected.expected"><span class="secno">5.7. </span><span class="content">�.�.7 Class template expected [<em>expected.expected</em>]</span><a class="self-link" href="#expected.expected"></a></h3>
<pre class="language-c++ highlight"><c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">T</c-><c- p="">,</c-> <c- n="">class</c-> <c- n="">E</c-><c- o="">&gt;</c->
<c- n="">class</c-> <c- n="">expected</c-> <c- p="">{</c->
<c- nl="">public</c-><c- p="">:</c->
    <c- n="">using</c-> <c- n="">value_type</c-> <c- o="">=</c-> <c- n="">T</c-><c- p="">;</c->
    <c- n="">using</c-> <c- n="">error_type</c-> <c- o="">=</c-> <c- n="">E</c-><c- p="">;</c->
    <c- n="">using</c-> <c- n="">unexpected_type</c-> <c- o="">=</c-> <c- n="">unexpected</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-><c- p="">;</c->

    <c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">U</c-><c- o="">&gt;</c->
    <c- n="">using</c-> <c- n="">rebind</c-> <c- o="">=</c-> <c- n="">expected</c-><c- o="">&lt;</c-><c- n="">U</c-><c- p="">,</c-> <c- n="">error_type</c-><c- o="">&gt;</c-><c- p="">;</c->

    <c- c1="">// �.�.7.1, constructors</c->
    <c- n="">constexpr</c-> <c- nf="">expected</c-><c- p="">();</c->
    <c- n="">constexpr</c-> <c- nf="">explicit</c-><c- p="">(</c-><c- n="">see</c-> <c- n="">below</c-><c- p="">)</c-> <c- n="">expected</c-><c- p="">(</c-><c- k="">const</c-> <c- n="">expected</c-><c- o="">&amp;</c-><c- p="">);</c->
    <c- n="">constexpr</c-> <c- nf="">explicit</c-><c- p="">(</c-><c- n="">see</c-> <c- n="">below</c-><c- p="">)</c-> <c- n="">expected</c-><c- p="">(</c-><c- n="">expected</c-><c- o="">&amp;&amp;</c-><c- p="">)</c-> <c- n="">noexcept</c-><c- p="">(</c-><c- n="">see</c-> <c- n="">below</c-><c- p="">);</c->
    <c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">U</c-><c- p="">,</c-> <c- n="">class</c-> <c- n="">G</c-><c- o="">&gt;</c->
        <c- n="">constexpr</c-> <c- n="">explicit</c-><c- p="">(</c-><c- n="">see</c-> <c- n="">below</c-><c- p="">)</c-> <c- n="">expected</c-><c- p="">(</c-><c- k="">const</c-> <c- n="">expected</c-><c- o="">&lt;</c-><c- n="">U</c-><c- p="">,</c-> <c- n="">G</c-><c- o="">&gt;&amp;</c-><c- p="">);</c->
    <c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">U</c-><c- p="">,</c-> <c- n="">class</c-> <c- n="">G</c-><c- o="">&gt;</c->
        <c- n="">constexpr</c-> <c- n="">explicit</c-><c- p="">(</c-><c- n="">see</c-> <c- n="">below</c-><c- p="">)</c-> <c- n="">expected</c-><c- p="">(</c-><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">U</c-><c- p="">,</c-> <c- n="">G</c-><c- o="">&gt;&amp;&amp;</c-><c- p="">);</c->

    <c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">U</c-> <c- o="">=</c-> <c- n="">T</c-><c- o="">&gt;</c->
        <c- n="">constexpr</c-> <c- n="">explicit</c-><c- p="">(</c-><c- n="">see</c-> <c- n="">below</c-><c- p="">)</c-> <c- n="">expected</c-><c- p="">(</c-><c- n="">U</c-><c- o="">&amp;&amp;</c-> <c- n="">v</c-><c- p="">);</c->

    <c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">G</c-><c- o="">&gt;</c->
        <c- n="">constexpr</c-> <c- n="">expected</c-><c- p="">(</c-><c- k="">const</c-> <c- n="">unexpected</c-><c- o="">&lt;</c-><c- n="">G</c-><c- o="">&gt;&amp;</c-><c- p="">);</c->
    <c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">G</c-><c- o="">&gt;</c->
        <c- n="">constexpr</c-> <c- n="">expected</c-><c- p="">(</c-><c- n="">unexpected</c-><c- o="">&lt;</c-><c- n="">G</c-><c- o="">&gt;&amp;&amp;</c-><c- p="">);</c->

    <c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-><c- p="">...</c-> <c- n="">Args</c-><c- o="">&gt;</c->
        <c- n="">constexpr</c-> <c- n="">explicit</c-> <c- n="">expected</c-><c- p="">(</c-><c- n="">in_place_t</c-><c- p="">,</c-> <c- n="">Args</c-><c- o="">&amp;&amp;</c-><c- p="">...);</c->
    <c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">U</c-><c- p="">,</c-> <c- n="">class</c-><c- p="">...</c-> <c- n="">Args</c-><c- o="">&gt;</c->
        <c- n="">constexpr</c-> <c- n="">explicit</c-> <c- n="">expected</c-><c- p="">(</c-><c- n="">in_place_t</c-><c- p="">,</c-> <c- n="">initializer_list</c-><c- o="">&lt;</c-><c- n="">U</c-><c- o="">&gt;</c-><c- p="">,</c-> <c- n="">Args</c-><c- o="">&amp;&amp;</c-><c- p="">...);</c->
    <c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-><c- p="">...</c-> <c- n="">Args</c-><c- o="">&gt;</c->
        <c- n="">constexpr</c-> <c- n="">explicit</c-> <c- n="">expected</c-><c- p="">(</c-><c- n="">unexpect_t</c-><c- p="">,</c-> <c- n="">Args</c-><c- o="">&amp;&amp;</c-><c- p="">...);</c->
    <c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">U</c-><c- p="">,</c-> <c- n="">class</c-><c- p="">...</c-> <c- n="">Args</c-><c- o="">&gt;</c->
        <c- n="">constexpr</c-> <c- n="">explicit</c-> <c- n="">expected</c-><c- p="">(</c-><c- n="">unexpect_t</c-><c- p="">,</c-> <c- n="">initializer_list</c-><c- o="">&lt;</c-><c- n="">U</c-><c- o="">&gt;</c-><c- p="">,</c-> <c- n="">Args</c-><c- o="">&amp;&amp;</c-><c- p="">...);</c->


    <c- c1="">// �.�.7.2, destructor</c->
    <c- n="">constexpr</c-> <c- o="">~</c-><c- n="">expected</c-><c- p="">();</c->

    <c- c1="">// �.�.7.3, assignment</c->
    <c- n="">constexpr</c-> <c- n="">expected</c-><c- o="">&amp;</c-> <c- n="">operator</c-><c- o="">=</c-><c- p="">(</c-><c- k="">const</c-> <c- n="">expected</c-><c- o="">&amp;</c-><c- p="">);</c->
    <c- n="">constexpr</c-> <c- n="">expected</c-><c- o="">&amp;</c-> <c- n="">operator</c-><c- o="">=</c-><c- p="">(</c-><c- n="">expected</c-><c- o="">&amp;&amp;</c-><c- p="">)</c-> <c- n="">noexcept</c-><c- p="">(</c-><c- n="">see</c-> <c- n="">below</c-><c- p="">);</c->
    <c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">U</c-> <c- o="">=</c-> <c- n="">T</c-><c- o="">&gt;</c-> <c- n="">constexpr</c-> <c- n="">expected</c-><c- o="">&amp;</c-> <c- n="">operator</c-><c- o="">=</c-><c- p="">(</c-><c- n="">U</c-><c- o="">&amp;&amp;</c-><c- p="">);</c->
    <c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">G</c-><c- o="">&gt;</c->
        <c- n="">constexpr</c-> <c- n="">expected</c-><c- o="">&amp;</c-> <c- n="">operator</c-><c- o="">=</c-><c- p="">(</c-><c- k="">const</c-> <c- n="">unexpected</c-><c- o="">&lt;</c-><c- n="">G</c-><c- o="">&gt;&amp;</c-><c- p="">);</c->
    <c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">G</c-><c- o="">&gt;</c->
        <c- n="">constexpr</c-> <c- n="">expected</c-><c- o="">&amp;</c-> <c- n="">operator</c-><c- o="">=</c-><c- p="">(</c-><c- n="">unexpected</c-><c- o="">&lt;</c-><c- n="">G</c-><c- o="">&gt;&amp;&amp;</c-><c- p="">);</c->

    <c- c1="">// �.�.7.4, modifiers</c->

    <c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-><c- p="">...</c-> <c- n="">Args</c-><c- o="">&gt;</c->
        <c- n="">constexpr</c-> <c- n="">T</c-><c- o="">&amp;</c-> <c- n="">emplace</c-><c- p="">(</c-><c- n="">Args</c-><c- o="">&amp;&amp;</c-><c- p="">...)</c-> <c- n="">noexcept</c-><c- p="">;</c->
    <c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">U</c-><c- p="">,</c-> <c- n="">class</c-><c- p="">...</c-> <c- n="">Args</c-><c- o="">&gt;</c->
        <c- n="">constexpr</c-> <c- n="">T</c-><c- o="">&amp;</c-> <c- n="">emplace</c-><c- p="">(</c-><c- n="">initializer_list</c-><c- o="">&lt;</c-><c- n="">U</c-><c- o="">&gt;</c-><c- p="">,</c-> <c- n="">Args</c-><c- o="">&amp;&amp;</c-><c- p="">...)</c-> <c- n="">noexcept</c-><c- p="">;</c->

    <c- c1="">// �.�.7.5, swap</c->
    <c- n="">constexpr</c-> <c- b="">void</c-> <c- n="">swap</c-><c- p="">(</c-><c- n="">expected</c-><c- o="">&amp;</c-><c- p="">)</c-> <c- n="">noexcept</c-><c- p="">(</c-><c- n="">see</c-> <c- n="">below</c-><c- p="">);</c->

    <c- c1="">// �.�.7.6, observers</c->
    <c- n="">constexpr</c-> <c- k="">const</c-> <c- n="">T</c-><c- o="">*</c-> <c- n="">operator</c-><c- o="">-&gt;</c-><c- p="">()</c-> <c- k="">const</c-> <c- n="">noexcept</c-><c- p="">;</c->
    <c- n="">constexpr</c-> <c- n="">T</c-><c- o="">*</c-> <c- n="">operator</c-><c- o="">-&gt;</c-><c- p="">()</c-> <c- n="">noexcept</c-><c- p="">;</c->
    <c- n="">constexpr</c-> <c- k="">const</c-> <c- n="">T</c-><c- o="">&amp;</c-> <c- n="">operator</c-><c- o="">*</c-><c- p="">()</c-> <c- k="">const</c-><c- o="">&amp;</c-> <c- n="">noexcept</c-><c- p="">;</c->
    <c- n="">constexpr</c-> <c- n="">T</c-><c- o="">&amp;</c-> <c- n="">operator</c-><c- o="">*</c-><c- p="">()</c-> <c- o="">&amp;</c-> <c- n="">noexcept</c-><c- p="">;</c->
    <c- n="">constexpr</c-> <c- k="">const</c-> <c- n="">T</c-><c- o="">&amp;&amp;</c-> <c- n="">operator</c-><c- o="">*</c-><c- p="">()</c-> <c- k="">const</c-><c- o="">&amp;&amp;</c-> <c- n="">noexcept</c-><c- p="">;</c->
    <c- n="">constexpr</c-> <c- n="">T</c-><c- o="">&amp;&amp;</c-> <c- n="">operator</c-><c- o="">*</c-><c- p="">()</c-> <c- o="">&amp;&amp;</c-> <c- n="">noexcept</c-><c- p="">;</c->
    <c- n="">constexpr</c-> <c- n="">explicit</c-> <c- n="">operator</c-> <c- b="">bool</c-><c- p="">()</c-> <c- k="">const</c-> <c- n="">noexcept</c-><c- p="">;</c->
    <c- n="">constexpr</c-> <c- b="">bool</c-> <c- n="">has_value</c-><c- p="">()</c-> <c- k="">const</c-> <c- n="">noexcept</c-><c- p="">;</c->
    <c- n="">constexpr</c-> <c- k="">const</c-> <c- n="">T</c-><c- o="">&amp;</c-> <c- n="">value</c-><c- p="">()</c-> <c- k="">const</c-><c- o="">&amp;</c-><c- p="">;</c->
    <c- n="">constexpr</c-> <c- n="">T</c-><c- o="">&amp;</c-> <c- n="">value</c-><c- p="">()</c-> <c- o="">&amp;</c-><c- p="">;</c->
    <c- n="">constexpr</c-> <c- k="">const</c-> <c- n="">T</c-><c- o="">&amp;&amp;</c-> <c- n="">value</c-><c- p="">()</c-> <c- k="">const</c-><c- o="">&amp;&amp;</c-><c- p="">;</c->
    <c- n="">constexpr</c-> <c- n="">T</c-><c- o="">&amp;&amp;</c-> <c- n="">value</c-><c- p="">()</c-> <c- o="">&amp;&amp;</c-><c- p="">;</c->
    <c- n="">constexpr</c-> <c- k="">const</c-> <c- n="">E</c-><c- o="">&amp;</c-> <c- n="">error</c-><c- p="">()</c-> <c- k="">const</c-><c- o="">&amp;</c-><c- p="">;</c->
    <c- n="">constexpr</c-> <c- n="">E</c-><c- o="">&amp;</c-> <c- n="">error</c-><c- p="">()</c-> <c- o="">&amp;</c-><c- p="">;</c->
    <c- n="">constexpr</c-> <c- k="">const</c-> <c- n="">E</c-><c- o="">&amp;&amp;</c-> <c- n="">error</c-><c- p="">()</c-> <c- k="">const</c-><c- o="">&amp;&amp;</c-><c- p="">;</c->
    <c- n="">constexpr</c-> <c- n="">E</c-><c- o="">&amp;&amp;</c-> <c- n="">error</c-><c- p="">()</c-> <c- o="">&amp;&amp;</c-><c- p="">;</c->
    <c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">U</c-><c- o="">&gt;</c->
        <c- n="">constexpr</c-> <c- n="">T</c-> <c- n="">value_or</c-><c- p="">(</c-><c- n="">U</c-><c- o="">&amp;&amp;</c-><c- p="">)</c-> <c- k="">const</c-><c- o="">&amp;</c-><c- p="">;</c->
    <c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">U</c-><c- o="">&gt;</c->
        <c- n="">constexpr</c-> <c- n="">T</c-> <c- n="">value_or</c-><c- p="">(</c-><c- n="">U</c-><c- o="">&amp;&amp;</c-><c- p="">)</c-> <c- o="">&amp;&amp;</c-><c- p="">;</c->

    <c- c1="">// �.�.7.7, Expected equality operators</c->
    <c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">T2</c-><c- p="">,</c-> <c- n="">class</c-> <c- n="">E2</c-><c- o="">&gt;</c->
        <c- n="">friend</c-> <c- n="">constexpr</c-> <c- b="">bool</c-> <c- n="">operator</c-><c- o="">==</c-><c- p="">(</c-><c- k="">const</c-> <c- n="">expected</c-><c- o="">&amp;</c-> <c- n="">x</c-><c- p="">,</c-> <c- k="">const</c-> <c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T2</c-><c- p="">,</c-> <c- n="">E2</c-><c- o="">&gt;&amp;</c-> <c- n="">y</c-><c- p="">);</c->
    <c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">T2</c-><c- o="">&gt;</c->
        <c- n="">friend</c-> <c- n="">constexpr</c-> <c- b="">bool</c-> <c- n="">operator</c-><c- o="">==</c-><c- p="">(</c-><c- k="">const</c-> <c- n="">expected</c-><c- o="">&amp;</c-><c- p="">,</c-> <c- k="">const</c-> <c- n="">T2</c-><c- o="">&amp;</c-><c- p="">);</c->
    <c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">E2</c-><c- o="">&gt;</c->
        <c- n="">friend</c-> <c- n="">constexpr</c-> <c- b="">bool</c-> <c- n="">operator</c-><c- o="">==</c-><c- p="">(</c-><c- k="">const</c-> <c- n="">expected</c-><c- o="">&amp;</c-><c- p="">,</c-> <c- k="">const</c-> <c- n="">unexpected</c-><c- o="">&lt;</c-><c- n="">E2</c-><c- o="">&gt;&amp;</c-><c- p="">);</c->

    <c- c1="">// �.�.7.10, Specialized algorithms</c->
    <c- n="">friend</c-> <c- n="">constexpr</c-> <c- b="">void</c-> <c- n="">swap</c-><c- p="">(</c-><c- n="">expected</c-><c- o="">&amp;</c-><c- p="">,</c-> <c- n="">expected</c-><c- o="">&amp;</c-><c- p="">)</c-> <c- n="">noexcept</c-><c- p="">(</c-><c- n="">see</c-> <c- n="">below</c-><c- p="">);</c->

<c- nl="">private</c-><c- p="">:</c->
    <c- b="">bool</c-> <c- n="">has_val</c-><c- p="">;</c-> <c- c1="">// exposition only</c->
    <c- k="">union</c->
    <c- p="">{</c->
        <c- n="">T</c-> <c- n="">val</c-><c- p="">;</c->  <c- c1="">// exposition only</c->
        <c- n="">E</c-> <c- n="">unex</c-><c- p="">;</c-> <c- c1="">// exposition only</c->
    <c- p="">};</c->
<c- p="">};</c->
</pre>
   <p>Any object of <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-></code> either contains a value of type <code class="highlight"><c- n="">T</c-></code> or a value of
type <code class="highlight"><c- n="">E</c-></code> within its own storage. Implementations are not permitted
to use additional storage, such as dynamic memory, to allocate the object of
type <code class="highlight"><c- n="">T</c-></code> or the object of type <code class="highlight"><c- n="">E</c-></code>. These objects are allocated
in a region of the <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-></code> storage suitably aligned for the types <code class="highlight"><c- n="">T</c-></code> and <code class="highlight"><c- n="">E</c-></code>. Members <code class="highlight"><c- n="">has_val</c-></code>, <code class="highlight"><c- n="">val</c-></code> and <code class="highlight"><c- n="">unex</c-></code> are provided for
exposition only. <code class="highlight"><c- n="">has_val</c-></code> indicates whether the <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-></code> object
contains an object of type <code class="highlight"><c- n="">T</c-></code>.</p>
   <p>A program that instantiates the definition of template <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-></code> for a
reference type, a function type, or for possibly cv-qualified types <code class="highlight"><c- n="">in_place_t</c-></code>, <code class="highlight"><c- n="">unexpect_t</c-></code>, or a specialization of <code class="highlight"><c- n="">unexpected</c-></code> for the <code class="highlight"><c- n="">T</c-></code> parameter is
ill-formed. A program that instantiates the definition of template <code class="highlight"><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-></code> with a type for the <code class="highlight"><c- n="">E</c-></code> parameter that is not a valid
template argument for <code class="highlight"><c- n="">unexpected</c-></code> is ill-formed.</p>
   <p>When <code class="highlight"><c- n="">T</c-></code> is not <em>cv</em> <code class="highlight"><c- b="">void</c-></code>, it shall meet the requirements of <code class="highlight"><c- n="">Cpp17Destructible</c-></code> (Table 27).</p>
   <p><code class="highlight"><c- n="">E</c-></code> shall meet the requirements of <code class="highlight"><c- n="">Cpp17Destructible</c-></code> (Table 27).</p>
   <h3 class="heading settled" data-level="5.8" id="expected.object.ctor"><span class="secno">5.8. </span><span class="content">�.�.7.1 Constructors [<em>expected.object.ctor</em>]</span><a class="self-link" href="#expected.object.ctor"></a></h3>
<pre class="language-c++ highlight"><c- n="">constexpr</c-> <c- nf="">expected</c-><c- p="">();</c->
</pre>
   <p><em>Constraints</em>: <code class="highlight"><c- n="">is_default_constructible_v</c-><c- o="">&lt;</c-><c- n="">T</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code>.</p>
   <p><em>Effects</em>: Value-initializes <code class="highlight"><c- n="">val</c-></code>.</p>
   <p><em>Postconditions</em>: <code class="highlight"><c- n="">has_value</c-><c- p="">()</c-></code> is <code class="highlight">true</code>.</p>
   <p><em>Throws</em>: Any exception thrown by the initialization of <code class="highlight"><c- n="">val</c-></code>.</p>
<pre class="language-c++ highlight"><c- n="">constexpr</c-> <c- nf="">expected</c-><c- p="">(</c-><c- k="">const</c-> <c- n="">expected</c-><c- o="">&amp;</c-> <c- n="">rhs</c-><c- p="">);</c->
</pre>
   <p><em>Effects</em>: If <code class="highlight"><c- n="">rhs</c-><c- p="">.</c-><c- n="">has_value</c-><c- p="">()</c-></code> is <code class="highlight">true</code>, direct-non-list-initializes <code class="highlight"><c- n="">val</c-></code> with <code class="highlight"><c- o="">*</c-><c- n="">rhs</c-></code>.
Otherwise, direct-non-list-initializes <code class="highlight"><c- n="">unex</c-></code> with <code class="highlight"><c- n="">rhs</c-><c- p="">.</c-><c- n="">error</c-><c- p="">()</c-></code>.</p>
   <p><em>Postconditions</em>: <code class="highlight"><c- n="">rhs</c-><c- p="">.</c-><c- n="">has_value</c-><c- p="">()</c-> <c- o="">==</c-> <c- k="">this</c-><c- o="">-&gt;</c-><c- n="">has_value</c-><c- p="">()</c-></code>.</p>
   <p><em>Throws</em>: Any exception thrown by the initialization of <code class="highlight"><c- n="">val</c-></code> or <code class="highlight"><c- n="">unex</c-></code>.</p>
   <p><em>Remarks</em>: This constructor is defined as deleted unless:</p>
   <ul>
    <li data-md="">
     <p><code class="highlight"><c- n="">is_copy_constructible_v</c-><c- o="">&lt;</c-><c- n="">T</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code>; and</p>
    </li><li data-md="">
     <p><code class="highlight"><c- n="">is_copy_constructible_v</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code>.</p>
   </li></ul>
   <p>This constructor is trivial if:</p>
   <ul>
    <li data-md="">
     <p><code class="highlight"><c- n="">is_trivially_copy_constructible_v</c-><c- o="">&lt;</c-><c- n="">T</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code>; and</p>
    </li><li data-md="">
     <p><code class="highlight"><c- n="">is_trivially_copy_constructible_v</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code>.</p>
   </li></ul>
<pre class="language-c++ highlight"><c- n="">constexpr</c-> <c- nf="">expected</c-><c- p="">(</c-><c- n="">expected</c-><c- o="">&amp;&amp;</c-> <c- n="">rhs</c-><c- p="">)</c-> <c- n="">noexcept</c-><c- p="">(</c-><c- n="">see</c-> <c- n="">below</c-><c- p="">);</c->
</pre>
   <p><em>Constraints</em>:</p>
   <ul>
    <li data-md="">
     <p><code class="highlight"><c- n="">is_move_constructible_v</c-><c- o="">&lt;</c-><c- n="">T</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code>; and</p>
    </li><li data-md="">
     <p><code class="highlight"><c- n="">is_move_constructible_v</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code>.</p>
   </li></ul>
   <p><em>Effects</em>: If <code class="highlight"><c- n="">rhs</c-><c- p="">.</c-><c- n="">has_value</c-><c- p="">()</c-></code> is <code class="highlight">true</code>, direct-non-list-initializes <code class="highlight"><c- n="">val</c-></code> with <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">move</c-><c- p="">(</c-><c- o="">*</c-><c- n="">rhs</c-><c- p="">)</c-></code>.
Otherwise, direct-non-list-initializes <code class="highlight"><c- n="">unex</c-></code> with <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">move</c-><c- p="">(</c-><c- n="">rhs</c-><c- p="">.</c-><c- n="">error</c-><c- p="">())</c-></code>.</p>
   <p><em>Postconditions</em>: <code class="highlight"><c- n="">rhs</c-><c- p="">.</c-><c- n="">has_value</c-><c- p="">()</c-></code> is unchanged, <code class="highlight"><c- n="">rhs</c-><c- p="">.</c-><c- n="">has_value</c-><c- p="">()</c-> <c- o="">==</c-> <c- k="">this</c-><c- o="">-&gt;</c-><c- n="">has_value</c-><c- p="">()</c-></code>.</p>
   <p><em>Throws</em>: Any exception thrown by the initialization of <code class="highlight"><c- n="">val</c-></code> or <code class="highlight"><c- n="">unex</c-></code>.</p>
   <p><em>Remarks</em>:
The exception specification is <code class="highlight"><c- n="">is_nothrow_move_constructible_v</c-><c- o="">&lt;</c-><c- n="">T</c-><c- o="">&gt;</c-> <c- o="">&amp;&amp;</c-> <c- n="">is_nothrow_move_constructible_v</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-></code>.</p>
   <p><em>Remarks</em>: This constructor is trivial if:</p>
   <ul>
    <li data-md="">
     <p><code class="highlight"><c- n="">is_trivially_move_constructible_v</c-><c- o="">&lt;</c-><c- n="">T</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code>; and</p>
    </li><li data-md="">
     <p><code class="highlight"><c- n="">is_trivially_move_constructible_v</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code>.</p>
   </li></ul>
<pre class="language-c++ highlight"><c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">U</c-><c- p="">,</c-> <c- n="">class</c-> <c- n="">G</c-><c- o="">&gt;</c->
    <c- n="">constexpr</c-> <c- n="">explicit</c-><c- p="">(</c-><c- n="">see</c-> <c- n="">below</c-><c- p="">)</c-> <c- n="">expected</c-><c- p="">(</c-><c- k="">const</c-> <c- n="">expected</c-><c- o="">&lt;</c-><c- n="">U</c-><c- p="">,</c-> <c- n="">G</c-><c- o="">&gt;&amp;</c-> <c- n="">rhs</c-><c- p="">);</c->
<c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">U</c-><c- p="">,</c-> <c- n="">class</c-> <c- n="">G</c-><c- o="">&gt;</c->
    <c- n="">constexpr</c-> <c- n="">explicit</c-><c- p="">(</c-><c- n="">see</c-> <c- n="">below</c-><c- p="">)</c-> <c- n="">expected</c-><c- p="">(</c-><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">U</c-><c- p="">,</c-> <c- n="">G</c-><c- o="">&gt;&amp;&amp;</c-> <c- n="">rhs</c-><c- p="">);</c->
</pre>
   <p>Let:</p>
   <ul>
    <li data-md="">
     <p><code class="highlight"><c- n="">UF</c-></code> be <code class="highlight"><c- k="">const</c-> <c- n="">U</c-><c- o="">&amp;</c-></code> for the first overload and <code class="highlight"><c- n="">U</c-></code> for the second overload.</p>
    </li><li data-md="">
     <p><code class="highlight"><c- n="">GF</c-></code> be <code class="highlight"><c- k="">const</c-> <c- n="">G</c-><c- o="">&amp;</c-></code> for the first overload and <code class="highlight"><c- n="">G</c-></code> for the second overload.</p>
   </li></ul>
   <p><em>Constraints</em>:</p>
   <ul>
    <li data-md="">
     <p><code class="highlight"><c- n="">is_constructible_v</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">UF</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code>; and</p>
    </li><li data-md="">
     <p><code class="highlight"><c- n="">is_constructible_v</c-><c- o="">&lt;</c-><c- n="">E</c-><c- p="">,</c-> <c- n="">GF</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code>; and</p>
    </li><li data-md="">
     <p><code class="highlight"><c- n="">is_constructible_v</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">expected</c-><c- o="">&lt;</c-><c- n="">U</c-><c- p="">,</c-> <c- n="">G</c-><c- o="">&gt;&amp;&gt;</c-></code> is <code class="highlight">false</code>; and</p>
    </li><li data-md="">
     <p><code class="highlight"><c- n="">is_constructible_v</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">expected</c-><c- o="">&lt;</c-><c- n="">U</c-><c- p="">,</c-> <c- n="">G</c-><c- o="">&gt;&gt;</c-></code> is <code class="highlight">false</code>; and</p>
    </li><li data-md="">
     <p><code class="highlight"><c- n="">is_constructible_v</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- k="">const</c-> <c- n="">expected</c-><c- o="">&lt;</c-><c- n="">U</c-><c- p="">,</c-> <c- n="">G</c-><c- o="">&gt;&amp;&gt;</c-></code> is <code class="highlight">false</code>; and</p>
    </li><li data-md="">
     <p><code class="highlight"><c- n="">is_constructible_v</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- k="">const</c-> <c- n="">expected</c-><c- o="">&lt;</c-><c- n="">U</c-><c- p="">,</c-> <c- n="">G</c-><c- o="">&gt;&gt;</c-></code> is <code class="highlight">false</code>; and</p>
    </li><li data-md="">
     <p><code class="highlight"><c- n="">is_convertible_v</c-><c- o="">&lt;</c-><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">U</c-><c- p="">,</c-> <c- n="">G</c-><c- o="">&gt;&amp;</c-><c- p="">,</c-> <c- n="">T</c-><c- o="">&gt;</c-></code> is <code class="highlight">false</code>; and</p>
    </li><li data-md="">
     <p><code class="highlight"><c- n="">is_convertible_v</c-><c- o="">&lt;</c-><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">U</c-><c- p="">,</c-> <c- n="">G</c-><c- o="">&gt;&amp;&amp;</c-><c- p="">,</c-> <c- n="">T</c-><c- o="">&gt;</c-></code> is <code class="highlight">false</code>; and</p>
    </li><li data-md="">
     <p><code class="highlight"><c- n="">is_convertible_v</c-><c- o="">&lt;</c-><c- k="">const</c-> <c- n="">expected</c-><c- o="">&lt;</c-><c- n="">U</c-><c- p="">,</c-> <c- n="">G</c-><c- o="">&gt;&amp;</c-><c- p="">,</c-> <c- n="">T</c-><c- o="">&gt;</c-></code> is <code class="highlight">false</code>; and</p>
    </li><li data-md="">
     <p><code class="highlight"><c- n="">is_convertible_v</c-><c- o="">&lt;</c-><c- k="">const</c-> <c- n="">expected</c-><c- o="">&lt;</c-><c- n="">U</c-><c- p="">,</c-> <c- n="">G</c-><c- o="">&gt;&amp;&amp;</c-><c- p="">,</c-> <c- n="">T</c-><c- o="">&gt;</c-></code> is <code class="highlight">false</code>; and</p>
    </li><li data-md="">
     <p><code class="highlight"><c- n="">is_constructible_v</c-><c- o="">&lt;</c-><c- n="">unexpected</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-><c- p="">,</c-> <c- n="">expected</c-><c- o="">&lt;</c-><c- n="">U</c-><c- p="">,</c-> <c- n="">G</c-><c- o="">&gt;&amp;&gt;</c-></code> is <code class="highlight">false</code>; and</p>
    </li><li data-md="">
     <p><code class="highlight"><c- n="">is_constructible_v</c-><c- o="">&lt;</c-><c- n="">unexpected</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-><c- p="">,</c-> <c- n="">expected</c-><c- o="">&lt;</c-><c- n="">U</c-><c- p="">,</c-> <c- n="">G</c-><c- o="">&gt;&gt;</c-></code> is <code class="highlight">false</code>; and</p>
    </li><li data-md="">
     <p><code class="highlight"><c- n="">is_constructible_v</c-><c- o="">&lt;</c-><c- n="">unexpected</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-><c- p="">,</c-> <c- k="">const</c-> <c- n="">expected</c-><c- o="">&lt;</c-><c- n="">U</c-><c- p="">,</c-> <c- n="">G</c-><c- o="">&gt;&amp;&gt;</c-></code> is <code class="highlight">false</code>; and</p>
    </li><li data-md="">
     <p><code class="highlight"><c- n="">is_constructible_v</c-><c- o="">&lt;</c-><c- n="">unexpected</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-><c- p="">,</c-> <c- k="">const</c-> <c- n="">expected</c-><c- o="">&lt;</c-><c- n="">U</c-><c- p="">,</c-> <c- n="">G</c-><c- o="">&gt;&gt;</c-></code> is <code class="highlight">false</code>.</p>
   </li></ul>
   <p><em>Effects</em>: If <code class="highlight"><c- n="">rhs</c-><c- p="">.</c-><c- n="">has_value</c-><c- p="">()</c-></code>, direct-non-list-initializes <code class="highlight"><c- n="">val</c-></code> with <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">forward</c-><c- o="">&lt;</c-><c- n="">UF</c-><c- o="">&gt;</c-><c- p="">(</c-><c- o="">*</c-><c- n="">rhs</c-><c- p="">)</c-></code>.
Otherwise, direct-non-list-initializes <code class="highlight"><c- n="">unex</c-></code> with <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">forward</c-><c- o="">&lt;</c-><c- n="">GF</c-><c- o="">&gt;</c-><c- p="">(</c-><c- n="">rhs</c-><c- p="">.</c-><c- n="">error</c-><c- p="">())</c-></code>.</p>
   <p><em>Postconditions</em>: <code class="highlight"><c- n="">rhs</c-><c- p="">.</c-><c- n="">has_value</c-><c- p="">()</c-></code> is unchanged, <code class="highlight"><c- n="">rhs</c-><c- p="">.</c-><c- n="">has_value</c-><c- p="">()</c-> <c- o="">==</c-> <c- k="">this</c-><c- o="">-&gt;</c-><c- n="">has_value</c-><c- p="">()</c-></code>.</p>
   <p><em>Throws</em>: Any exception thrown by the initialization of <code class="highlight"><c- n="">val</c-></code> or <code class="highlight"><c- n="">unex</c-></code>.</p>
   <p><em>Remarks</em>:
The expression inside <code class="highlight"><c- k="">explicit</c-></code> is equivalent to <code class="highlight"><c- o="">!</c-><c- n="">is_convertible_v</c-><c- o="">&lt;</c-><c- n="">UF</c-><c- p="">,</c-> <c- n="">T</c-><c- o="">&gt;</c-> <c- o="">||</c-> <c- o="">!</c-><c- n="">is_convertible_v</c-><c- o="">&lt;</c-><c- n="">GF</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-></code>.</p>
<pre class="language-c++ highlight"><c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">U</c-> <c- o="">=</c-> <c- n="">T</c-><c- o="">&gt;</c->
    <c- n="">constexpr</c-> <c- n="">explicit</c-><c- p="">(</c-><c- o="">!</c-><c- n="">is_convertible_v</c-><c- o="">&lt;</c-><c- n="">U</c-><c- p="">,</c-> <c- n="">T</c-><c- o="">&gt;</c-><c- p="">)</c-> <c- n="">expected</c-><c- p="">(</c-><c- n="">U</c-><c- o="">&amp;&amp;</c-> <c- n="">v</c-><c- p="">);</c->
</pre>
   <p><em>Constraints</em>:</p>
   <ul>
    <li data-md="">
     <p><code class="highlight"><c- n="">is_same_v</c-><c- o="">&lt;</c-><c- n="">remove_cvref_t</c-><c- o="">&lt;</c-><c- n="">U</c-><c- o="">&gt;</c-><c- p="">,</c-> <c- n="">in_place_t</c-><c- o="">&gt;</c-></code> is <code class="highlight">false</code>; and</p>
    </li><li data-md="">
     <p><code class="highlight"><c- n="">is_same_v</c-><c- o="">&lt;</c-><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-><c- p="">,</c-> <c- n="">remove_cvref_t</c-><c- o="">&lt;</c-><c- n="">U</c-><c- o="">&gt;&gt;</c-></code> is <code class="highlight">false</code>; and</p>
    </li><li data-md="">
     <p><code class="highlight"><c- n="">remove_cvref_t</c-><c- o="">&lt;</c-><c- n="">U</c-><c- o="">&gt;</c-></code> is not a specialization of <code class="highlight"><c- n="">unexpected</c-></code>; and</p>
    </li><li data-md="">
     <p><code class="highlight"><c- n="">is_constructible_v</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">U</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code>.</p>
   </li></ul>
   <p><em>Effects</em>: Direct-non-list-initializes <code class="highlight"><c- n="">val</c-></code> with <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">forward</c-><c- o="">&lt;</c-><c- n="">U</c-><c- o="">&gt;</c-><c- p="">(</c-><c- n="">v</c-><c- p="">)</c-></code>.</p>
   <p><em>Postconditions</em>: <code class="highlight"><c- n="">has_value</c-><c- p="">()</c-></code> is <code class="highlight">true</code>.</p>
   <p><em>Throws</em>: Any exception thrown by the initialization of <code class="highlight"><c- n="">val</c-></code>.</p>
<pre class="language-c++ highlight"><c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">G</c-><c- o="">&gt;</c->
    <c- n="">constexpr</c-> <c- n="">explicit</c-><c- p="">(</c-><c- o="">!</c-><c- n="">is_convertible_v</c-><c- o="">&lt;</c-><c- k="">const</c-> <c- n="">G</c-><c- o="">&amp;</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-><c- p="">)</c-> <c- n="">expected</c-><c- p="">(</c-><c- k="">const</c-> <c- n="">unexpected</c-><c- o="">&lt;</c-><c- n="">G</c-><c- o="">&gt;&amp;</c-> <c- n="">e</c-><c- p="">);</c->
<c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">G</c-><c- o="">&gt;</c->
    <c- n="">constexpr</c-> <c- n="">explicit</c-><c- p="">(</c-><c- o="">!</c-><c- n="">is_convertible_v</c-><c- o="">&lt;</c-><c- n="">G</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-><c- p="">)</c-> <c- n="">expected</c-><c- p="">(</c-><c- n="">unexpected</c-><c- o="">&lt;</c-><c- n="">G</c-><c- o="">&gt;&amp;&amp;</c-> <c- n="">e</c-><c- p="">);</c->
</pre>
   <p>Let <code class="highlight"><c- n="">GF</c-></code> be <code class="highlight"><c- k="">const</c-> <c- n="">G</c-><c- o="">&amp;</c-></code> for the first overload and <code class="highlight"><c- n="">G</c-></code> for the second overload.</p>
   <p><em>Constraints</em>: <code class="highlight"><c- n="">is_constructible_v</c-><c- o="">&lt;</c-><c- n="">E</c-><c- p="">,</c-> <c- n="">GF</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code>.</p>
   <p><em>Effects</em>: Direct-non-list-initializes <code class="highlight"><c- n="">unex</c-></code> with <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">forward</c-><c- o="">&lt;</c-><c- n="">GF</c-><c- o="">&gt;</c-><c- p="">(</c-><c- n="">e</c-><c- p="">.</c-><c- n="">error</c-><c- p="">())</c-></code>.</p>
   <p><em>Postconditions</em>: <code class="highlight"><c- n="">has_value</c-><c- p="">()</c-></code> is <code class="highlight">false</code>.</p>
   <p><em>Throws</em>: Any exception thrown by the initialization of <code class="highlight"><c- n="">unex</c-></code>.</p>
<pre class="language-c++ highlight"><c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-><c- p="">...</c-> <c- n="">Args</c-><c- o="">&gt;</c->
    <c- n="">constexpr</c-> <c- n="">explicit</c-> <c- n="">expected</c-><c- p="">(</c-><c- n="">in_place_t</c-><c- p="">,</c-> <c- n="">Args</c-><c- o="">&amp;&amp;</c-><c- p="">...</c-> <c- n="">args</c-><c- p="">);</c->
</pre>
   <p><em>Constraints</em>:</p>
   <ul>
    <li data-md="">
     <p><code class="highlight"><c- n="">is_constructible_v</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">Args</c-><c- p="">...</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code>.</p>
   </li></ul>
   <p><em>Effects</em>: Direct-non-list-initializes <code class="highlight"><c- n="">val</c-></code> with <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">forward</c-><c- o="">&lt;</c-><c- n="">Args</c-><c- o="">&gt;</c-><c- p="">(</c-><c- n="">args</c-><c- p="">)...</c-></code>.</p>
   <p><em>Postconditions</em>: <code class="highlight"><c- n="">has_value</c-><c- p="">()</c-></code> is <code class="highlight">true</code>.</p>
   <p><em>Throws</em>: Any exception thrown by the initialization of <code class="highlight"><c- n="">val</c-></code>.</p>
<pre class="language-c++ highlight"><c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">U</c-><c- p="">,</c-> <c- n="">class</c-><c- p="">...</c-> <c- n="">Args</c-><c- o="">&gt;</c->
    <c- n="">constexpr</c-> <c- n="">explicit</c-> <c- n="">expected</c-><c- p="">(</c-><c- n="">in_place_t</c-><c- p="">,</c-> <c- n="">initializer_list</c-><c- o="">&lt;</c-><c- n="">U</c-><c- o="">&gt;</c-> <c- n="">il</c-><c- p="">,</c-> <c- n="">Args</c-><c- o="">&amp;&amp;</c-><c- p="">...</c-> <c- n="">args</c-><c- p="">);</c->
</pre>
   <p><em>Constraints</em>: <code class="highlight"><c- n="">is_constructible_v</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">initializer_list</c-><c- o="">&lt;</c-><c- n="">U</c-><c- o="">&gt;&amp;</c-><c- p="">,</c-> <c- n="">Args</c-><c- p="">...</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code>.</p>
   <p><em>Effects</em>: Direct-non-list-initializes <code class="highlight"><c- n="">val</c-></code> with <code class="highlight"><c- n="">il</c-><c- p="">,</c-> <c- n="">std</c-><c- o="">::</c-><c- n="">forward</c-><c- o="">&lt;</c-><c- n="">Args</c-><c- o="">&gt;</c-><c- p="">(</c-><c- n="">args</c-><c- p="">)...</c-></code>.</p>
   <p><em>Postconditions</em>: <code class="highlight"><c- n="">has_value</c-><c- p="">()</c-></code> is <code class="highlight">true</code>.</p>
   <p><em>Throws</em>: Any exception thrown by the initialization of <code class="highlight"><c- n="">val</c-></code>.</p>
<pre class="language-c++ highlight"><c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-><c- p="">...</c-> <c- n="">Args</c-><c- o="">&gt;</c->
    <c- n="">constexpr</c-> <c- n="">explicit</c-> <c- n="">expected</c-><c- p="">(</c-><c- n="">unexpect_t</c-><c- p="">,</c-> <c- n="">Args</c-><c- o="">&amp;&amp;</c-><c- p="">...</c-> <c- n="">args</c-><c- p="">);</c->
</pre>
   <p><em>Constraints</em>: <code class="highlight"><c- n="">is_constructible_v</c-><c- o="">&lt;</c-><c- n="">E</c-><c- p="">,</c-> <c- n="">Args</c-><c- p="">...</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code>.</p>
   <p><em>Effects</em>: Direct-non-list-initializes <code class="highlight"><c- n="">unex</c-></code> with <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">forward</c-><c- o="">&lt;</c-><c- n="">Args</c-><c- o="">&gt;</c-><c- p="">(</c-><c- n="">args</c-><c- p="">)...</c-></code>.</p>
   <p><em>Postconditions</em>: <code class="highlight"><c- n="">has_value</c-><c- p="">()</c-></code> is <code class="highlight">false</code>.</p>
   <p><em>Throws</em>: Any exception thrown by the initialization of <code class="highlight"><c- n="">unex</c-></code>.</p>
<pre class="language-c++ highlight"><c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">U</c-><c- p="">,</c-> <c- n="">class</c-><c- p="">...</c-> <c- n="">Args</c-><c- o="">&gt;</c->
    <c- n="">constexpr</c-> <c- n="">explicit</c-> <c- n="">expected</c-><c- p="">(</c-><c- n="">unexpect_t</c-><c- p="">,</c-> <c- n="">initializer_list</c-><c- o="">&lt;</c-><c- n="">U</c-><c- o="">&gt;</c-> <c- n="">il</c-><c- p="">,</c-> <c- n="">Args</c-><c- o="">&amp;&amp;</c-><c- p="">...</c-> <c- n="">args</c-><c- p="">);</c->
</pre>
   <p><em>Constraints</em>: <code class="highlight"><c- n="">is_constructible_v</c-><c- o="">&lt;</c-><c- n="">E</c-><c- p="">,</c-> <c- n="">initializer_list</c-><c- o="">&lt;</c-><c- n="">U</c-><c- o="">&gt;&amp;</c-><c- p="">,</c-> <c- n="">Args</c-><c- p="">...</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code>.</p>
   <p><em>Effects</em>: Direct-non-list-initializes <code class="highlight"><c- n="">unex</c-></code> with <code class="highlight"><c- n="">il</c-><c- p="">,</c-> <c- n="">std</c-><c- o="">::</c-><c- n="">forward</c-><c- o="">&lt;</c-><c- n="">Args</c-><c- o="">&gt;</c-><c- p="">(</c-><c- n="">args</c-><c- p="">)...</c-></code>.</p>
   <p><em>Postconditions</em>: <code class="highlight"><c- n="">has_value</c-><c- p="">()</c-></code> is <code class="highlight">false</code>.</p>
   <p><em>Throws</em>: Any exception thrown by the initialization of <code class="highlight"><c- n="">unex</c-></code>.</p>
   <h3 class="heading settled" data-level="5.9" id="expected.object.dtor"><span class="secno">5.9. </span><span class="content">�.�.7.2 Destructor [<em>expected.object.dtor</em>]</span><a class="self-link" href="#expected.object.dtor"></a></h3>
<pre class="language-c++ highlight"><c- n="">constexpr</c-> <c- o="">~</c-><c- n="">expected</c-><c- p="">();</c->
</pre>
   <p><em>Effects</em>: If <code class="highlight"><c- n="">has_value</c-><c- p="">()</c-></code> is <code class="highlight">true</code>, destroys <code class="highlight"><c- n="">val</c-></code>, otherwise destroys <code class="highlight"><c- n="">unex</c-></code>.</p>
   <p><em>Remarks</em>: If <code class="highlight"><c- n="">is_trivially_destructible_v</c-><c- o="">&lt;</c-><c- n="">T</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code>, and <code class="highlight"><c- n="">is_trivially_destructible_v</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code>, then this destructor
is a trivial destructor.</p>
   <h3 class="heading settled" data-level="5.10" id="expected.object.assign"><span class="secno">5.10. </span><span class="content">�.�.7.3 Assignment [<em>expected.object.assign</em>]</span><a class="self-link" href="#expected.object.assign"></a></h3>
   <p>This subclause makes use of the following exposition-only function:</p>
   <blockquote> [Drafting note: the name <i><code class="highlight"><c- n="">reinit</c-><c- o="">-</c-><c- n="">expected</c-></code></i> should be kebab case in this codeblock.] </blockquote>
<pre class="language-c++ highlight"><c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">T</c-><c- p="">,</c-> <c- n="">class</c-> <c- n="">U</c-><c- p="">,</c-> <c- n="">class</c-><c- p="">...</c-> <c- n="">Args</c-><c- o="">&gt;</c->
<c- n="">constexpr</c-> <c- b="">void</c-> <c- n="">reinit</c-><c- o="">-</c-><c- n="">expected</c-><c- p="">(</c-><c- n="">T</c-><c- o="">&amp;</c-> <c- n="">newval</c-><c- p="">,</c-> <c- n="">U</c-><c- o="">&amp;</c-> <c- n="">oldval</c-><c- p="">,</c-> <c- n="">Args</c-><c- o="">&amp;&amp;</c-><c- p="">...</c-> <c- n="">args</c-><c- p="">)</c->
<c- p="">{</c->
  <c- k="">if</c-> <c- nf="">constexpr</c-> <c- p="">(</c-><c- n="">is_nothrow_constructible_v</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">Args</c-><c- p="">...</c-><c- o="">&gt;</c-><c- p="">)</c-> <c- p="">{</c->
    <c- n="">destroy_at</c-><c- p="">(</c-><c- n="">addressof</c-><c- p="">(</c-><c- n="">oldval</c-><c- p="">));</c->
    <c- n="">construct_at</c-><c- p="">(</c-><c- n="">addressof</c-><c- p="">(</c-><c- n="">newval</c-><c- p="">),</c-> <c- n="">std</c-><c- o="">::</c-><c- n="">forward</c-><c- o="">&lt;</c-><c- n="">Args</c-><c- o="">&gt;</c-><c- p="">(</c-><c- n="">args</c-><c- p="">)...);</c->
  <c- p="">}</c-> <c- k="">else</c-> <c- k="">if</c-> <c- n="">constexpr</c-> <c- p="">(</c-><c- n="">is_nothrow_move_constructible_v</c-><c- o="">&lt;</c-><c- n="">T</c-><c- o="">&gt;</c-><c- p="">)</c-> <c- p="">{</c->
    <c- n="">T</c-> <c- nf="">tmp</c-><c- p="">(</c-><c- n="">std</c-><c- o="">::</c-><c- n="">forward</c-><c- o="">&lt;</c-><c- n="">Args</c-><c- o="">&gt;</c-><c- p="">(</c-><c- n="">args</c-><c- p="">)...);</c->
    <c- n="">destroy_at</c-><c- p="">(</c-><c- n="">addressof</c-><c- p="">(</c-><c- n="">oldval</c-><c- p="">));</c->
    <c- n="">construct_at</c-><c- p="">(</c-><c- n="">addressof</c-><c- p="">(</c-><c- n="">newval</c-><c- p="">),</c-> <c- n="">std</c-><c- o="">::</c-><c- n="">move</c-><c- p="">(</c-><c- n="">tmp</c-><c- p="">));</c->
  <c- p="">}</c-> <c- k="">else</c-> <c- p="">{</c->
    <c- n="">U</c-> <c- nf="">tmp</c-><c- p="">(</c-><c- n="">std</c-><c- o="">::</c-><c- n="">move</c-><c- p="">(</c-><c- n="">oldval</c-><c- p="">));</c->
    <c- n="">destroy_at</c-><c- p="">(</c-><c- n="">addressof</c-><c- p="">(</c-><c- n="">oldval</c-><c- p="">));</c->
    <c- n="">try</c-> <c- p="">{</c->
      <c- n="">construct_at</c-><c- p="">(</c-><c- n="">addressof</c-><c- p="">(</c-><c- n="">newval</c-><c- p="">),</c-> <c- n="">std</c-><c- o="">::</c-><c- n="">forward</c-><c- o="">&lt;</c-><c- n="">Args</c-><c- o="">&gt;</c-><c- p="">(</c-><c- n="">args</c-><c- p="">)...);</c->
    <c- p="">}</c-> <c- n="">catch</c-> <c- p="">(...)</c-> <c- p="">{</c->
      <c- n="">construct_at</c-><c- p="">(</c-><c- n="">addressof</c-><c- p="">(</c-><c- n="">oldval</c-><c- p="">),</c-> <c- n="">std</c-><c- o="">::</c-><c- n="">move</c-><c- p="">(</c-><c- n="">tmp</c-><c- p="">));</c->
      <c- n="">throw</c-><c- p="">;</c->
    <c- p="">}</c->
  <c- p="">}</c->
<c- p="">}</c->
</pre>
<pre class="language-c++ highlight"><c- n="">constexpr</c-> <c- n="">expected</c-><c- o="">&amp;</c-> <c- n="">operator</c-><c- o="">=</c-><c- p="">(</c-><c- k="">const</c-> <c- n="">expected</c-><c- o="">&amp;</c-> <c- n="">rhs</c-><c- p="">);</c->
</pre>
   <p><em>Effects</em>:</p>
   <ul>
    <li data-md="">
     <p>If <code class="highlight"><c- k="">this</c-><c- o="">-&gt;</c-><c- n="">has_value</c-><c- p="">()</c-> <c- o="">&amp;&amp;</c-> <c- n="">rhs</c-><c- p="">.</c-><c- n="">has_value</c-><c- p="">()</c-></code> is <code class="highlight">true</code>, equivalent to <code class="highlight"><c- n="">val</c-> <c- o="">=</c-> <c- o="">*</c-><c- n="">rhs</c-></code>.</p>
    </li><li data-md="">
     <p>Otherwise, if <code class="highlight"><c- k="">this</c-><c- o="">-&gt;</c-><c- n="">has_value</c-><c- p="">()</c-></code> is <code class="highlight">true</code>, equivalent to <i><code class="highlight"><c- n="">reinit</c-><c- o="">-</c-><c- n="">expected</c-></code></i><code class="highlight"><c- p="">(</c-><c- n="">unex</c-><c- p="">,</c-> <c- n="">val</c-><c- p="">,</c-> <c- n="">rhs</c-><c- p="">.</c-><c- n="">error</c-><c- p="">())</c-></code>.</p>
    </li><li data-md="">
     <p>Otherwise, if <code class="highlight"><c- n="">rhs</c-><c- p="">.</c-><c- n="">has_value</c-><c- p="">()</c-></code> is <code class="highlight">true</code>, equivalent to <i><code class="highlight"><c- n="">reinit</c-><c- o="">-</c-><c- n="">expected</c-></code></i><code class="highlight"><c- p="">(</c-><c- n="">val</c-><c- p="">,</c-> <c- n="">unex</c-><c- p="">,</c-> <c- o="">*</c-><c- n="">rhs</c-><c- p="">)</c-></code>.</p>
    </li><li data-md="">
     <p>Otherwise, equivalent to <code class="highlight"><c- n="">unex</c-> <c- o="">=</c-> <c- n="">rhs</c-><c- p="">.</c-><c- n="">error</c-><c- p="">()</c-></code>.</p>
   </li></ul>
   <p>Then, if no exception was thrown, equivalent to: <code class="highlight"><c- n="">has_val</c-> <c- o="">=</c-> <c- n="">rhs</c-><c- p="">.</c-><c- n="">has_value</c-><c- p="">();</c-> <c- k="">return</c-> <c- o="">*</c-><c- k="">this</c-><c- p="">;</c-></code></p>
   <p><em>Remarks</em>:
This operator is defined as deleted unless:</p>
   <ul>
    <li data-md="">
     <p><code class="highlight"><c- n="">is_copy_assignable_v</c-><c- o="">&lt;</c-><c- n="">T</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code> and <code class="highlight"><c- n="">is_copy_constructible_v</c-><c- o="">&lt;</c-><c- n="">T</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code> and <code class="highlight"><c- n="">is_copy_assignable_v</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code> and <code class="highlight"><c- n="">is_copy_constructible_v</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code> and <code class="highlight"><c- n="">is_nothrow_move_constructible_v</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-> <c- o="">||</c-> <c- n="">is_nothrow_move_constructible_v</c-><c- o="">&lt;</c-><c- n="">T</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code>.</p>
   </li></ul>
<pre class="language-c++ highlight"><c- n="">constexpr</c-> <c- n="">expected</c-><c- o="">&amp;</c-> <c- n="">operator</c-><c- o="">=</c-><c- p="">(</c-><c- n="">expected</c-><c- o="">&amp;&amp;</c-> <c- n="">rhs</c-><c- p="">)</c-> <c- n="">noexcept</c-><c- p="">(</c-><c- n="">see</c-> <c- n="">below</c-><c- p="">);</c->
</pre>
   <p><em>Constraints</em>: <code class="highlight"><c- n="">is_move_constructible_v</c-><c- o="">&lt;</c-><c- n="">T</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code> and <code class="highlight"><c- n="">is_move_assignable_v</c-><c- o="">&lt;</c-><c- n="">T</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code> and <code class="highlight"><c- n="">is_move_constructible_v</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code> and <code class="highlight"><c- n="">is_move_assignable_v</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code> and <code class="highlight"><c- n="">is_nothrow_move_constructible_v</c-><c- o="">&lt;</c-><c- n="">T</c-><c- o="">&gt;</c-> <c- o="">||</c-> <c- n="">is_nothrow_move_constructible_v</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code>.</p>
   <p><em>Effects</em>:</p>
   <ul>
    <li data-md="">
     <p>If <code class="highlight"><c- k="">this</c-><c- o="">-&gt;</c-><c- n="">has_value</c-><c- p="">()</c-> <c- o="">&amp;&amp;</c-> <c- n="">rhs</c-><c- p="">.</c-><c- n="">has_value</c-><c- p="">()</c-></code> is <code class="highlight">true</code>, equivalent to <code class="highlight"><c- n="">val</c-> <c- o="">=</c-> <c- n="">std</c-><c- o="">::</c-><c- n="">move</c-><c- p="">(</c-><c- o="">*</c-><c- n="">rhs</c-><c- p="">)</c-></code>.</p>
    </li><li data-md="">
     <p>Otherwise, if <code class="highlight"><c- k="">this</c-><c- o="">-&gt;</c-><c- n="">has_value</c-><c- p="">()</c-></code> is <code class="highlight">true</code>, equivalent to <i><code class="highlight"><c- n="">reinit</c-><c- o="">-</c-><c- n="">expected</c-></code></i><code class="highlight"><c- p="">(</c-><c- n="">unex</c-><c- p="">,</c-> <c- n="">val</c-><c- p="">,</c-> <c- n="">std</c-><c- o="">::</c-><c- n="">move</c-><c- p="">(</c-><c- n="">rhs</c-><c- p="">.</c-><c- n="">error</c-><c- p="">()))</c-></code>.</p>
    </li><li data-md="">
     <p>Otherwise, if <code class="highlight"><c- n="">rhs</c-><c- p="">.</c-><c- n="">has_value</c-><c- p="">()</c-></code> is <code class="highlight">true</code>, equivalent to <i><code class="highlight"><c- n="">reinit</c-><c- o="">-</c-><c- n="">expected</c-></code></i><code class="highlight"><c- p="">(</c-><c- n="">val</c-><c- p="">,</c-> <c- n="">unex</c-><c- p="">,</c-> <c- n="">std</c-><c- o="">::</c-><c- n="">move</c-><c- p="">(</c-><c- o="">*</c-><c- n="">rhs</c-><c- p="">))</c-></code>.</p>
    </li><li data-md="">
     <p>Otherwise, equivalent to <code class="highlight"><c- n="">unex</c-> <c- o="">=</c-> <c- n="">std</c-><c- o="">::</c-><c- n="">move</c-><c- p="">(</c-><c- n="">rhs</c-><c- p="">.</c-><c- n="">error</c-><c- p="">())</c-></code>.</p>
   </li></ul>
   <p>Then, if no exception was thrown, equivalent to: <code class="highlight"><c- n="">has_val</c-> <c- o="">=</c-> <c- n="">rhs</c-><c- p="">.</c-><c- n="">has_value</c-><c- p="">();</c-> <c- k="">return</c-> <c- o="">*</c-><c- k="">this</c-><c- p="">;</c-></code></p>
   <p><em>Remarks</em>:
The exception specification is <code class="highlight"><c- n="">is_nothrow_move_assignable_v</c-><c- o="">&lt;</c-><c- n="">T</c-><c- o="">&gt;</c-> <c- o="">&amp;&amp;</c-> <c- n="">is_nothrow_move_constructible_v</c-><c- o="">&lt;</c-><c- n="">T</c-><c- o="">&gt;</c-> <c- o="">&amp;&amp;</c-> <c- n="">is_nothrow_move_assignable_v</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-> <c- o="">&amp;&amp;</c-> <c- n="">is_nothrow_move_constructible_v</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-></code>.</p>
<pre class="language-c++ highlight"><c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">U</c-> <c- o="">=</c-> <c- n="">T</c-><c- o="">&gt;</c->
    <c- n="">constexpr</c-> <c- n="">expected</c-><c- o="">&amp;</c-> <c- n="">operator</c-><c- o="">=</c-><c- p="">(</c-><c- n="">U</c-><c- o="">&amp;&amp;</c-> <c- n="">v</c-><c- p="">);</c->
</pre>
   <p><em>Constraints</em>:</p>
   <ul>
    <li data-md="">
     <p><code class="highlight"><c- n="">is_same_v</c-><c- o="">&lt;</c-><c- n="">expected</c-><c- p="">,</c-> <c- n="">remove_cvref_t</c-><c- o="">&lt;</c-><c- n="">U</c-><c- o="">&gt;&gt;</c-></code> is <code class="highlight">false</code>; and</p>
    </li><li data-md="">
     <p><code class="highlight"><c- n="">remove_cvref_t</c-><c- o="">&lt;</c-><c- n="">U</c-><c- o="">&gt;</c-></code> is not a specialization of <code class="highlight"><c- n="">unexpected</c-></code>; and</p>
    </li><li data-md="">
     <p><code class="highlight"><c- n="">is_constructible_v</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">U</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code>; and</p>
    </li><li data-md="">
     <p><code class="highlight"><c- n="">is_assignable_v</c-><c- o="">&lt;</c-><c- n="">T</c-><c- o="">&amp;</c-><c- p="">,</c-> <c- n="">U</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code>; and</p>
    </li><li data-md="">
     <p><code class="highlight"><c- n="">is_nothrow_constructible_v</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">U</c-><c- o="">&gt;</c-> <c- o="">||</c-> <c- n="">is_nothrow_move_constructible_v</c-><c- o="">&lt;</c-><c- n="">T</c-><c- o="">&gt;</c-> <c- o="">||</c-> <c- n="">is_nothrow_move_constructible_v</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code>.</p>
   </li></ul>
   <p><em>Effects</em>:</p>
   <ul>
    <li data-md="">
     <p>If <code class="highlight"><c- n="">has_value</c-><c- p="">()</c-></code> is <code class="highlight">true</code>, equivalent to: <code class="highlight"><c- n="">val</c-> <c- o="">=</c-> <c- n="">std</c-><c- o="">::</c-><c- n="">forward</c-><c- o="">&lt;</c-><c- n="">U</c-><c- o="">&gt;</c-><c- p="">(</c-><c- n="">v</c-><c- p="">);</c-> <c- k="">return</c-> <c- o="">*</c-><c- k="">this</c-><c- p="">;</c-></code></p>
    </li><li data-md="">
     <p>Otherwise, equivalent to <i><code class="highlight"><c- n="">reinit</c-><c- o="">-</c-><c- n="">expected</c-></code></i><code class="highlight"><c- p="">(</c-><c- n="">val</c-><c- p="">,</c-> <c- n="">unex</c-><c- p="">,</c-> <c- n="">std</c-><c- o="">::</c-><c- n="">forward</c-><c- o="">&lt;</c-><c- n="">U</c-><c- o="">&gt;</c-><c- p="">(</c-><c- n="">v</c-><c- p="">));</c-> <c- n="">has_val</c-> <c- o="">=</c-> true<c- p="">;</c-> <c- k="">return</c-> <c- o="">*</c-><c- k="">this</c-><c- p="">;</c-></code></p>
   </li></ul>
<pre class="language-c++ highlight"><c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">G</c-><c- o="">&gt;</c->
    <c- n="">constexpr</c-> <c- n="">expected</c-><c- o="">&amp;</c-> <c- n="">operator</c-><c- o="">=</c-><c- p="">(</c-><c- k="">const</c-> <c- n="">unexpected</c-><c- o="">&lt;</c-><c- n="">G</c-><c- o="">&gt;&amp;</c-> <c- n="">e</c-><c- p="">);</c->
<c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">G</c-><c- o="">&gt;</c->
    <c- n="">constexpr</c-> <c- n="">expected</c-><c- o="">&amp;</c-> <c- n="">operator</c-><c- o="">=</c-><c- p="">(</c-><c- n="">unexpected</c-><c- o="">&lt;</c-><c- n="">G</c-><c- o="">&gt;&amp;&amp;</c-> <c- n="">e</c-><c- p="">);</c->
</pre>
   <p>Let <code class="highlight"><c- n="">GF</c-></code> be <code class="highlight"><c- k="">const</c-> <c- n="">G</c-><c- o="">&amp;</c-></code> for the first overload and <code class="highlight"><c- n="">G</c-></code> for the second overload.</p>
   <p><em>Constraints</em>:</p>
   <ul>
    <li data-md="">
     <p><code class="highlight"><c- n="">is_constructible_v</c-><c- o="">&lt;</c-><c- n="">E</c-><c- p="">,</c-> <c- n="">GF</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code>.</p>
    </li><li data-md="">
     <p><code class="highlight"><c- n="">is_assignable_v</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&amp;</c-><c- p="">,</c-> <c- n="">GF</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code>; and</p>
    </li><li data-md="">
     <p><code class="highlight"><c- n="">is_nothrow_constructible_v</c-><c- o="">&lt;</c-><c- n="">E</c-><c- p="">,</c-> <c- n="">GF</c-><c- o="">&gt;</c-> <c- o="">||</c-> <c- n="">is_nothrow_move_constructible_v</c-><c- o="">&lt;</c-><c- n="">T</c-><c- o="">&gt;</c-> <c- o="">||</c-> <c- n="">is_nothrow_move_constructible_v</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code>.</p>
   </li></ul>
   <p><em>Effects</em>:</p>
   <ul>
    <li data-md="">
     <p>If <code class="highlight"><c- n="">has_value</c-><c- p="">()</c-></code> is <code class="highlight">true</code>, equivalent to <i><code class="highlight"><c- n="">reinit</c-><c- o="">-</c-><c- n="">expected</c-></code></i><code class="highlight"><c- p="">(</c-><c- n="">unex</c-><c- p="">,</c-> <c- n="">val</c-><c- p="">,</c-> <c- n="">std</c-><c- o="">::</c-><c- n="">forward</c-><c- o="">&lt;</c-><c- n="">GF</c-><c- o="">&gt;</c-><c- p="">(</c-><c- n="">e</c-><c- p="">.</c-><c- n="">value</c-><c- p="">()));</c-> <c- n="">has_val</c-> <c- o="">=</c-> false<c- p="">;</c-> <c- k="">return</c-> <c- o="">*</c-><c- k="">this</c-><c- p="">;</c-></code></p>
    </li><li data-md="">
     <p>Otherwise, equivalent to: <code class="highlight"><c- n="">unex</c-> <c- o="">=</c-> <c- n="">std</c-><c- o="">::</c-><c- n="">forward</c-><c- o="">&lt;</c-><c- n="">GF</c-><c- o="">&gt;</c-><c- p="">(</c-><c- n="">e</c-><c- p="">.</c-><c- n="">value</c-><c- p="">());</c-> <c- k="">return</c-> <c- o="">*</c-><c- k="">this</c-><c- p="">;</c-></code></p>
   </li></ul>
<pre class="language-c++ highlight"><c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-><c- p="">...</c-> <c- n="">Args</c-><c- o="">&gt;</c->
    <c- n="">constexpr</c-> <c- n="">T</c-><c- o="">&amp;</c-> <c- n="">emplace</c-><c- p="">(</c-><c- n="">Args</c-><c- o="">&amp;&amp;</c-><c- p="">...</c-> <c- n="">args</c-><c- p="">)</c-> <c- n="">noexcept</c-><c- p="">;</c->
</pre>
   <p><em>Constraints</em>: <code class="highlight"><c- n="">is_nothrow_constructible_v</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">Args</c-><c- p="">...</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code>.</p>
   <p><em>Effects</em>: Equivalent to:</p>
<pre class="language-c++ highlight"><c- k="">if</c-> <c- p="">(</c-><c- n="">has_value</c-><c- p="">())</c->
  <c- n="">destroy_at</c-><c- p="">(</c-><c- n="">addressof</c-><c- p="">(</c-><c- n="">val</c-><c- p="">));</c->
<c- k="">else</c-> <c- p="">{</c->
  <c- n="">destroy_at</c-><c- p="">(</c-><c- n="">addressof</c-><c- p="">(</c-><c- n="">unex</c-><c- p="">));</c->
  <c- n="">has_val</c-> <c- o="">=</c-> true<c- p="">;</c->
<c- p="">}</c->
<c- k="">return</c-> <c- o="">*</c-><c- n="">construct_at</c-><c- p="">(</c-><c- n="">addressof</c-><c- p="">(</c-><c- n="">val</c-><c- p="">),</c-> <c- n="">std</c-><c- o="">::</c-><c- n="">forward</c-><c- o="">&lt;</c-><c- n="">Args</c-><c- o="">&gt;</c-><c- p="">(</c-><c- n="">args</c-><c- p="">)...);</c->
</pre>
<pre class="language-c++ highlight"><c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">U</c-><c- p="">,</c-> <c- n="">class</c-><c- p="">...</c-> <c- n="">Args</c-><c- o="">&gt;</c->
    <c- n="">constexpr</c-> <c- n="">T</c-><c- o="">&amp;</c-> <c- n="">emplace</c-><c- p="">(</c-><c- n="">initializer_list</c-><c- o="">&lt;</c-><c- n="">U</c-><c- o="">&gt;</c-> <c- n="">il</c-><c- p="">,</c-> <c- n="">Args</c-><c- o="">&amp;&amp;</c-><c- p="">...</c-> <c- n="">args</c-><c- p="">)</c-> <c- n="">noexcept</c-><c- p="">;</c->
</pre>
   <p><em>Constraints</em>: <code class="highlight"><c- n="">is_nothrow_constructible_v</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">initializer_list</c-><c- o="">&lt;</c-><c- n="">U</c-><c- o="">&gt;&amp;</c-><c- p="">,</c-> <c- n="">Args</c-><c- p="">...</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code>.</p>
   <p><em>Effects</em>:  Equivalent to:</p>
<pre class="language-c++ highlight"><c- k="">if</c-> <c- p="">(</c-><c- n="">has_value</c-><c- p="">())</c->
  <c- n="">destroy_at</c-><c- p="">(</c-><c- n="">addressof</c-><c- p="">(</c-><c- n="">val</c-><c- p="">));</c->
<c- k="">else</c-> <c- p="">{</c->
  <c- n="">destroy_at</c-><c- p="">(</c-><c- n="">addressof</c-><c- p="">(</c-><c- n="">unex</c-><c- p="">));</c->
  <c- n="">has_val</c-> <c- o="">=</c-> true<c- p="">;</c->
<c- p="">}</c->
<c- k="">return</c-> <c- o="">*</c-><c- n="">construct_at</c-><c- p="">(</c-><c- n="">addressof</c-><c- p="">(</c-><c- n="">val</c-><c- p="">),</c-> <c- n="">il</c-><c- p="">,</c-> <c- n="">std</c-><c- o="">::</c-><c- n="">forward</c-><c- o="">&lt;</c-><c- n="">Args</c-><c- o="">&gt;</c-><c- p="">(</c-><c- n="">args</c-><c- p="">)...);</c->
</pre>
   <h3 class="heading settled" data-level="5.11" id="expected.object.swap"><span class="secno">5.11. </span><span class="content">�.�.7.4 Swap [<em>expected.object.swap</em>]</span><a class="self-link" href="#expected.object.swap"></a></h3>
<pre class="language-c++ highlight"><c- n="">constexpr</c-> <c- b="">void</c-> <c- n="">swap</c-><c- p="">(</c-><c- n="">expected</c-><c- o="">&amp;</c-> <c- n="">rhs</c-><c- p="">)</c-> <c- n="">noexcept</c-><c- p="">(</c-><c- n="">see</c-> <c- n="">below</c-><c- p="">);</c->
</pre>
   <p><em>Constraints</em>:</p>
   <ul>
    <li data-md="">
     <p><code class="highlight"><c- n="">is_swappable_v</c-><c- o="">&lt;</c-><c- n="">T</c-><c- o="">&gt;</c-></code>; and</p>
    </li><li data-md="">
     <p><code class="highlight"><c- n="">is_swappable_v</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-></code>; and</p>
    </li><li data-md="">
     <p><code class="highlight"><c- n="">is_move_constructible_v</c-><c- o="">&lt;</c-><c- n="">T</c-><c- o="">&gt;</c-> <c- o="">&amp;&amp;</c-> <c- n="">is_move_constructible_v</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code>, and</p>
    </li><li data-md="">
     <p><code class="highlight"><c- n="">is_nothrow_move_constructible_v</c-><c- o="">&lt;</c-><c- n="">T</c-><c- o="">&gt;</c-> <c- o="">||</c-> <c- n="">is_nothrow_move_constructible_v</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code>.</p>
   </li></ul>
   <p><em>Effects</em>: See Table <em>editor-please-pick-a-number-5</em></p>
   <table>
    <caption>Table <em>editor-please-pick-a-number-5</em> — <code class="highlight"><c- n="">swap</c-><c- p="">(</c-><c- n="">expected</c-><c- o="">&amp;</c-><c- p="">)</c-></code> effects</caption>
    <tbody>
     <tr>
      <td>
      </td><td><code class="highlight"><c- n="">has_value</c-><c- p="">()</c-></code>
      </td><td><code class="highlight"><c- o="">!</c-><c- n="">has_value</c-><c- p="">()</c-></code>
     </td></tr><tr>
      <td><code class="highlight"><c- n="">rhs</c-><c- p="">.</c-><c- n="">has_value</c-><c- p="">()</c-></code>
      </td><td>equivalent to: <code class="highlight"><c- k="">using</c-> <c- n="">std</c-><c- o="">::</c-><c- n="">swap</c-><c- p="">;</c-> <c- n="">swap</c-><c- p="">(</c-><c- n="">val</c-><c- p="">,</c-> <c- n="">rhs</c-><c- p="">.</c-><c- n="">val</c-><c- p="">);</c-></code>
      </td><td>calls <code class="highlight"><c- n="">rhs</c-><c- p="">.</c-><c- n="">swap</c-><c- p="">(</c-><c- o="">*</c-><c- k="">this</c-><c- p="">)</c-></code>
     </td></tr><tr>
      <td><code class="highlight"><c- o="">!</c-><c- n="">rhs</c-><c- p="">.</c-><c- n="">has_value</c-><c- p="">()</c-></code>
      </td><td>
       <p>See below <sup>†</sup>.</p>
      </td><td>equivalent to: <code class="highlight"><c- k="">using</c-> <c- n="">std</c-><c- o="">::</c-><c- n="">swap</c-><c- p="">;</c-> <c- n="">swap</c-><c- p="">(</c-><c- n="">unex</c-><c- p="">,</c-> <c- n="">rhs</c-><c- p="">.</c-><c- n="">unex</c-><c- p="">);</c-></code>
   </td></tr></tbody></table>
   <p><sup>†</sup> For the case where <code class="highlight"><c- n="">rhs</c-><c- p="">.</c-><c- n="">value</c-><c- p="">()</c-></code> is <code class="highlight">false</code> and <code class="highlight"><c- k="">this</c-><c- o="">-&gt;</c-><c- n="">has_value</c-><c- p="">()</c-></code> is <code class="highlight">true</code>, equivalent to:</p>
<pre class="highlight"><c- k="">if</c-> <c- nf="">constexpr</c-> <c- p="">(</c-><c- n="">is_nothrow_move_constructible_v</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-><c- p="">)</c-> <c- p="">{</c->
  <c- n="">E</c-> <c- n="">tmp</c-><c- p="">(</c-><c- n="">std</c-><c- o="">::</c-><c- n="">move</c-><c- p="">(</c-><c- n="">rhs</c-><c- p="">.</c-><c- n="">unex</c-><c- p="">));</c->
  <c- n="">destroy_at</c-><c- p="">(</c-><c- n="">addressof</c-><c- p="">(</c-><c- n="">rhs</c-><c- p="">.</c-><c- n="">unex</c-><c- p="">));</c->
  <c- k="">try</c-> <c- p="">{</c->
    <c- n="">construct_at</c-><c- p="">(</c-><c- n="">addressof</c-><c- p="">(</c-><c- n="">rhs</c-><c- p="">.</c-><c- n="">val</c-><c- p="">),</c-> <c- n="">std</c-><c- o="">::</c-><c- n="">move</c-><c- p="">(</c-><c- n="">val</c-><c- p="">));</c->
    <c- n="">destroy_at</c-><c- p="">(</c-><c- n="">addressof</c-><c- p="">(</c-><c- n="">val</c-><c- p="">));</c->
    <c- n="">construct_at</c-><c- p="">(</c-><c- n="">addressof</c-><c- p="">(</c-><c- n="">unex</c-><c- p="">),</c-> <c- n="">std</c-><c- o="">::</c-><c- n="">move</c-><c- p="">(</c-><c- n="">tmp</c-><c- p="">));</c->
  <c- p="">}</c-> <c- k="">catch</c-><c- p="">(...)</c-> <c- p="">{</c->
    <c- n="">construct_at</c-><c- p="">(</c-><c- n="">addressof</c-><c- p="">(</c-><c- n="">rhs</c-><c- p="">.</c-><c- n="">unex</c-><c- p="">),</c-> <c- n="">std</c-><c- o="">::</c-><c- n="">move</c-><c- p="">(</c-><c- n="">tmp</c-><c- p="">));</c->
    <c- k="">throw</c-><c- p="">;</c->
  <c- p="">}</c->
<c- k="">else</c-> <c- p="">{</c->
  <c- n="">T</c-> <c- n="">tmp</c-><c- p="">(</c-><c- n="">std</c-><c- o="">::</c-><c- n="">move</c-><c- p="">(</c-><c- n="">val</c-><c- p="">));</c->
  <c- n="">destroy_at</c-><c- p="">(</c-><c- n="">addressof</c-><c- p="">(</c-><c- n="">val</c-><c- p="">));</c->
  <c- k="">try</c-> <c- p="">{</c->
    <c- n="">construct_at</c-><c- p="">(</c-><c- n="">addressof</c-><c- p="">(</c-><c- n="">unex</c-><c- p="">),</c-> <c- n="">std</c-><c- o="">::</c-><c- n="">move</c-><c- p="">(</c-><c- n="">rhs</c-><c- p="">.</c-><c- n="">unex</c-><c- p="">));</c->
    <c- n="">destroy_at</c-><c- p="">(</c-><c- n="">addressof</c-><c- p="">(</c-><c- n="">rhs</c-><c- p="">.</c-><c- n="">unex</c-><c- p="">));</c->
    <c- n="">construct_at</c-><c- p="">(</c-><c- n="">addressof</c-><c- p="">(</c-><c- n="">rhs</c-><c- p="">.</c-><c- n="">val</c-><c- p="">),</c-> <c- n="">std</c-><c- o="">::</c-><c- n="">move</c-><c- p="">(</c-><c- n="">tmp</c-><c- p="">));</c->
  <c- p="">}</c-> <c- k="">catch</c-> <c- p="">(...)</c-> <c- p="">{</c->
    <c- n="">construct_at</c-><c- p="">(</c-><c- n="">addressof</c-><c- p="">(</c-><c- n="">val</c-><c- p="">),</c-> <c- n="">std</c-><c- o="">::</c-><c- n="">move</c-><c- p="">(</c-><c- n="">tmp</c-><c- p="">));</c->
    <c- k="">throw</c-><c- p="">;</c->
  <c- p="">}</c->
<c- p="">}</c->
<c- n="">has_val</c-> <c- o="">=</c-> false<c- p="">;</c->
<c- n="">rhs</c-><c- p="">.</c-><c- n="">has_val</c-> <c- o="">=</c-> true<c- p="">;</c->
</pre>
   <p><em>Throws</em>: Any exception thrown by the expressions in the <em>Effects</em>.</p>
   <p><em>Remarks</em>: The exception specification is:</p>
<pre class="language-c++ highlight"><c- n="">is_nothrow_move_constructible_v</c-><c- o="">&lt;</c-><c- n="">T</c-><c- o="">&gt;</c-> <c- o="">&amp;&amp;</c->
<c- n="">is_nothrow_swappable_v</c-><c- o="">&lt;</c-><c- n="">T</c-><c- o="">&gt;</c-> <c- o="">&amp;&amp;</c->
<c- n="">is_nothrow_move_constructible_v</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-> <c- o="">&amp;&amp;</c->
<c- n="">is_nothrow_swappable_v</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c->
</pre>
<pre class="language-c++ highlight"><c- n="">friend</c-> <c- n="">constexpr</c-> <c- b="">void</c-> <c- n="">swap</c-><c- p="">(</c-><c- n="">expected</c-><c- o="">&amp;</c-> <c- n="">x</c-><c- p="">,</c-> <c- n="">expected</c-><c- o="">&amp;</c-> <c- n="">y</c-><c- p="">)</c-> <c- n="">noexcept</c-><c- p="">(</c-><c- n="">noexcept</c-><c- p="">(</c-><c- n="">x</c-><c- p="">.</c-><c- n="">swap</c-><c- p="">(</c-><c- n="">y</c-><c- p="">)));</c->
</pre>
   <p><em>Effects</em>: Equivalent to <code class="highlight"><c- n="">x</c-><c- p="">.</c-><c- n="">swap</c-><c- p="">(</c-><c- n="">y</c-><c- p="">)</c-></code>.</p>
   <h3 class="heading settled" data-level="5.12" id="expected.object.observe"><span class="secno">5.12. </span><span class="content">�.�.7.5 Observers [<em>expected.object.observe</em>]</span><a class="self-link" href="#expected.object.observe"></a></h3>
<pre class="language-c++ highlight"><c- n="">constexpr</c-> <c- k="">const</c-> <c- n="">T</c-><c- o="">*</c-> <c- n="">operator</c-><c- o="">-&gt;</c-><c- p="">()</c-> <c- k="">const</c-> <c- n="">noexcept</c-><c- p="">;</c->
<c- n="">constexpr</c-> <c- n="">T</c-><c- o="">*</c-> <c- n="">operator</c-><c- o="">-&gt;</c-><c- p="">()</c-> <c- n="">noexcept</c-><c- p="">;</c->
</pre>
   <p><em>Preconditions</em>: <code class="highlight"><c- n="">has_value</c-><c- p="">()</c-></code> is <code class="highlight">true</code>.</p>
   <p><em>Returns</em>: <code class="highlight"><c- n="">addressof</c-><c- p="">(</c-><c- n="">val</c-><c- p="">)</c-></code>.</p>
<pre class="language-c++ highlight"><c- n="">constexpr</c-> <c- k="">const</c-> <c- n="">T</c-><c- o="">&amp;</c-> <c- n="">operator</c-><c- o="">*</c-><c- p="">()</c-> <c- k="">const</c-><c- o="">&amp;</c-> <c- n="">noexcept</c-><c- p="">;</c->
<c- n="">constexpr</c-> <c- n="">T</c-><c- o="">&amp;</c-> <c- n="">operator</c-><c- o="">*</c-><c- p="">()</c-> <c- o="">&amp;</c-> <c- n="">noexcept</c-><c- p="">;</c->
</pre>
   <p><em>Preconditions</em>: <code class="highlight"><c- n="">has_value</c-><c- p="">()</c-></code> is <code class="highlight">true</code>.</p>
   <p><em>Returns</em>: <code class="highlight"><c- n="">val</c-></code>.</p>
<pre class="language-c++ highlight"><c- n="">constexpr</c-> <c- n="">T</c-><c- o="">&amp;&amp;</c-> <c- n="">operator</c-><c- o="">*</c-><c- p="">()</c-> <c- o="">&amp;&amp;</c-> <c- n="">noexcept</c-><c- p="">;</c->
<c- n="">constexpr</c-> <c- k="">const</c-> <c- n="">T</c-><c- o="">&amp;&amp;</c-> <c- n="">operator</c-><c- o="">*</c-><c- p="">()</c-> <c- k="">const</c-><c- o="">&amp;&amp;</c-> <c- n="">noexcept</c-><c- p="">;</c->
</pre>
   <p><em>Preconditions</em>: <code class="highlight"><c- n="">has_value</c-><c- p="">()</c-></code> is <code class="highlight">true</code>.</p>
   <p><em>Returns</em>: <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">move</c-><c- p="">(</c-><c- n="">val</c-><c- p="">)</c-></code>.</p>
<pre class="language-c++ highlight"><c- n="">constexpr</c-> <c- n="">explicit</c-> <c- n="">operator</c-> <c- b="">bool</c-><c- p="">()</c-> <c- k="">const</c-> <c- n="">noexcept</c-><c- p="">;</c->
<c- n="">constexpr</c-> <c- b="">bool</c-> <c- n="">has_value</c-><c- p="">()</c-> <c- k="">const</c-> <c- n="">noexcept</c-><c- p="">;</c->
</pre>
   <p><em>Returns</em>: <code class="highlight"><c- n="">has_val</c-></code>.</p>
<pre class="language-c++ highlight"><c- n="">constexpr</c-> <c- k="">const</c-> <c- n="">T</c-><c- o="">&amp;</c-> <c- n="">value</c-><c- p="">()</c-> <c- k="">const</c-><c- o="">&amp;</c-><c- p="">;</c->
<c- n="">constexpr</c-> <c- n="">T</c-><c- o="">&amp;</c-> <c- n="">value</c-><c- p="">()</c-> <c- o="">&amp;</c-><c- p="">;</c->
</pre>
   <p><em>Returns</em>: <code class="highlight"><c- n="">val</c-></code>, if <code class="highlight"><c- n="">has_value</c-><c- p="">()</c-></code> is <code class="highlight">true</code> .</p>
   <p><em>Throws</em>: <code class="highlight"><c- n="">bad_expected_access</c-><c- p="">(</c-><c- n="">error</c-><c- p="">())</c-></code> if <code class="highlight"><c- n="">has_value</c-><c- p="">()</c-></code> is <code class="highlight">false</code>.</p>
<pre class="language-c++ highlight"><c- n="">constexpr</c-> <c- n="">T</c-><c- o="">&amp;&amp;</c-> <c- n="">value</c-><c- p="">()</c-> <c- o="">&amp;&amp;</c-><c- p="">;</c->
<c- n="">constexpr</c-> <c- k="">const</c-> <c- n="">T</c-><c- o="">&amp;&amp;</c-> <c- n="">value</c-><c- p="">()</c-> <c- k="">const</c-><c- o="">&amp;&amp;</c-><c- p="">;</c->
</pre>
   <p><em>Returns</em>: <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">move</c-><c- p="">(</c-><c- n="">val</c-><c- p="">)</c-></code>, if <code class="highlight"><c- n="">has_value</c-><c- p="">()</c-></code> is <code class="highlight">true</code> .</p>
   <p><em>Throws</em>: <code class="highlight"><c- n="">bad_expected_access</c-><c- p="">(</c-><c- n="">std</c-><c- o="">::</c-><c- n="">move</c-><c- p="">(</c-><c- n="">error</c-><c- p="">()))</c-></code> if <code class="highlight"><c- n="">has_value</c-><c- p="">()</c-></code> is <code class="highlight">false</code>.</p>
<pre class="language-c++ highlight"><c- n="">constexpr</c-> <c- k="">const</c-> <c- n="">E</c-><c- o="">&amp;</c-> <c- n="">error</c-><c- p="">()</c-> <c- k="">const</c-><c- o="">&amp;</c-> <c- n="">noexcept</c-><c- p="">;</c->
<c- n="">constexpr</c-> <c- n="">E</c-><c- o="">&amp;</c-> <c- n="">error</c-><c- p="">()</c-> <c- o="">&amp;</c-> <c- n="">noexcept</c-><c- p="">;</c->
</pre>
   <p><em>Preconditions</em>: <code class="highlight"><c- n="">has_value</c-><c- p="">()</c-></code> is <code class="highlight">false</code>.</p>
   <p><em>Returns</em>: <code class="highlight"><c- n="">unex</c-></code>.</p>
<pre class="language-c++ highlight"><c- n="">constexpr</c-> <c- n="">E</c-><c- o="">&amp;&amp;</c-> <c- n="">error</c-><c- p="">()</c-> <c- o="">&amp;&amp;</c-> <c- n="">noexcept</c-><c- p="">;</c->
<c- n="">constexpr</c-> <c- k="">const</c-> <c- n="">E</c-><c- o="">&amp;&amp;</c-> <c- n="">error</c-><c- p="">()</c-> <c- k="">const</c-><c- o="">&amp;&amp;</c-> <c- n="">noexcept</c-><c- p="">;</c->
</pre>
   <p><em>Preconditions</em>: <code class="highlight"><c- n="">has_value</c-><c- p="">()</c-></code> is <code class="highlight">false</code>.</p>
   <p><em>Returns</em>: <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">move</c-><c- p="">(</c-><c- n="">unex</c-><c- p="">)</c-></code>.</p>
<pre class="language-c++ highlight"><c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">U</c-><c- o="">&gt;</c->
    <c- n="">constexpr</c-> <c- n="">T</c-> <c- n="">value_or</c-><c- p="">(</c-><c- n="">U</c-><c- o="">&amp;&amp;</c-> <c- n="">v</c-><c- p="">)</c-> <c- k="">const</c-><c- o="">&amp;</c-><c- p="">;</c->
</pre>
   <p><em>Mandates</em>: <code class="highlight"><c- n="">is_copy_constructible_v</c-><c- o="">&lt;</c-><c- n="">T</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code> and <code class="highlight"><c- n="">is_convertible</c-><c- o="">&lt;</c-><c- n="">U</c-><c- p="">,</c-> <c- n="">T</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code>.</p>
   <p><em>Returns</em>: <code class="highlight"><c- n="">has_value</c-><c- p="">()</c-> <c- o="">?</c-> <c- o="">**</c-><c- k="">this</c-> <c- o="">:</c-> <c- k="">static_cast</c-><c- o="">&lt;</c-><c- n="">T</c-><c- o="">&gt;</c-><c- p="">(</c-><c- n="">std</c-><c- o="">::</c-><c- n="">forward</c-><c- o="">&lt;</c-><c- n="">U</c-><c- o="">&gt;</c-><c- p="">(</c-><c- n="">v</c-><c- p="">))</c-></code>.</p>
<pre class="language-c++ highlight"><c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">U</c-><c- o="">&gt;</c->
    <c- n="">constexpr</c-> <c- n="">T</c-> <c- n="">value_or</c-><c- p="">(</c-><c- n="">U</c-><c- o="">&amp;&amp;</c-> <c- n="">v</c-><c- p="">)</c-> <c- o="">&amp;&amp;</c-><c- p="">;</c->
</pre>
   <p><em>Mandates</em>: <code class="highlight"><c- n="">is_move_constructible_v</c-><c- o="">&lt;</c-><c- n="">T</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code> and <code class="highlight"><c- n="">is_convertible</c-><c- o="">&lt;</c-><c- n="">U</c-><c- p="">,</c-> <c- n="">T</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code>.</p>
   <p><em>Returns</em>: <code class="highlight"><c- n="">has_value</c-><c- p="">()</c-> <c- o="">?</c-> <c- n="">std</c-><c- o="">::</c-><c- n="">move</c-><c- p="">(</c-><c- o="">**</c-><c- k="">this</c-><c- p="">)</c-> <c- o="">:</c-> <c- k="">static_cast</c-><c- o="">&lt;</c-><c- n="">T</c-><c- o="">&gt;</c-><c- p="">(</c-><c- n="">std</c-><c- o="">::</c-><c- n="">forward</c-><c- o="">&lt;</c-><c- n="">U</c-><c- o="">&gt;</c-><c- p="">(</c-><c- n="">v</c-><c- p="">))</c-></code>.</p>
   <h3 class="heading settled" data-level="5.13" id="expected.object.eq"><span class="secno">5.13. </span><span class="content">�.�.7.6 Expected Equality operators [<em>expected.object.eq</em>]</span><a class="self-link" href="#expected.object.eq"></a></h3>
<pre class="language-c++ highlight"><c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">T2</c-><c- p="">,</c-> <c- n="">class</c-> <c- n="">E2</c-><c- o="">&gt;</c->
    <c- n="">requires</c-> <c- p="">(</c-><c- o="">!</c-><c- n="">is_void_v</c-><c- o="">&lt;</c-><c- n="">T2</c-><c- o="">&gt;</c-><c- p="">)</c->
    <c- n="">friend</c-> <c- n="">constexpr</c-> <c- b="">bool</c-> <c- n="">operator</c-><c- o="">==</c-><c- p="">(</c-><c- k="">const</c-> <c- n="">expected</c-><c- o="">&amp;</c-> <c- n="">x</c-><c- p="">,</c-> <c- k="">const</c-> <c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T2</c-><c- p="">,</c-> <c- n="">E2</c-><c- o="">&gt;&amp;</c-> <c- n="">y</c-><c- p="">);</c->
</pre>
   <p><em>Mandates</em>: The expressions <code class="highlight"><c- o="">*</c-><c- n="">x</c-> <c- o="">==</c-> <c- o="">*</c-><c- n="">y</c-></code> and <code class="highlight"><c- n="">x</c-><c- p="">.</c-><c- n="">error</c-><c- p="">()</c-><c- o="">==</c-> <c- n="">y</c-><c- p="">.</c-><c- n="">error</c-><c- p="">()</c-></code> are well-formed and their results
are convertible to <code class="highlight"><c- b="">bool</c-></code>.</p>
   <p><em>Returns</em>:
If <code class="highlight"><c- n="">x</c-><c- p="">.</c-><c- n="">has_value</c-><c- p="">()</c-></code> does not equal <code class="highlight"><c- n="">y</c-><c- p="">.</c-><c- n="">has_value</c-><c- p="">()</c-></code>, <code class="highlight">false</code>;
otherwise if <code class="highlight"><c- n="">x</c-><c- p="">.</c-><c- n="">has_value</c-><c- p="">()</c-></code> is <code class="highlight">true</code>, <code class="highlight"><c- o="">*</c-><c- n="">x</c-> <c- o="">==</c-> <c- o="">*</c-><c- n="">y</c-></code>;
otherwise <code class="highlight"><c- n="">x</c-><c- p="">.</c-><c- n="">error</c-><c- p="">()</c-> <c- o="">==</c-> <c- n="">y</c-><c- p="">.</c-><c- n="">error</c-><c- p="">()</c-></code>.</p>
<pre class="language-c++ highlight"><c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">T2</c-><c- o="">&gt;</c-> <c- n="">constexpr</c-> <c- b="">bool</c-> <c- n="">operator</c-><c- o="">==</c-><c- p="">(</c-><c- k="">const</c-> <c- n="">expected</c-><c- o="">&amp;</c-> <c- n="">x</c-><c- p="">,</c-> <c- k="">const</c-> <c- n="">T2</c-><c- o="">&amp;</c-> <c- n="">v</c-><c- p="">);</c->
</pre>
   <p><em>Mandates</em>: The expression <code class="highlight"><c- o="">*</c-><c- n="">x</c-> <c- o="">==</c-> <c- n="">v</c-></code> is well-formed
and its result is convertible to <code class="highlight"><c- b="">bool</c-></code>. [ <em>Note:</em> <code class="highlight"><c- n="">T1</c-></code> need not be <em>Cpp17EqualityComparable</em>. - <em>end note</em>]</p>
   <p><em>Returns</em>: <code class="highlight"><c- n="">x</c-><c- p="">.</c-><c- n="">has_value</c-><c- p="">()</c-> <c- o="">&amp;&amp;</c-> <c- k="">static_cast</c-><c- o="">&lt;</c-><c- b="">bool</c-><c- o="">&gt;</c-><c- p="">(</c-><c- o="">*</c-><c- n="">x</c-> <c- o="">==</c-> <c- n="">v</c-><c- p="">)</c-></code>.</p>
<pre class="language-c++ highlight"><c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">E2</c-><c- o="">&gt;</c-> <c- n="">constexpr</c-> <c- b="">bool</c-> <c- n="">operator</c-><c- o="">==</c-><c- p="">(</c-><c- k="">const</c-> <c- n="">expected</c-><c- o="">&amp;</c-> <c- n="">x</c-><c- p="">,</c-> <c- k="">const</c-> <c- n="">unexpected</c-><c- o="">&lt;</c-><c- n="">E2</c-><c- o="">&gt;&amp;</c-> <c- n="">e</c-><c- p="">);</c->
</pre>
   <p><em>Mandates</em>: The expression <code class="highlight"><c- n="">x</c-><c- p="">.</c-><c- n="">error</c-><c- p="">()</c-> <c- o="">==</c-> <c- n="">e</c-><c- p="">.</c-><c- n="">value</c-><c- p="">()</c-></code> is well-formed and
its result is convertible to <code class="highlight"><c- b="">bool</c-></code>.</p>
   <p><em>Returns</em>: <code class="highlight"><c- o="">!</c-><c- n="">x</c-><c- p="">.</c-><c- n="">has_value</c-><c- p="">()</c-> <c- o="">&amp;&amp;</c-> <c- k="">static_cast</c-><c- o="">&lt;</c-><c- b="">bool</c-><c- o="">&gt;</c-><c- p="">(</c-><c- n="">x</c-><c- p="">.</c-><c- n="">error</c-><c- p="">()</c-> <c- o="">==</c-> <c- n="">e</c-><c- p="">.</c-><c- n="">value</c-><c- p="">())</c-></code>.</p>
   <h3 class="heading settled" data-level="5.14" id="expected.void"><span class="secno">5.14. </span><span class="content">�.�.8 Partial specialization of expected for void types [<em>expected.void</em>]</span><a class="self-link" href="#expected.void"></a></h3>
<pre class="language-c++ highlight"><c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">T</c-><c- p="">,</c-> <c- n="">class</c-> <c- n="">E</c-><c- o="">&gt;</c-> <c- n="">requires</c-> <c- n="">is_void_v</c-><c- o="">&lt;</c-><c- n="">T</c-><c- o="">&gt;</c->
<c- n="">class</c-> <c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-> <c- p="">{</c->
<c- nl="">public</c-><c- p="">:</c->
    <c- n="">using</c-> <c- n="">value_type</c-> <c- o="">=</c-> <c- n="">T</c-><c- p="">;</c->
    <c- n="">using</c-> <c- n="">error_type</c-> <c- o="">=</c-> <c- n="">E</c-><c- p="">;</c->
    <c- n="">using</c-> <c- n="">unexpected_type</c-> <c- o="">=</c-> <c- n="">unexpected</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-><c- p="">;</c->

    <c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">U</c-><c- o="">&gt;</c->
    <c- n="">using</c-> <c- n="">rebind</c-> <c- o="">=</c-> <c- n="">expected</c-><c- o="">&lt;</c-><c- n="">U</c-><c- p="">,</c-> <c- n="">error_type</c-><c- o="">&gt;</c-><c- p="">;</c->

    <c- c1="">// �.�.8.1, constructors</c->
    <c- n="">constexpr</c-> <c- nf="">expected</c-><c- p="">()</c-> <c- n="">noexcept</c-><c- p="">;</c->
    <c- n="">constexpr</c-> <c- nf="">explicit</c-><c- p="">(</c-><c- n="">see</c-> <c- n="">below</c-><c- p="">)</c-> <c- n="">expected</c-><c- p="">(</c-><c- k="">const</c-> <c- n="">expected</c-><c- o="">&amp;</c-><c- p="">);</c->
    <c- n="">constexpr</c-> <c- nf="">explicit</c-><c- p="">(</c-><c- n="">see</c-> <c- n="">below</c-><c- p="">)</c-> <c- n="">expected</c-><c- p="">(</c-><c- n="">expected</c-><c- o="">&amp;&amp;</c-><c- p="">)</c-> <c- n="">noexcept</c-><c- p="">(</c-><c- n="">see</c-> <c- n="">below</c-><c- p="">);</c->
    <c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">U</c-><c- p="">,</c-> <c- n="">class</c-> <c- n="">G</c-><c- o="">&gt;</c->
        <c- n="">constexpr</c-> <c- n="">explicit</c-><c- p="">(</c-><c- n="">see</c-> <c- n="">below</c-><c- p="">)</c-> <c- n="">expected</c-><c- p="">(</c-><c- k="">const</c-> <c- n="">expected</c-><c- o="">&lt;</c-><c- n="">U</c-><c- p="">,</c-> <c- n="">G</c-><c- o="">&gt;&amp;</c-><c- p="">);</c->
    <c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">U</c-><c- p="">,</c-> <c- n="">class</c-> <c- n="">G</c-><c- o="">&gt;</c->
        <c- n="">constexpr</c-> <c- n="">explicit</c-><c- p="">(</c-><c- n="">see</c-> <c- n="">below</c-><c- p="">)</c-> <c- n="">expected</c-><c- p="">(</c-><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">U</c-><c- p="">,</c-> <c- n="">G</c-><c- o="">&gt;&amp;&amp;</c-><c- p="">);</c->

    <c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">G</c-><c- o="">&gt;</c->
        <c- n="">constexpr</c-> <c- n="">expected</c-><c- p="">(</c-><c- k="">const</c-> <c- n="">unexpected</c-><c- o="">&lt;</c-><c- n="">G</c-><c- o="">&gt;&amp;</c-><c- p="">);</c->
    <c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">G</c-><c- o="">&gt;</c->
        <c- n="">constexpr</c-> <c- n="">expected</c-><c- p="">(</c-><c- n="">unexpected</c-><c- o="">&lt;</c-><c- n="">G</c-><c- o="">&gt;&amp;&amp;</c-><c- p="">);</c->

    <c- n="">constexpr</c-> <c- n="">explicit</c-> <c- n="">expected</c-><c- p="">(</c-><c- n="">in_place_t</c-><c- p="">)</c-> <c- n="">noexcept</c-><c- p="">;</c->
    <c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-><c- p="">...</c-> <c- n="">Args</c-><c- o="">&gt;</c->
        <c- n="">constexpr</c-> <c- n="">explicit</c-> <c- n="">expected</c-><c- p="">(</c-><c- n="">unexpect_t</c-><c- p="">,</c-> <c- n="">Args</c-><c- o="">&amp;&amp;</c-><c- p="">...);</c->
    <c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">U</c-><c- p="">,</c-> <c- n="">class</c-><c- p="">...</c-> <c- n="">Args</c-><c- o="">&gt;</c->
        <c- n="">constexpr</c-> <c- n="">explicit</c-> <c- n="">expected</c-><c- p="">(</c-><c- n="">unexpect_t</c-><c- p="">,</c-> <c- n="">initializer_list</c-><c- o="">&lt;</c-><c- n="">U</c-><c- o="">&gt;</c-><c- p="">,</c-> <c- n="">Args</c-><c- o="">&amp;&amp;</c-><c- p="">...);</c->


    <c- c1="">// �.�.8.2, destructor</c->
    <c- n="">constexpr</c-> <c- o="">~</c-><c- n="">expected</c-><c- p="">();</c->

    <c- c1="">// �.�.8.3, assignment</c->
    <c- n="">constexpr</c-> <c- n="">expected</c-><c- o="">&amp;</c-> <c- n="">operator</c-><c- o="">=</c-><c- p="">(</c-><c- k="">const</c-> <c- n="">expected</c-><c- o="">&amp;</c-><c- p="">);</c->
    <c- n="">constexpr</c-> <c- n="">expected</c-><c- o="">&amp;</c-> <c- n="">operator</c-><c- o="">=</c-><c- p="">(</c-><c- n="">expected</c-><c- o="">&amp;&amp;</c-><c- p="">)</c-> <c- n="">noexcept</c-><c- p="">(</c-><c- n="">see</c-> <c- n="">below</c-><c- p="">);</c->
    <c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">G</c-><c- o="">&gt;</c->
        <c- n="">constexpr</c-> <c- n="">expected</c-><c- o="">&amp;</c-> <c- n="">operator</c-><c- o="">=</c-><c- p="">(</c-><c- k="">const</c-> <c- n="">unexpected</c-><c- o="">&lt;</c-><c- n="">G</c-><c- o="">&gt;&amp;</c-><c- p="">);</c->
    <c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">G</c-><c- o="">&gt;</c->
        <c- n="">constexpr</c-> <c- n="">expected</c-><c- o="">&amp;</c-> <c- n="">operator</c-><c- o="">=</c-><c- p="">(</c-><c- n="">unexpected</c-><c- o="">&lt;</c-><c- n="">G</c-><c- o="">&gt;&amp;&amp;</c-><c- p="">);</c->

    <c- c1="">// �.�.8.4, modifiers</c->

    <c- n="">constexpr</c-> <c- b="">void</c-> <c- n="">emplace</c-><c- p="">()</c-> <c- n="">noexcept</c-><c- p="">;</c->

    <c- c1="">// �.�.8.5, swap</c->
    <c- n="">constexpr</c-> <c- b="">void</c-> <c- n="">swap</c-><c- p="">(</c-><c- n="">expected</c-><c- o="">&amp;</c-><c- p="">)</c-> <c- n="">noexcept</c-><c- p="">(</c-><c- n="">see</c-> <c- n="">below</c-><c- p="">);</c->

    <c- c1="">// �.�.8.6, observers</c->
    <c- n="">constexpr</c-> <c- n="">explicit</c-> <c- n="">operator</c-> <c- b="">bool</c-><c- p="">()</c-> <c- k="">const</c-> <c- n="">noexcept</c-><c- p="">;</c->
    <c- n="">constexpr</c-> <c- b="">bool</c-> <c- n="">has_value</c-><c- p="">()</c-> <c- k="">const</c-> <c- n="">noexcept</c-><c- p="">;</c->
    <c- n="">constexpr</c-> <c- b="">void</c-> <c- n="">operator</c-><c- o="">*</c-><c- p="">()</c-> <c- k="">const</c-> <c- n="">noexcept</c-><c- p="">;</c->
    <c- n="">constexpr</c-> <c- b="">void</c-> <c- n="">value</c-><c- p="">()</c-> <c- k="">const</c-><c- o="">&amp;</c-><c- p="">;</c->
    <c- n="">constexpr</c-> <c- b="">void</c-> <c- n="">value</c-><c- p="">()</c-> <c- o="">&amp;&amp;</c-><c- p="">;</c->
    <c- n="">constexpr</c-> <c- k="">const</c-> <c- n="">E</c-><c- o="">&amp;</c-> <c- n="">error</c-><c- p="">()</c-> <c- k="">const</c-><c- o="">&amp;</c-><c- p="">;</c->
    <c- n="">constexpr</c-> <c- n="">E</c-><c- o="">&amp;</c-> <c- n="">error</c-><c- p="">()</c-> <c- o="">&amp;</c-><c- p="">;</c->
    <c- n="">constexpr</c-> <c- k="">const</c-> <c- n="">E</c-><c- o="">&amp;&amp;</c-> <c- n="">error</c-><c- p="">()</c-> <c- k="">const</c-><c- o="">&amp;&amp;</c-><c- p="">;</c->
    <c- n="">constexpr</c-> <c- n="">E</c-><c- o="">&amp;&amp;</c-> <c- n="">error</c-><c- p="">()</c-> <c- o="">&amp;&amp;</c-><c- p="">;</c->

    <c- c1="">// �.�.8.7, Expected equality operators</c->
    <c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">T2</c-><c- p="">,</c-> <c- n="">class</c-> <c- n="">E2</c-><c- o="">&gt;</c-> <c- n="">requires</c-> <c- n="">is_void_v</c-><c- o="">&lt;</c-><c- n="">T2</c-><c- o="">&gt;</c->
        <c- n="">friend</c-> <c- n="">constexpr</c-> <c- b="">bool</c-> <c- n="">operator</c-><c- o="">==</c-><c- p="">(</c-><c- k="">const</c-> <c- n="">expected</c-><c- o="">&amp;</c-> <c- n="">x</c-><c- p="">,</c-> <c- k="">const</c-> <c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T2</c-><c- p="">,</c-> <c- n="">E2</c-><c- o="">&gt;&amp;</c-> <c- n="">y</c-><c- p="">);</c->
    <c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">E2</c-><c- o="">&gt;</c->
        <c- n="">friend</c-> <c- n="">constexpr</c-> <c- b="">bool</c-> <c- n="">operator</c-><c- o="">==</c-><c- p="">(</c-><c- k="">const</c-> <c- n="">expected</c-><c- o="">&amp;</c-><c- p="">,</c-> <c- k="">const</c-> <c- n="">unexpected</c-><c- o="">&lt;</c-><c- n="">E2</c-><c- o="">&gt;&amp;</c-><c- p="">);</c->

    <c- c1="">// �.�.8.10, Specialized algorithms</c->
    <c- n="">friend</c-> <c- n="">constexpr</c-> <c- b="">void</c-> <c- n="">swap</c-><c- p="">(</c-><c- n="">expected</c-><c- o="">&amp;</c-><c- p="">,</c-> <c- n="">expected</c-><c- o="">&amp;</c-><c- p="">)</c-> <c- n="">noexcept</c-><c- p="">(</c-><c- n="">see</c-> <c- n="">below</c-><c- p="">);</c->

<c- nl="">private</c-><c- p="">:</c->
    <c- b="">bool</c-> <c- n="">has_val</c-><c- p="">;</c-> <c- c1="">// exposition only</c->
    <c- k="">union</c->
    <c- p="">{</c->
        <c- n="">E</c-> <c- n="">unex</c-><c- p="">;</c->   <c- c1="">// exposition only</c->
    <c- p="">};</c->
<c- p="">};</c->
</pre>
   <p><code class="highlight"><c- n="">E</c-></code> shall meet the requirements of <code class="highlight"><c- n="">Cpp17Destructible</c-></code> (Table 27).</p>
   <h3 class="heading settled" data-level="5.15" id="expected.void.ctor"><span class="secno">5.15. </span><span class="content">�.�.8.1 Constructors [<em>expected.void.ctor</em>]</span><a class="self-link" href="#expected.void.ctor"></a></h3>
<pre class="language-c++ highlight"><c- n="">constexpr</c-> <c- nf="">expected</c-><c- p="">()</c-> <c- n="">noexcept</c-><c- p="">;</c->
</pre>
   <p><em>Postconditions</em>: <code class="highlight"><c- n="">has_value</c-><c- p="">()</c-></code> is <code class="highlight">true</code>.</p>
<pre class="language-c++ highlight"><c- n="">constexpr</c-> <c- nf="">expected</c-><c- p="">(</c-><c- k="">const</c-> <c- n="">expected</c-><c- o="">&amp;</c-> <c- n="">rhs</c-><c- p="">);</c->
</pre>
   <p><em>Effects</em>: If <code class="highlight"><c- n="">rhs</c-><c- p="">.</c-><c- n="">has_value</c-><c- p="">()</c-></code> is <code class="highlight">false</code>, direct-non-list-initializes <code class="highlight"><c- n="">unex</c-></code> with <code class="highlight"><c- n="">rhs</c-><c- p="">.</c-><c- n="">error</c-><c- p="">()</c-></code>.</p>
   <p><em>Postconditions</em>: <code class="highlight"><c- n="">rhs</c-><c- p="">.</c-><c- n="">has_value</c-><c- p="">()</c-> <c- o="">==</c-> <c- k="">this</c-><c- o="">-&gt;</c-><c- n="">has_value</c-><c- p="">()</c-></code>.</p>
   <p><em>Throws</em>: Any exception thrown by the initialization of <code class="highlight"><c- n="">unex</c-></code>.</p>
   <p><em>Remarks</em>: This constructor is defined as deleted unless <code class="highlight"><c- n="">is_copy_constructible_v</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code>.</p>
   <p>This constructor is trivial if <code class="highlight"><c- n="">is_trivially_copy_constructible_v</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code>.</p>
<pre class="language-c++ highlight"><c- n="">constexpr</c-> <c- nf="">expected</c-><c- p="">(</c-><c- n="">expected</c-><c- o="">&amp;&amp;</c-> <c- n="">rhs</c-><c- p="">)</c-> <c- n="">noexcept</c-><c- p="">(</c-><c- n="">is_nothrow_move_constructible_v</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-><c- p="">);</c->
</pre>
   <p><em>Constraints</em>: <code class="highlight"><c- n="">is_move_constructible_v</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code>.</p>
   <p><em>Effects</em>: If <code class="highlight"><c- n="">rhs</c-><c- p="">.</c-><c- n="">has_value</c-><c- p="">()</c-></code> is <code class="highlight">false</code>, direct-non-list-initializes <code class="highlight"><c- n="">unex</c-></code> with <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">move</c-><c- p="">(</c-><c- n="">rhs</c-><c- p="">.</c-><c- n="">error</c-><c- p="">())</c-></code>.</p>
   <p><em>Postconditions</em>: <code class="highlight"><c- n="">rhs</c-><c- p="">.</c-><c- n="">has_value</c-><c- p="">()</c-></code> is unchanged, <code class="highlight"><c- n="">rhs</c-><c- p="">.</c-><c- n="">has_value</c-><c- p="">()</c-> <c- o="">==</c-> <c- k="">this</c-><c- o="">-&gt;</c-><c- n="">has_value</c-><c- p="">()</c-></code>.</p>
   <p><em>Throws</em>: Any exception thrown by the initialization of <code class="highlight"><c- n="">unex</c-></code>.</p>
   <p><em>Remarks</em>: This constructor is trivial if <code class="highlight"><c- n="">is_trivially_move_constructible_v</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code>.</p>
<pre class="language-c++ highlight"><c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">U</c-><c- p="">,</c-> <c- n="">class</c-> <c- n="">G</c-><c- o="">&gt;</c->
    <c- n="">constexpr</c-> <c- n="">explicit</c-><c- p="">(</c-><c- o="">!</c-><c- n="">is_convertible_v</c-><c- o="">&lt;</c-><c- k="">const</c-> <c- n="">G</c-><c- o="">&amp;</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-><c- p="">)</c-> <c- n="">expected</c-><c- p="">(</c-><c- k="">const</c-> <c- n="">expected</c-><c- o="">&lt;</c-><c- n="">U</c-><c- p="">,</c-> <c- n="">G</c-><c- o="">&gt;&amp;</c-> <c- n="">rhs</c-><c- p="">);</c->
<c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">U</c-><c- p="">,</c-> <c- n="">class</c-> <c- n="">G</c-><c- o="">&gt;</c->
    <c- n="">constexpr</c-> <c- n="">explicit</c-><c- p="">(</c-><c- o="">!</c-><c- n="">is_convertible_v</c-><c- o="">&lt;</c-><c- n="">G</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-><c- p="">)</c-> <c- n="">expected</c-><c- p="">(</c-><c- n="">expected</c-><c- o="">&lt;</c-><c- n="">U</c-><c- p="">,</c-> <c- n="">G</c-><c- o="">&gt;&amp;&amp;</c-> <c- n="">rhs</c-><c- p="">);</c->
</pre>
   <p>Let <code class="highlight"><c- n="">GF</c-></code> be <code class="highlight"><c- k="">const</c-> <c- n="">G</c-><c- o="">&amp;</c-></code> for the first overload and <code class="highlight"><c- n="">G</c-></code> for the second overload.</p>
   <p><em>Constraints</em>:</p>
   <ul>
    <li data-md="">
     <p><code class="highlight"><c- n="">is_void_v</c-><c- o="">&lt;</c-><c- n="">U</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code>; and</p>
    </li><li data-md="">
     <p><code class="highlight"><c- n="">is_constructible_v</c-><c- o="">&lt;</c-><c- n="">E</c-><c- p="">,</c-> <c- n="">GF</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code>; and</p>
    </li><li data-md="">
     <p><code class="highlight"><c- n="">is_constructible_v</c-><c- o="">&lt;</c-><c- n="">unexpected</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-><c- p="">,</c-> <c- n="">expected</c-><c- o="">&lt;</c-><c- n="">U</c-><c- p="">,</c-> <c- n="">G</c-><c- o="">&gt;&amp;&gt;</c-></code> is <code class="highlight">false</code>; and</p>
    </li><li data-md="">
     <p><code class="highlight"><c- n="">is_constructible_v</c-><c- o="">&lt;</c-><c- n="">unexpected</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-><c- p="">,</c-> <c- n="">expected</c-><c- o="">&lt;</c-><c- n="">U</c-><c- p="">,</c-> <c- n="">G</c-><c- o="">&gt;&gt;</c-></code> is <code class="highlight">false</code>; and</p>
    </li><li data-md="">
     <p><code class="highlight"><c- n="">is_constructible_v</c-><c- o="">&lt;</c-><c- n="">unexpected</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-><c- p="">,</c-> <c- k="">const</c-> <c- n="">expected</c-><c- o="">&lt;</c-><c- n="">U</c-><c- p="">,</c-> <c- n="">G</c-><c- o="">&gt;&amp;&gt;</c-></code> is <code class="highlight">false</code>; and</p>
    </li><li data-md="">
     <p><code class="highlight"><c- n="">is_constructible_v</c-><c- o="">&lt;</c-><c- n="">unexpected</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-><c- p="">,</c-> <c- k="">const</c-> <c- n="">expected</c-><c- o="">&lt;</c-><c- n="">U</c-><c- p="">,</c-> <c- n="">G</c-><c- o="">&gt;&gt;</c-></code> is <code class="highlight">false</code>; and</p>
   </li></ul>
   <p><em>Effects</em>: If <code class="highlight"><c- n="">rhs</c-><c- p="">.</c-><c- n="">has_value</c-><c- p="">()</c-></code> is <code class="highlight">false</code>, direct-non-list-initializes <code class="highlight"><c- n="">unex</c-></code> with <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">forward</c-><c- o="">&lt;</c-><c- n="">GF</c-><c- o="">&gt;</c-><c- p="">(</c-><c- n="">rhs</c-><c- p="">.</c-><c- n="">error</c-><c- p="">())</c-></code>.</p>
   <p><em>Postconditions</em>: <code class="highlight"><c- n="">rhs</c-><c- p="">.</c-><c- n="">has_value</c-><c- p="">()</c-></code> is unchanged, <code class="highlight"><c- n="">rhs</c-><c- p="">.</c-><c- n="">has_value</c-><c- p="">()</c-> <c- o="">==</c-> <c- k="">this</c-><c- o="">-&gt;</c-><c- n="">has_value</c-><c- p="">()</c-></code>.</p>
   <p><em>Throws</em>: Any exception thrown by the initialization of <code class="highlight"><c- n="">unex</c-></code>.</p>
<pre class="language-c++ highlight"><c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">G</c-><c- o="">&gt;</c->
    <c- n="">constexpr</c-> <c- n="">explicit</c-><c- p="">(</c-><c- o="">!</c-><c- n="">is_convertible_v</c-><c- o="">&lt;</c-><c- k="">const</c-> <c- n="">G</c-><c- o="">&amp;</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-><c- p="">)</c-> <c- n="">expected</c-><c- p="">(</c-><c- k="">const</c-> <c- n="">unexpected</c-><c- o="">&lt;</c-><c- n="">G</c-><c- o="">&gt;&amp;</c-> <c- n="">e</c-><c- p="">);</c->
<c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">G</c-><c- o="">&gt;</c->
    <c- n="">constexpr</c-> <c- n="">explicit</c-><c- p="">(</c-><c- o="">!</c-><c- n="">is_convertible_v</c-><c- o="">&lt;</c-><c- n="">G</c-><c- p="">,</c-> <c- n="">E</c-><c- o="">&gt;</c-><c- p="">)</c-> <c- n="">expected</c-><c- p="">(</c-><c- n="">unexpected</c-><c- o="">&lt;</c-><c- n="">G</c-><c- o="">&gt;&amp;&amp;</c-> <c- n="">e</c-><c- p="">);</c->
</pre>
   <p>Let <code class="highlight"><c- n="">GF</c-></code> be <code class="highlight"><c- k="">const</c-> <c- n="">G</c-><c- o="">&amp;</c-></code> for the first overload and <code class="highlight"><c- n="">G</c-></code> for the second overload.</p>
   <p><em>Constraints</em>: <code class="highlight"><c- n="">is_constructible_v</c-><c- o="">&lt;</c-><c- n="">E</c-><c- p="">,</c-> <c- n="">GF</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code>.</p>
   <p><em>Effects</em>: Direct-non-list-initializes <code class="highlight"><c- n="">unex</c-></code> with <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">forward</c-><c- o="">&lt;</c-><c- n="">GF</c-><c- o="">&gt;</c-><c- p="">(</c-><c- n="">e</c-><c- p="">.</c-><c- n="">value</c-><c- p="">())</c-></code>.</p>
   <p><em>Postconditions</em>: <code class="highlight"><c- n="">has_value</c-><c- p="">()</c-></code> is <code class="highlight">false</code>.</p>
   <p><em>Throws</em>: Any exception thrown by the initialization of <code class="highlight"><c- n="">unex</c-></code>.</p>
<pre class="language-c++ highlight"><c- n="">constexpr</c-> <c- n="">explicit</c-> <c- n="">expected</c-><c- p="">(</c-><c- n="">in_place_t</c-><c- p="">)</c-> <c- n="">noexcept</c-><c- p="">;</c->
</pre>
   <p><em>Postconditions</em>: <code class="highlight"><c- n="">has_value</c-><c- p="">()</c-></code> is <code class="highlight">true</code>.</p>
<pre class="language-c++ highlight"><c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-><c- p="">...</c-> <c- n="">Args</c-><c- o="">&gt;</c->
    <c- n="">constexpr</c-> <c- n="">explicit</c-> <c- n="">expected</c-><c- p="">(</c-><c- n="">unexpect_t</c-><c- p="">,</c-> <c- n="">Args</c-><c- o="">&amp;&amp;</c-><c- p="">...</c-> <c- n="">args</c-><c- p="">);</c->
</pre>
   <p><em>Constraints</em>: <code class="highlight"><c- n="">is_constructible_v</c-><c- o="">&lt;</c-><c- n="">E</c-><c- p="">,</c-> <c- n="">Args</c-><c- p="">...</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code>.</p>
   <p><em>Effects</em>: Direct-non-list-initializes <code class="highlight"><c- n="">unex</c-></code> with <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">forward</c-><c- o="">&lt;</c-><c- n="">Args</c-><c- o="">&gt;</c-><c- p="">(</c-><c- n="">args</c-><c- p="">)...</c-></code>.</p>
   <p><em>Postconditions</em>: <code class="highlight"><c- n="">has_value</c-><c- p="">()</c-></code> is <code class="highlight">false</code>.</p>
   <p><em>Throws</em>: Any exception thrown by the initialization of <code class="highlight"><c- n="">unex</c-></code>.</p>
<pre class="language-c++ highlight"><c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">U</c-><c- p="">,</c-> <c- n="">class</c-><c- p="">...</c-> <c- n="">Args</c-><c- o="">&gt;</c->
    <c- n="">constexpr</c-> <c- n="">explicit</c-> <c- n="">expected</c-><c- p="">(</c-><c- n="">unexpect_t</c-><c- p="">,</c-> <c- n="">initializer_list</c-><c- o="">&lt;</c-><c- n="">U</c-><c- o="">&gt;</c-> <c- n="">il</c-><c- p="">,</c-> <c- n="">Args</c-><c- o="">&amp;&amp;</c-><c- p="">...</c-> <c- n="">args</c-><c- p="">);</c->
</pre>
   <p><em>Constraints</em>: <code class="highlight"><c- n="">is_constructible_v</c-><c- o="">&lt;</c-><c- n="">E</c-><c- p="">,</c-> <c- n="">initializer_list</c-><c- o="">&lt;</c-><c- n="">U</c-><c- o="">&gt;&amp;</c-><c- p="">,</c-> <c- n="">Args</c-><c- p="">...</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code>.</p>
   <p><em>Effects</em>: Direct-non-list-initializes <code class="highlight"><c- n="">unex</c-></code> with <code class="highlight"><c- n="">il</c-><c- p="">,</c-> <c- n="">std</c-><c- o="">::</c-><c- n="">forward</c-><c- o="">&lt;</c-><c- n="">Args</c-><c- o="">&gt;</c-><c- p="">(</c-><c- n="">args</c-><c- p="">)...</c-></code>.</p>
   <p><em>Postconditions</em>: <code class="highlight"><c- n="">has_value</c-><c- p="">()</c-></code> is <code class="highlight">false</code>.</p>
   <p><em>Throws</em>: Any exception thrown by the initialization of <code class="highlight"><c- n="">unex</c-></code>.</p>
   <h3 class="heading settled" data-level="5.16" id="expected.void.dtor"><span class="secno">5.16. </span><span class="content">�.�.8.2 Destructor [<em>expected.void.dtor</em>]</span><a class="self-link" href="#expected.void.dtor"></a></h3>
<pre class="language-c++ highlight"><c- n="">constexpr</c-> <c- o="">~</c-><c- n="">expected</c-><c- p="">();</c->
</pre>
   <p><em>Effects</em>: If <code class="highlight"><c- n="">has_value</c-><c- p="">()</c-></code> is <code class="highlight">false</code>, destroys <code class="highlight"><c- n="">unex</c-></code>.</p>
   <p><em>Remarks</em>: If <code class="highlight"><c- n="">is_trivially_destructible_v</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code>, then this destructor
is a trivial destructor.</p>
   <h3 class="heading settled" data-level="5.17" id="expected.void.assign"><span class="secno">5.17. </span><span class="content">�.�.8.3 Assignment [<em>expected.void.assign</em>]</span><a class="self-link" href="#expected.void.assign"></a></h3>
<pre class="language-c++ highlight"><c- n="">constexpr</c-> <c- n="">expected</c-><c- o="">&amp;</c-> <c- n="">operator</c-><c- o="">=</c-><c- p="">(</c-><c- k="">const</c-> <c- n="">expected</c-><c- o="">&amp;</c-> <c- n="">rhs</c-><c- p="">);</c->
</pre>
   <p><em>Effects</em>:</p>
   <ul>
    <li data-md="">
     <p>If <code class="highlight"><c- k="">this</c-><c- o="">-&gt;</c-><c- n="">has_value</c-><c- p="">()</c-> <c- o="">&amp;&amp;</c-> <c- n="">rhs</c-><c- p="">.</c-><c- n="">has_value</c-><c- p="">()</c-></code> is <code class="highlight">true</code>, no effects.</p>
    </li><li data-md="">
     <p>Otherwise, if <code class="highlight"><c- k="">this</c-><c- o="">-&gt;</c-><c- n="">has_value</c-><c- p="">()</c-></code> is <code class="highlight">true</code>, equivalent to: <code class="highlight"><c- n="">construct_at</c-><c- p="">(</c-><c- n="">addressof</c-><c- p="">(</c-><c- n="">unex</c-><c- p="">),</c-> <c- n="">rhs</c-><c- p="">.</c-><c- n="">unex</c-><c- p="">);</c-> <c- n="">has_val</c-> <c- o="">=</c-> false<c- p="">;</c-></code></p>
    </li><li data-md="">
     <p>Otherwise, if <code class="highlight"><c- n="">rhs</c-><c- p="">.</c-><c- n="">has_value</c-><c- p="">()</c-></code> is <code class="highlight">true</code>, destroys <code class="highlight"><c- n="">unex</c-></code> and sets <code class="highlight"><c- n="">has_val</c-></code> to <code class="highlight">true</code>.</p>
    </li><li data-md="">
     <p>Otherwise, equivalent to <code class="highlight"><c- n="">unex</c-> <c- o="">=</c-> <c- n="">rhs</c-><c- p="">.</c-><c- n="">error</c-><c- p="">()</c-></code>.</p>
   </li></ul>
   <p><em>Returns</em>: <code class="highlight"><c- o="">*</c-><c- k="">this</c-></code>.</p>
   <p><em>Remarks</em>:
This operator is defined as deleted unless:</p>
   <ul>
    <li data-md="">
     <p><code class="highlight"><c- n="">is_copy_assignable_v</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code> and <code class="highlight"><c- n="">is_copy_constructible_v</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code>.</p>
   </li></ul>
<pre class="language-c++ highlight"><c- n="">constexpr</c-> <c- n="">expected</c-><c- o="">&amp;</c-> <c- n="">operator</c-><c- o="">=</c-><c- p="">(</c-><c- n="">expected</c-><c- o="">&amp;&amp;</c-> <c- n="">rhs</c-><c- p="">)</c-> <c- n="">noexcept</c-><c- p="">(</c-><c- n="">see</c-> <c- n="">below</c-><c- p="">);</c->
</pre>
   <p><em>Effects</em>:</p>
   <ul>
    <li data-md="">
     <p>If <code class="highlight"><c- k="">this</c-><c- o="">-&gt;</c-><c- n="">has_value</c-><c- p="">()</c-> <c- o="">&amp;&amp;</c-> <c- n="">rhs</c-><c- p="">.</c-><c- n="">has_value</c-><c- p="">()</c-></code> is <code class="highlight">true</code>, no effects.</p>
    </li><li data-md="">
     <p>Otherwise, if <code class="highlight"><c- k="">this</c-><c- o="">-&gt;</c-><c- n="">has_value</c-><c- p="">()</c-></code> is <code class="highlight">true</code>, equivalent to: <code class="highlight"><c- n="">construct_at</c-><c- p="">(</c-><c- n="">addressof</c-><c- p="">(</c-><c- n="">unex</c-><c- p="">),</c-> <c- n="">std</c-><c- o="">::</c-><c- n="">move</c-><c- p="">(</c-><c- n="">rhs</c-><c- p="">.</c-><c- n="">unex</c-><c- p="">));</c-> <c- n="">has_val</c-> <c- o="">=</c-> false<c- p="">;</c-></code></p>
    </li><li data-md="">
     <p>Otherwise, if <code class="highlight"><c- n="">rhs</c-><c- p="">.</c-><c- n="">has_value</c-><c- p="">()</c-></code> is <code class="highlight">true</code>, destroys <code class="highlight"><c- n="">unex</c-></code> and sets <code class="highlight"><c- n="">has_val</c-></code> to <code class="highlight">true</code>.</p>
    </li><li data-md="">
     <p>Otherwise, equivalent to <code class="highlight"><c- n="">unex</c-> <c- o="">=</c-> <c- n="">rhs</c-><c- p="">.</c-><c- n="">error</c-><c- p="">()</c-></code>.</p>
   </li></ul>
   <p><em>Returns</em>: <code class="highlight"><c- o="">*</c-><c- k="">this</c-></code>.</p>
   <p><em>Remarks</em>: The exception specification is <code class="highlight"><c- n="">is_nothrow_move_constructible_v</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-> <c- o="">&amp;&amp;</c-> <c- n="">is_nothrow_move_assignable_v</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-></code>.</p>
   <p>This operator is defined as deleted unless:</p>
   <ul>
    <li data-md="">
     <p><code class="highlight"><c- n="">is_move_constructible_v</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code> and <code class="highlight"><c- n="">is_move_assignable_v</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code>.</p>
   </li></ul>
<pre class="language-c++ highlight"><c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">G</c-><c- o="">&gt;</c->
    <c- n="">constexpr</c-> <c- n="">expected</c-><c- o="">&amp;</c-> <c- n="">operator</c-><c- o="">=</c-><c- p="">(</c-><c- k="">const</c-> <c- n="">unexpected</c-><c- o="">&lt;</c-><c- n="">G</c-><c- o="">&gt;&amp;</c-> <c- n="">e</c-><c- p="">);</c->
<c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">G</c-><c- o="">&gt;</c->
    <c- n="">constexpr</c-> <c- n="">expected</c-><c- o="">&amp;</c-> <c- n="">operator</c-><c- o="">=</c-><c- p="">(</c-><c- n="">unexpected</c-><c- o="">&lt;</c-><c- n="">G</c-><c- o="">&gt;&amp;&amp;</c-> <c- n="">e</c-><c- p="">);</c->
</pre>
   <p>Let <code class="highlight"><c- n="">GF</c-></code> be <code class="highlight"><c- k="">const</c-> <c- n="">G</c-><c- o="">&amp;</c-></code> for the first overload and <code class="highlight"><c- n="">G</c-></code> for the second overload.</p>
   <p><em>Constraints</em>: <code class="highlight"><c- n="">is_constructible_v</c-><c- o="">&lt;</c-><c- n="">E</c-><c- p="">,</c-> <c- n="">GF</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code> and <code class="highlight"><c- n="">is_assignable_v</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&amp;</c-><c- p="">,</c-> <c- n="">GF</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code>.</p>
   <p><em>Effects</em>:</p>
   <ul>
    <li data-md="">
     <p>If <code class="highlight"><c- n="">has_value</c-><c- p="">()</c-></code> is <code class="highlight">true</code>, equivalent to: <code class="highlight"><c- n="">construct_at</c-><c- p="">(</c-><c- n="">addressof</c-><c- p="">(</c-><c- n="">unex</c-><c- p="">),</c-> <c- n="">std</c-><c- o="">::</c-><c- n="">forward</c-><c- o="">&lt;</c-><c- n="">GF</c-><c- o="">&gt;</c-><c- p="">(</c-><c- n="">e</c-><c- p="">.</c-><c- n="">value</c-><c- p="">()));</c-> <c- n="">has_val</c-> <c- o="">=</c-> false<c- p="">;</c-> <c- k="">return</c-> <c- o="">*</c-><c- k="">this</c-><c- p="">;</c-></code></p>
    </li><li data-md="">
     <p>Otherwise, equivalent to: <code class="highlight"><c- n="">unex</c-> <c- o="">=</c-> <c- n="">std</c-><c- o="">::</c-><c- n="">forward</c-><c- o="">&lt;</c-><c- n="">GF</c-><c- o="">&gt;</c-><c- p="">(</c-><c- n="">e</c-><c- p="">.</c-><c- n="">value</c-><c- p="">());</c-> <c- k="">return</c-> <c- o="">*</c-><c- k="">this</c-><c- p="">;</c-></code></p>
   </li></ul>
<pre class="language-c++ highlight"><c- n="">constexpr</c-> <c- b="">void</c-> <c- n="">emplace</c-><c- p="">()</c-> <c- n="">noexcept</c-><c- p="">;</c->
</pre>
   <p><em>Effects</em>:
If <code class="highlight"><c- n="">has_value</c-><c- p="">()</c-></code> is <code class="highlight">false</code>, destroys <code class="highlight"><c- n="">unex</c-></code> and sets <code class="highlight"><c- n="">has_val</c-></code> to <code class="highlight">true</code>.</p>
   <h3 class="heading settled" data-level="5.18" id="expected.void.swap"><span class="secno">5.18. </span><span class="content">�.�.8.4 Swap [<em>expected.void.swap</em>]</span><a class="self-link" href="#expected.void.swap"></a></h3>
<pre class="language-c++ highlight"><c- n="">constexpr</c-> <c- b="">void</c-> <c- n="">swap</c-><c- p="">(</c-><c- n="">expected</c-><c- o="">&amp;</c-> <c- n="">rhs</c-><c- p="">)</c-> <c- n="">noexcept</c-><c- p="">(</c-><c- n="">see</c-> <c- n="">below</c-><c- p="">);</c->
</pre>
   <p><em>Constraints</em>: <code class="highlight"><c- n="">is_swappable_v</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code>; and <code class="highlight"><c- n="">is_move_constructible_v</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-></code> is <code class="highlight">true</code>.</p>
   <p><em>Effects</em>: See Table <em>editor-please-pick-a-number-5</em></p>
   <table>
    <caption>Table <em>editor-please-pick-a-number-5</em> — <code class="highlight"><c- n="">swap</c-><c- p="">(</c-><c- n="">expected</c-><c- o="">&amp;</c-><c- p="">)</c-></code> effects</caption>
    <tbody>
     <tr>
      <td>
      </td><td><code class="highlight"><c- n="">has_value</c-><c- p="">()</c-></code>
      </td><td><code class="highlight"><c- o="">!</c-><c- n="">has_value</c-><c- p="">()</c-></code>
     </td></tr><tr>
      <td><code class="highlight"><c- n="">rhs</c-><c- p="">.</c-><c- n="">has_value</c-><c- p="">()</c-></code>
      </td><td>no effects
      </td><td>calls <code class="highlight"><c- n="">rhs</c-><c- p="">.</c-><c- n="">swap</c-><c- p="">(</c-><c- o="">*</c-><c- k="">this</c-><c- p="">)</c-></code>
     </td></tr><tr>
      <td><code class="highlight"><c- o="">!</c-><c- n="">rhs</c-><c- p="">.</c-><c- n="">has_value</c-><c- p="">()</c-></code>
      </td><td> See below <sup>†</sup>. 
      </td><td>equivalent to: <code class="highlight"><c- k="">using</c-> <c- n="">std</c-><c- o="">::</c-><c- n="">swap</c-><c- p="">;</c-> <c- n="">swap</c-><c- p="">(</c-><c- n="">unex</c-><c- p="">,</c-> <c- n="">rhs</c-><c- p="">.</c-><c- n="">unex</c-><c- p="">);</c-></code>
   </td></tr></tbody></table>
   <p><sup>†</sup> For the case where <code class="highlight"><c- n="">rhs</c-><c- p="">.</c-><c- n="">value</c-><c- p="">()</c-></code> is <code class="highlight">false</code> and <code class="highlight"><c- k="">this</c-><c- o="">-&gt;</c-><c- n="">has_value</c-><c- p="">()</c-></code> is <code class="highlight">true</code>, equivalent to:</p>
<pre class="highlight"><c- n="">construct_at</c-><c- p="">(</c-><c- n="">addressof</c-><c- p="">(</c-><c- n="">unex</c-><c- p="">),</c-> <c- n="">std</c-><c- o="">::</c-><c- n="">move</c-><c- p="">(</c-><c- n="">rhs</c-><c- p="">.</c-><c- n="">unex</c-><c- p="">));</c->
<c- n="">destroy_at</c-><c- p="">(</c-><c- n="">addressof</c-><c- p="">(</c-><c- n="">rhs</c-><c- p="">.</c-><c- n="">unex</c-><c- p="">));</c->
<c- n="">has_val</c-> <c- o="">=</c-> false<c- p="">;</c->
<c- n="">rhs</c-><c- p="">.</c-><c- n="">has_val</c-> <c- o="">=</c-> true<c- p="">;</c->
</pre>
   <p><em>Throws</em>: Any exception thrown by the expressions in the <em>Effects</em>.</p>
   <p><em>Remarks</em>: The exception specification is <code class="highlight"><c- n="">is_nothrow_move_constructible_v</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-> <c- o="">&amp;&amp;</c-> <c- n="">is_nothrow_swappable_v</c-><c- o="">&lt;</c-><c- n="">E</c-><c- o="">&gt;</c-></code>.</p>
<pre class="language-c++ highlight"><c- n="">friend</c-> <c- n="">constexpr</c-> <c- b="">void</c-> <c- n="">swap</c-><c- p="">(</c-><c- n="">expected</c-><c- o="">&amp;</c-> <c- n="">x</c-><c- p="">,</c-> <c- n="">expected</c-><c- o="">&amp;</c-> <c- n="">y</c-><c- p="">)</c-> <c- n="">noexcept</c-><c- p="">(</c-><c- n="">noexcept</c-><c- p="">(</c-><c- n="">x</c-><c- p="">.</c-><c- n="">swap</c-><c- p="">(</c-><c- n="">y</c-><c- p="">)));</c->
</pre>
   <p><em>Effects</em>: Equivalent to <code class="highlight"><c- n="">x</c-><c- p="">.</c-><c- n="">swap</c-><c- p="">(</c-><c- n="">y</c-><c- p="">)</c-></code>.</p>
   <h3 class="heading settled" data-level="5.19" id="expected.void.observe"><span class="secno">5.19. </span><span class="content">�.�.8.5 Observers [<em>expected.void.observe</em>]</span><a class="self-link" href="#expected.void.observe"></a></h3>
<pre class="language-c++ highlight"><c- n="">constexpr</c-> <c- n="">explicit</c-> <c- n="">operator</c-> <c- b="">bool</c-><c- p="">()</c-> <c- k="">const</c-> <c- n="">noexcept</c-><c- p="">;</c->
<c- n="">constexpr</c-> <c- b="">bool</c-> <c- n="">has_value</c-><c- p="">()</c-> <c- k="">const</c-> <c- n="">noexcept</c-><c- p="">;</c->
</pre>
   <p><em>Returns</em>: <code class="highlight"><c- n="">has_val</c-></code>.</p>
<pre class="language-c++ highlight"><c- n="">constexpr</c-> <c- b="">void</c-> <c- n="">operator</c-><c- o="">*</c-><c- p="">()</c-> <c- k="">const</c-> <c- n="">noexcept</c-><c- p="">;</c->
</pre>
   <p><em>Preconditions</em>: <code class="highlight"><c- n="">has_value</c-><c- p="">()</c-></code> is <code class="highlight">true</code>.</p>
<pre class="language-c++ highlight"><c- n="">constexpr</c-> <c- b="">void</c-> <c- n="">value</c-><c- p="">()</c-> <c- k="">const</c-><c- o="">&amp;</c-><c- p="">;</c->
</pre>
   <p><em>Throws</em>: <code class="highlight"><c- n="">bad_expected_access</c-><c- p="">(</c-><c- n="">error</c-><c- p="">())</c-></code> if <code class="highlight"><c- n="">has_value</c-><c- p="">()</c-></code> is <code class="highlight">false</code>.</p>
<pre class="language-c++ highlight"><c- n="">constexpr</c-> <c- b="">void</c-> <c- n="">value</c-><c- p="">()</c-> <c- o="">&amp;&amp;</c-><c- p="">;</c->
</pre>
   <p><em>Throws</em>: <code class="highlight"><c- n="">bad_expected_access</c-><c- p="">(</c-><c- n="">std</c-><c- o="">::</c-><c- n="">move</c-><c- p="">(</c-><c- n="">error</c-><c- p="">()))</c-></code> if <code class="highlight"><c- n="">has_value</c-><c- p="">()</c-></code> is <code class="highlight">false</code>.</p>
<pre class="language-c++ highlight"><c- n="">constexpr</c-> <c- k="">const</c-> <c- n="">E</c-><c- o="">&amp;</c-> <c- n="">error</c-><c- p="">()</c-> <c- k="">const</c-><c- o="">&amp;</c-><c- p="">;</c->
<c- n="">constexpr</c-> <c- n="">E</c-><c- o="">&amp;</c-> <c- n="">error</c-><c- p="">()</c-> <c- o="">&amp;</c-><c- p="">;</c->
</pre>
   <p><em>Preconditions</em>: <code class="highlight"><c- n="">has_value</c-><c- p="">()</c-></code> is <code class="highlight">false</code>.</p>
   <p><em>Returns</em>: <code class="highlight"><c- n="">unex</c-></code>.</p>
<pre class="language-c++ highlight"><c- n="">constexpr</c-> <c- n="">E</c-><c- o="">&amp;&amp;</c-> <c- n="">error</c-><c- p="">()</c-> <c- o="">&amp;&amp;</c-><c- p="">;</c->
<c- n="">constexpr</c-> <c- k="">const</c-> <c- n="">E</c-><c- o="">&amp;&amp;</c-> <c- n="">error</c-><c- p="">()</c-> <c- k="">const</c-><c- o="">&amp;&amp;</c-><c- p="">;</c->
</pre>
   <p><em>Preconditions</em>: <code class="highlight"><c- n="">has_value</c-><c- p="">()</c-></code> is <code class="highlight">false</code>.</p>
   <p><em>Returns</em>: <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">move</c-><c- p="">(</c-><c- n="">unex</c-><c- p="">)</c-></code>.</p>
   <h3 class="heading settled" data-level="5.20" id="expected.void.eq"><span class="secno">5.20. </span><span class="content">�.�.8.6 Expected Equality operators [<em>expected.void.eq</em>]</span><a class="self-link" href="#expected.void.eq"></a></h3>
<pre class="language-c++ highlight"><c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">T2</c-><c- p="">,</c-> <c- n="">class</c-> <c- n="">E2</c-><c- o="">&gt;</c->
    <c- n="">requires</c-> <c- n="">is_void_v</c-><c- o="">&lt;</c-><c- n="">T2</c-><c- o="">&gt;</c->
    <c- n="">friend</c-> <c- n="">constexpr</c-> <c- b="">bool</c-> <c- n="">operator</c-><c- o="">==</c-><c- p="">(</c-><c- k="">const</c-> <c- n="">expected</c-><c- o="">&amp;</c-> <c- n="">x</c-><c- p="">,</c-> <c- k="">const</c-> <c- n="">expected</c-><c- o="">&lt;</c-><c- n="">T2</c-><c- p="">,</c-> <c- n="">E2</c-><c- o="">&gt;&amp;</c-> <c- n="">y</c-><c- p="">);</c->
</pre>
   <p><em>Mandates</em>: The expression <code class="highlight"><c- n="">x</c-><c- p="">.</c-><c- n="">error</c-><c- p="">()</c-> <c- o="">==</c-> <c- n="">y</c-><c- p="">.</c-><c- n="">error</c-><c- p="">()</c-></code> is well-formed and its result
is convertible to <code class="highlight"><c- b="">bool</c-></code>.</p>
   <p><em>Returns</em>:
If <code class="highlight"><c- n="">x</c-><c- p="">.</c-><c- n="">has_value</c-><c- p="">()</c-></code> does not equal <code class="highlight"><c- n="">y</c-><c- p="">.</c-><c- n="">has_value</c-><c- p="">()</c-></code>, <code class="highlight">false</code>;
otherwise <code class="highlight"><c- n="">x</c-><c- p="">.</c-><c- n="">has_value</c-><c- p="">()</c-> <c- o="">||</c-> <c- k="">static_cast</c-><c- o="">&lt;</c-><c- b="">bool</c-><c- o="">&gt;</c-><c- p="">(</c-><c- n="">x</c-><c- p="">.</c-><c- n="">error</c-><c- p="">()</c-> <c- o="">==</c-> <c- n="">y</c-><c- p="">.</c-><c- n="">error</c-><c- p="">())</c-></code>.</p>
<pre class="language-c++ highlight"><c- n="">template</c-><c- o="">&lt;</c-><c- n="">class</c-> <c- n="">E2</c-><c- o="">&gt;</c->
    <c- n="">constexpr</c-> <c- b="">bool</c-> <c- n="">operator</c-><c- o="">==</c-><c- p="">(</c-><c- k="">const</c-> <c- n="">expected</c-><c- o="">&amp;</c-> <c- n="">x</c-><c- p="">,</c-> <c- k="">const</c-> <c- n="">unexpected</c-><c- o="">&lt;</c-><c- n="">E2</c-><c- o="">&gt;&amp;</c-> <c- n="">e</c-><c- p="">);</c->
</pre>
   <p><em>Mandates</em>: The expression <code class="highlight"><c- n="">x</c-><c- p="">.</c-><c- n="">error</c-><c- p="">()</c-> <c- o="">==</c-> <c- n="">e</c-><c- p="">.</c-><c- n="">value</c-><c- p="">()</c-></code> is well-formed and
its result is convertible to <code class="highlight"><c- b="">bool</c-></code>.</p>
   <p><em>Returns</em>: <code class="highlight"><c- o="">!</c-><c- n="">x</c-><c- p="">.</c-><c- n="">has_value</c-><c- p="">()</c-> <c- o="">&amp;&amp;</c-> <c- k="">static_cast</c-><c- o="">&lt;</c-><c- b="">bool</c-><c- o="">&gt;</c-><c- p="">(</c-><c- n="">x</c-><c- p="">.</c-><c- n="">error</c-><c- p="">()</c-> <c- o="">==</c-> <c- n="">e</c-><c- p="">.</c-><c- n="">value</c-><c- p="">())</c-></code>.</p>
   <h3 class="heading settled" data-level="5.21" id="zombie.names"><span class="secno">5.21. </span><span class="content">16.4.5.3.2 Zombie names [<em>zombie.names</em>]</span><a class="self-link" href="#zombie.names"></a></h3>
   <p>Remove <code class="highlight"><c- n="">unexpected</c-></code> from the list of zombie names as follows:</p>
   <blockquote>
     In namespace <code class="highlight"><c- n="">std</c-></code>, the following names are reserved for previous standardization: 
    <ul>
     <li>[...], 
     </li><li><code class="highlight"><c- n="">undeclare_no_pointers</c-></code>, 
     </li><li>
      <code class="highlight"><c- n="">undeclare_reachable</c-></code>,
      <ins> and</ins>
     </li><li>
      <del><code class="highlight"><c- n="">unexpected</c-></code>, and</del>
     </li><li><code class="highlight"><c- n="">unexpected_handler</c-></code>. 
    </li></ul>
   </blockquote>
   <h2 class="heading settled" data-level="6" id="use"><span class="secno">6. </span><span class="content">Implementation &amp; Usage Experience</span><a class="self-link" href="#use"></a></h2>
   <p>There are multiple implementations of <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">expected</c-></code>
 as specified in this paper, listed below. There are also many 
implementations which are similar but not the same as specified in this 
paper, they are not listed below.</p>
   <h3 class="heading settled" data-level="6.1" id="💜"><span class="secno">6.1. </span><span class="content">Sy Brand</span><a class="self-link" href="#💜"></a></h3>
   <p>By far the most popular implementation is Sy Brand’s, with over 500 stars on GitHub and extensive usage.</p>
   <ul>
    <li>Code: <a href="https://github.com/TartanLlama/expected">https://github.com/TartanLlama/expected</a> 
    </li><li>
     Non comprehensive usage list: 
     <ul>
      <li>Telegram desktop client 
      </li><li>Ceph distributed storage system 
      </li><li>FiveM and RedM mod frameworks 
      </li><li>Rspamd spam filtering system 
      </li><li>OTTO hardware synth 
      </li><li>Some NIST project 
      </li><li>about 10 cryptocurrency projects 
     </li></ul>
    </li><li>
     Testimonials: 
     <ul>
      <li>
       <a href="https://twitter.com/syoyo/status/1328196033545814016">https://twitter.com/syoyo/status/1328196033545814016</a> 
       <blockquote>Ultra super 
cooooooooooooooooooooooooooooooooopooool!!!!! 
🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🎉🙏🙏🙏🙏🙏🙏🙏🙏🙏☺️☺️☺️☺️☺️☺️☺️☺️🥰🥰🥰🥰🥰🥰🥰😍😍😍😍😍😍😍😍😍
 C++11/14/17 std::expected with functional-style extensions</blockquote>
      </li><li>
       <a href="https://twitter.com/LesleyLai6/status/1328199023786770432">https://twitter.com/LesleyLai6/status/1328199023786770432</a> 
       <blockquote>I use @TartanLlama 's optional and expected libraries for almost all of my projects. Thay are amazing!<br>Though I made a custom fork and added a few rust Rusult like features.</blockquote>
      </li><li>
       <a href="https://twitter.com/bjorn_fahller/status/1229803982685638656">https://twitter.com/bjorn_fahller/status/1229803982685638656</a> 
       <blockquote>I used tl::expected&lt;&gt; and a few higher order functions to extend functionality with 1/3 code size ;-)</blockquote>
      </li><li>
       <a href="https://twitter.com/toffiloff/status/1101559543631351808">https://twitter.com/toffiloff/status/1101559543631351808</a> 
       <blockquote>Also, using @TartanLlama’s ‘expected’ library has 
done wonders for properly handling error cases on bare metal systems 
without exceptions enabled</blockquote>
      </li><li>
       <a href="https://twitter.com/chsiedentop/status/1296624103080640513">https://twitter.com/chsiedentop/status/1296624103080640513</a> 
       <blockquote>I can really recommend the tl::expected library which has this 😉. BTW, great library, @TartanLlama!</blockquote>
     </li></ul>
   </li></ul>
   <h3 class="heading settled" data-level="6.2" id="viboes"><span class="secno">6.2. </span><span class="content">Vicente J. Botet Escriba</span><a class="self-link" href="#viboes"></a></h3>
   <p>The original author of <code class="highlight"><c- n="">std</c-><c- o="">::</c-><c- n="">expected</c-></code> has an implementation available:</p>
   <ul>
    <li data-md="">
     <p>Code: <a href="https://github.com/viboes/std-make/blob/master/include/experimental/fundamental/v3/expected2/expected.hpp">https://github.com/viboes/std-make/blob/master/include/experimental/fundamental/v3/expected2/expected.hpp</a></p>
   </li></ul>
   <h3 class="heading settled" data-level="6.3" id="🕸🐈"><span class="secno">6.3. </span><span class="content">WebKit</span><a class="self-link" href="#🕸🐈"></a></h3>
   <p>The WebKit web browser (used in Safari) contains an implementation that’s used throughout its codebase.</p>
   <ul>
    <li data-md="">
     <p>Code: <a href="https://github.com/WebKit/WebKit/blob/main/Source/WTF/wtf/Expected.h">https://github.com/WebKit/WebKit/blob/main/Source/WTF/wtf/Expected.h</a></p>
   </li></ul>
  </main>
<script>
(function() {
  "use strict";
  var collapseSidebarText = '<span aria-hidden="true">←</span> '
                          + '<span>Collapse Sidebar</span>';
  var expandSidebarText   = '<span aria-hidden="true">→</span> '
                          + '<span>Pop Out Sidebar</span>';
  var tocJumpText         = '<span aria-hidden="true">↑</span> '
                          + '<span>Jump to Table of Contents</span>';

  var sidebarMedia = window.matchMedia('screen and (min-width: 78em)');
  var autoToggle   = function(e){ toggleSidebar(e.matches) };
  if(sidebarMedia.addListener) {
    sidebarMedia.addListener(autoToggle);
  }

  function toggleSidebar(on) {
    if (on == undefined) {
      on = !document.body.classList.contains('toc-sidebar');
    }

    /* Don’t scroll to compensate for the ToC if we’re above it already. */
    var headY = 0;
    var head = document.querySelector('.head');
    if (head) {
      // terrible approx of "top of ToC"
      headY += head.offsetTop + head.offsetHeight;
    }
    var skipScroll = window.scrollY < headY;

    var toggle = document.getElementById('toc-toggle');
    var tocNav = document.getElementById('toc');
    if (on) {
      var tocHeight = tocNav.offsetHeight;
      document.body.classList.add('toc-sidebar');
      document.body.classList.remove('toc-inline');
      toggle.innerHTML = collapseSidebarText;
      if (!skipScroll) {
        window.scrollBy(0, 0 - tocHeight);
      }
      tocNav.focus();
      sidebarMedia.addListener(autoToggle); // auto-collapse when out of room
    }
    else {
      document.body.classList.add('toc-inline');
      document.body.classList.remove('toc-sidebar');
      toggle.innerHTML = expandSidebarText;
      if (!skipScroll) {
        window.scrollBy(0, tocNav.offsetHeight);
      }
      if (toggle.matches(':hover')) {
        /* Unfocus button when not using keyboard navigation,
           because I don’t know where else to send the focus. */
        toggle.blur();
      }
    }
  }

  function createSidebarToggle() {
    /* Create the sidebar toggle in JS; it shouldn’t exist when JS is off. */
    var toggle = document.createElement('a');
      /* This should probably be a button, but appearance isn’t standards-track.*/
    toggle.id = 'toc-toggle';
    toggle.class = 'toc-toggle';
    toggle.href = '#toc';
    toggle.innerHTML = collapseSidebarText;

    sidebarMedia.addListener(autoToggle);
    var toggler = function(e) {
      e.preventDefault();
      sidebarMedia.removeListener(autoToggle); // persist explicit off states
      toggleSidebar();
      return false;
    }
    toggle.addEventListener('click', toggler, false);


    /* Get <nav id=toc-nav>, or make it if we don’t have one. */
    var tocNav = document.getElementById('toc-nav');
    if (!tocNav) {
      tocNav = document.createElement('p');
      tocNav.id = 'toc-nav';
      /* Prepend for better keyboard navigation */
      document.body.insertBefore(tocNav, document.body.firstChild);
    }
    /* While we’re at it, make sure we have a Jump to Toc link. */
    var tocJump = document.getElementById('toc-jump');
    if (!tocJump) {
      tocJump = document.createElement('a');
      tocJump.id = 'toc-jump';
      tocJump.href = '#toc';
      tocJump.innerHTML = tocJumpText;
      tocNav.appendChild(tocJump);
    }

    tocNav.appendChild(toggle);
  }

  var toc = document.getElementById('toc');
  if (toc) {
    createSidebarToggle();
    toggleSidebar(sidebarMedia.matches);

    /* If the sidebar has been manually opened and is currently overlaying the text
       (window too small for the MQ to add the margin to body),
       then auto-close the sidebar once you click on something in there. */
    toc.addEventListener('click', function(e) {
      if(e.target.tagName.toLowerCase() == "a" && document.body.classList.contains('toc-sidebar') && !sidebarMedia.matches) {
        toggleSidebar(false);
      }
    }, false);
  }
  else {
    console.warn("Can’t find Table of Contents. Please use <nav id='toc'> around the ToC.");
  }

  /* Wrap tables in case they overflow */
  var tables = document.querySelectorAll(':not(.overlarge) > table.data, :not(.overlarge) > table.index');
  var numTables = tables.length;
  for (var i = 0; i < numTables; i++) {
    var table = tables[i];
    var wrapper = document.createElement('div');
    wrapper.className = 'overlarge';
    table.parentNode.insertBefore(wrapper, table);
    wrapper.appendChild(table);
  }

})();
</script>
  <h2 class="no-num no-ref heading settled" id="references"><span class="content">References</span><a class="self-link" href="#references"></a></h2>
  <h3 class="no-num no-ref heading settled" id="informative"><span class="content">Informative References</span><a class="self-link" href="#informative"></a></h3>
  <dl>
   <dt id="biblio-n3527">[N3527]
   </dt><dd>F. Cacciola, A. Krzemieński. <a href="https://wg21.link/n3527"><cite>A proposal to add a utility class to represent optional objects (Revision 2)</cite></a>. 10 March 2013. URL: <a href="https://wg21.link/n3527">https://wg21.link/n3527</a>
   </dd><dt id="biblio-n3672">[N3672]
   </dt><dd>F. Cacciola, A. Krzemieński. <a href="https://wg21.link/n3672"><cite>A proposal to add a utility class to represent optional objects (Revision 4)</cite></a>. 19 April 2013. URL: <a href="https://wg21.link/n3672">https://wg21.link/n3672</a>
   </dd><dt id="biblio-n3793">[N3793]
   </dt><dd>F. Cacciola, A. Krzemieński. <a href="https://wg21.link/n3793"><cite>A proposal to add a utility class to represent optional objects (Revision 5)</cite></a>. 3 October 2013. URL: <a href="https://wg21.link/n3793">https://wg21.link/n3793</a>
   </dd><dt id="biblio-n4015">[N4015]
   </dt><dd>V. Escriba, P. Talbot. <a href="https://wg21.link/n4015"><cite>A proposal to add a utility class to represent expected monad</cite></a>. 26 May 2014. URL: <a href="https://wg21.link/n4015">https://wg21.link/n4015</a>
   </dd><dt id="biblio-n4109">[N4109]
   </dt><dd>V. Escriba, P. Talbot. <a href="https://wg21.link/n4109"><cite>A proposal to add a utility class to represent expected monad - Revision 1</cite></a>. 29 June 2014. URL: <a href="https://wg21.link/n4109">https://wg21.link/n4109</a>
   </dd><dt id="biblio-p0032r2">[P0032R2]
   </dt><dd>Vicente J. Botet Escriba. <a href="https://wg21.link/p0032r2"><cite>Homogeneous interface for variant, any and optional (Revision 2)</cite></a>. 13 March 2016. URL: <a href="https://wg21.link/p0032r2">https://wg21.link/p0032r2</a>
   </dd><dt id="biblio-p0110r0">[P0110R0]
   </dt><dd>Anthony Williams. <a href="https://wg21.link/p0110r0"><cite>Implementing the strong guarantee for variant&lt;&gt; assignment</cite></a>. 25 September 2015. URL: <a href="https://wg21.link/p0110r0">https://wg21.link/p0110r0</a>
   </dd><dt id="biblio-p0157r0">[P0157R0]
   </dt><dd>Lawrence Crowl. <a href="https://wg21.link/p0157r0"><cite>Handling Disappointment in C++</cite></a>. 7 November 2015. URL: <a href="https://wg21.link/p0157r0">https://wg21.link/p0157r0</a>
   </dd><dt id="biblio-p0262r1">[P0262r1]
   </dt><dd>Lawrence Crowl, Chris Mysen. <a href="https://wg21.link/p0262r1"><cite>A Class for Status and Optional Value</cite></a>. 15 October 2016. URL: <a href="https://wg21.link/p0262r1">https://wg21.link/p0262r1</a>
   </dd><dt id="biblio-p0323r10">[P0323r10]
   </dt><dd>JF Bastien, Vicente Botet. <a href="https://wg21.link/p0323r10"><cite>std::expected</cite></a>. 15 April 2021. URL: <a href="https://wg21.link/p0323r10">https://wg21.link/p0323r10</a>
   </dd><dt id="biblio-p0323r2">[P0323R2]
   </dt><dd>Vicente J. Botet Escriba. <a href="https://wg21.link/p0323r2"><cite>A proposal to add a utility class to represent expected object (Revision 4)</cite></a>. 15 June 2017. URL: <a href="https://wg21.link/p0323r2">https://wg21.link/p0323r2</a>
   </dd><dt id="biblio-p0323r3">[P0323r3]
   </dt><dd>Vicente J. Botet Escriba. <a href="https://wg21.link/p0323r3"><cite>Utility class to represent expected object</cite></a>. 15 October 2017. URL: <a href="https://wg21.link/p0323r3">https://wg21.link/p0323r3</a>
   </dd><dt id="biblio-p0323r9">[P0323r9]
   </dt><dd>JF Bastien, Vicente Botet. <a href="https://wg21.link/p0323r9"><cite>std::expected</cite></a>. 3 August 2019. URL: <a href="https://wg21.link/p0323r9">https://wg21.link/p0323r9</a>
   </dd><dt id="biblio-p0343r1">[P0343r1]
   </dt><dd>Vicente J. Botet Escriba. <a href="https://wg21.link/p0343r1"><cite>Meta-programming High-Order Functions</cite></a>. 15 June 2017. URL: <a href="https://wg21.link/p0343r1">https://wg21.link/p0343r1</a>
   </dd><dt id="biblio-p0650r0">[P0650R0]
   </dt><dd>Vicente J. Botet Escriba. <a href="https://wg21.link/p0650r0"><cite>C++ Monadic interface</cite></a>. 15 June 2017. URL: <a href="https://wg21.link/p0650r0">https://wg21.link/p0650r0</a>
   </dd><dt id="biblio-p0650r2">[P0650r2]
   </dt><dd>Vicente J. Botet Escribá. <a href="https://wg21.link/p0650r2"><cite>C++ Monadic interface</cite></a>. 11 February 2018. URL: <a href="https://wg21.link/p0650r2">https://wg21.link/p0650r2</a>
   </dd><dt id="biblio-p0709r4">[P0709r4]
   </dt><dd>Herb Sutter. <a href="https://wg21.link/p0709r4"><cite>Zero-overhead deterministic exceptions: Throwing values</cite></a>. 4 August 2019. URL: <a href="https://wg21.link/p0709r4">https://wg21.link/p0709r4</a>
   </dd><dt id="biblio-p0762r0">[P0762r0]
   </dt><dd>Niall Douglas. <a href="https://wg21.link/p0762r0"><cite>Concerns about expected&lt;T, E&gt; from the Boost.Outcome peer review</cite></a>. 15 October 2017. URL: <a href="https://wg21.link/p0762r0">https://wg21.link/p0762r0</a>
   </dd><dt id="biblio-p0786r0">[P0786R0]
   </dt><dd>Vicente J. Botet Escriba. <a href="https://wg21.link/p0786r0"><cite>SuccessOrFailure, ValuedOrError and ValuedOrNone types</cite></a>. 15 October 2017. URL: <a href="https://wg21.link/p0786r0">https://wg21.link/p0786r0</a>
   </dd><dt id="biblio-p1028r3">[P1028R3]
   </dt><dd>Niall Douglas. <a href="https://wg21.link/p1028r3"><cite>SG14 status_code and standard error object</cite></a>. 12 January 2020. URL: <a href="https://wg21.link/p1028r3">https://wg21.link/p1028r3</a>
   </dd><dt id="biblio-p1051r0">[P1051r0]
   </dt><dd>Vicente J. Botet Escribá. <a href="https://wg21.link/p1051r0"><cite>std::experimental::expected LWG design issues</cite></a>. 3 May 2018. URL: <a href="https://wg21.link/p1051r0">https://wg21.link/p1051r0</a>
   </dd><dt id="biblio-p1095r0">[P1095r0]
   </dt><dd>Niall Douglas. <a href="https://wg21.link/p1095r0"><cite>Zero overhead deterministic failure - A unified mechanism for C and C++</cite></a>. 29 August 2018. URL: <a href="https://wg21.link/p1095r0">https://wg21.link/p1095r0</a>
  </dd></dl></body></html>