<!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>P0323R10: 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
 *
 * 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)
 *   - .assertion  for assertions                    (div, p, span)
 *   - .advisement for loud normative statements     (div, p, strong)
 *   - .annoying-warning for spec obsoletion notices (div, aside, details)
 *
 * 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
 *
 * 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 {
		color: black;
		color: var(--text);
		background-color: white;
		background-color: var(--bg);
	}

	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;

		background: transparent 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: 2;
			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,
	#subtitle {
		/* #subtitle 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: medium;
	}
	dfn var {
		font-style: normal;
	}

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

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

/** 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: none;
		border-bottom: 1px solid #707070;
		border-bottom: 1px solid var(--a-normal-underline);
		/* Need a bit of extending for it to look okay */
		padding: 0 1px 0;
		margin: 0 -1px 0;
	}
	a:visited {
		color: #034575;
		color: var(--a-visited-text);
		border-bottom-color: #bbb;
		border-bottom-color: var(--a-visited-underline);
	}

	/* Use distinguishing colors when user is interacting with the link */
	a[href]:focus,
	a[href]:hover {
		background: #f8f8f8;
		background: rgba(75%, 75%, 75%, .25);
		background: var(--a-hover-bg);
		border-bottom-width: 3px;
		margin-bottom: -2px;
	}
	a[href]:active {
		color: #c00;
		color: var(--a-active-text);
		border-color: #c00;
		border-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 {
		padding: .5em;
		border: .5em;
		border-left-style: solid;
		page-break-inside: avoid;
	}
	span.issue, span.note {
		padding: .1em .5em .15em;
		border-right-style: solid;
	}

	.issue,
	.note,
	.example,
	.advisement,
	.assertion,
	blockquote {
		margin: 1em auto;
	}
	.note  > p:first-child,
	.issue > p:first-child,
	blockquote > :first-child {
		margin-top: 0;
	}
	blockquote > :last-child {
		margin-bottom: 0;
	}


	.issue::before, .issue > .marker,
	.example::before, .example > .marker,
	.note::before, .note > .marker,
	details.note > 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);
	}

/** 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-top: 0.1rem;
		/* Larger, more consistently-sized click target */
		display: block;
		/* 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: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;
		line-height: 1.1rem; /* consistent spacing */
	}

	/* 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 .secno { font-size: 85%; }
	.toc > li li li li li { font-size:   85%;    }
	.toc > li li li li li .secno { font-size: 100%; }

	/* @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 {
			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;
	}

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

	@media print {
		/* Pages have their own margins. */
		html {
			margin: 0;
		}
		/* Serif for print. */
		body {
			font-family: serif;
		}
	}
	@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 table positioning:
		   "content column" is 50ems wide at max; less on smaller screens.
		   Extra space (after ToC + content) is empty on the right.

		   1. When table < content column, centers table in column.
		   2. When content < table < available, left-aligns.
		   3. When table > 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 89ebb6ab, updated Fri Oct 9 15:32:07 2020 -0700" name="generator">
  <link href="https://wg21.link/P0323R10" rel="canonical">
  <link href="https://isocpp.org/favicon.ico" rel="icon">
  <meta content="2534a2bd0603a5cf361dddffbfc271407a835634" 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 */
html {
    color: black;
    color: var(--text);
    background-color: white;
    background-color: var(--bg);
}
:root {
    color-scheme: light dark;

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

    --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: #707070;
    --a-visited-text: var(--a-normal-text);
    --a-visited-underline: #bbb;
    --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);

    --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: #fdf6e3; }
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;

        --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);

        --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>
 <body class="h-entry">
  <div class="head">
   <p data-fill-with="logo"></p>
   <h1 class="p-name no-ref" id="title">P0323R10<br>std::expected</h1>
   <h2 class="no-num no-toc no-ref heading settled" id="subtitle"><span class="content">Published Proposal, <time class="dt-updated" datetime="2021-04-15">2021-04-15</time></span></h2>
   <div data-fill-with="spec-metadata">
    <dl>
     <dt>This version:
     <dd><a class="u-url" href="https://wg21.link/P0323R10">https://wg21.link/P0323R10</a>
     <dt class="editor">Authors:
     <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 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>)
     <dt>Audience:
     <dd>LWG
     <dt>Project:
     <dd>ISO/IEC JTC1/SC22/WG21 14882: Programming Language — C++
     <dt>Source:
     <dd><a href="https://github.com/jfbastien/papers/blob/master/source/P0323R10.bs">github.com/jfbastien/papers/blob/master/source/P0323R10.bs</a>
    </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>
     <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><a href="#ret"><span class="secno">2.2</span> <span class="content">Error retrieval and correction</span></a>
      <li><a href="#impact"><span class="secno">2.3</span> <span class="content">Impact on the standard</span></a>
     </ol>
    <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>></c-></code></span></a>
      <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><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>></c-></code></span></a>
      <li><a href="#never-empty"><span class="secno">3.4</span> <span class="content">Never-empty guarantee</span></a>
      <li><a href="#default-ctor"><span class="secno">3.5</span> <span class="content">The default constructor</span></a>
      <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><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><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><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><a href="#observers"><span class="secno">3.10</span> <span class="content">Observers</span></a>
      <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><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><a href="#contained-value"><span class="secno">3.13</span> <span class="content">Accessing the contained value</span></a>
      <li><a href="#deref"><span class="secno">3.14</span> <span class="content">Dereference operator</span></a>
      <li><a href="#func-val"><span class="secno">3.15</span> <span class="content">Function value</span></a>
      <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>>::</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>></c-></code>?</span></a>
      <li><a href="#access-error"><span class="secno">3.17</span> <span class="content">Accessing the contained error</span></a>
      <li><a href="#unexpected-conv"><span class="secno">3.18</span> <span class="content">Conversion to the unexpected value</span></a>
      <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><a href="#eq"><span class="secno">3.20</span> <span class="content">Equality operators</span></a>
      <li><a href="#comparison"><span class="secno">3.21</span> <span class="content">Comparison operators</span></a>
      <li><a href="#modifiers"><span class="secno">3.22</span> <span class="content">Modifiers</span></a>
      <li><a href="#reset"><span class="secno">3.23</span> <span class="content">Resetting the value</span></a>
      <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><a href="#unexpect"><span class="secno">3.25</span> <span class="content">Tag <code class="highlight"><c- n>unexpect</c-></code></span></a>
      <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><a href="#expected-references"><span class="secno">3.27</span> <span class="content">Expected references</span></a>
      <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><a href="#literal"><span class="secno">3.29</span> <span class="content">Making expected a literal type</span></a>
      <li><a href="#moved-from"><span class="secno">3.30</span> <span class="content">Moved from state</span></a>
      <li><a href="#io"><span class="secno">3.31</span> <span class="content">I/O operations</span></a>
      <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><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>>::</c-><c- n>error_or</c-></code> function?</span></a>
      <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>>::</c-><c- n>check_error</c-></code> function?</span></a>
      <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>>::</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>
     </ol>
    <li>
     <a href="#word"><span class="secno">4</span> <span class="content">Wording</span></a>
     <ol class="toc">
      <li><a href="#expected"><span class="secno">4.1</span> <span class="content">�.� Expected objects [<em>expected</em>]</span></a>
      <li><a href="#expected.general"><span class="secno">4.2</span> <span class="content">�.�.1 In general [<em>expected.general</em>]</span></a>
     </ol>
    <li>
     <a href="#expected.synop"><span class="secno">5</span> <span class="content">�.�.2 Header <code class="highlight"><c- o>&lt;</c-><c- n>expected</c-><c- o>></c-></code> synopsis [<em>expected.synop</em>]</span></a>
     <ol class="toc">
      <li><a href="#expected.defs"><span class="secno">5.1</span> <span class="content">�.�.3 Definitions [<em>expected.defs</em>]</span></a>
      <li><a href="#expected.expected"><span class="secno">5.2</span> <span class="content">�.�.4 Class template expected [<em>expected.expected</em>]</span></a>
      <li><a href="#expected.object.ctor"><span class="secno">5.3</span> <span class="content">�.�.4.1 Constructors [<em>expected.object.ctor</em>]</span></a>
      <li><a href="#expected.object.dtor"><span class="secno">5.4</span> <span class="content">�.�.4.2 Destructor [<em>expected.object.dtor</em>]</span></a>
      <li><a href="#expected.object.assign"><span class="secno">5.5</span> <span class="content">�.�.4.3 Assignment [<em>expected.object.assign</em>]</span></a>
      <li><a href="#expected.object.swap"><span class="secno">5.6</span> <span class="content">�.�.4.4 Swap [<em>expected.object.swap</em>]</span></a>
      <li><a href="#expected.object.observe"><span class="secno">5.7</span> <span class="content">�.�.4.5 Observers [<em>expected.object.observe</em>]</span></a>
      <li><a href="#expected.equality_op"><span class="secno">5.8</span> <span class="content">�.�.4.6 Expected Equality operators [<em>expected.equality_op</em>]</span></a>
      <li><a href="#expected.comparison_T"><span class="secno">5.9</span> <span class="content">�.�.4.7 Comparison with <code class="highlight"><c- n>T</c-></code> [<em>expected.comparison_T</em>]</span></a>
      <li><a href="#expected.comparison_unexpected_E"><span class="secno">5.10</span> <span class="content">�.�.4.8 Comparison with <code class="highlight"><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-></code> [<em>expected.comparison_unexpected_E</em>]</span></a>
      <li><a href="#expected.specalg"><span class="secno">5.11</span> <span class="content">�.�.4.9 Specialized algorithms [<em>expected.specalg</em>]</span></a>
      <li><a href="#expected.unexpected"><span class="secno">5.12</span> <span class="content">�.�.5 Unexpected objects [<em>expected.unexpected</em>]</span></a>
      <li><a href="#expected.unexpected.general"><span class="secno">5.13</span> <span class="content">�.�.5.1 General [<em>expected.unexpected.general</em>]</span></a>
      <li>
       <a href="#expected.unexpected.object"><span class="secno">5.14</span> <span class="content">�.�.5.2 Class template <code class="highlight"><c- n>unexpected</c-></code> [<em>expected.unexpected.object</em>]</span></a>
       <ol class="toc">
        <li><a href="#expected.unexpected.ctor"><span class="secno">5.14.1</span> <span class="content">�.�.5.2.1 Constructors [<em>expected.unexpected.ctor</em>]</span></a>
        <li><a href="#expected.unexpected.assign"><span class="secno">5.14.2</span> <span class="content">�.�.5.2.2 Assignment [<em>expected.unexpected.assign</em>]</span></a>
        <li><a href="#expected.unexpected.observe"><span class="secno">5.14.3</span> <span class="content">�.�.5.2.3 Observers [<em>expected.unexpected.observe</em>]</span></a>
        <li><a href="#expected.unexpected.swap"><span class="secno">5.14.4</span> <span class="content">�.�.5.2.4 Swap [<em>expected.unexpected.ctor</em>]</span></a>
       </ol>
      <li>
       <a href="#expected.unexpected.equality_op"><span class="secno">5.15</span> <span class="content">�.�.5.2.5 Equality operators [<em>expected.unexpected.equality_op</em>]</span></a>
       <ol class="toc">
        <li><a href="#expected.unexpected.specalg"><span class="secno">5.15.1</span> <span class="content">�.�.5.2.5 Specialized algorithms [<em>expected.unexpected.specalg</em>]</span></a>
       </ol>
      <li><a href="#expected.bad_expected_access"><span class="secno">5.16</span> <span class="content">�.�.6 Template Class <code class="highlight"><c- n>bad_expected_access</c-></code> [<em>expected.bad_expected_access</em>]</span></a>
      <li><a href="#expected.bad_expected_access_base"><span class="secno">5.17</span> <span class="content">�.�.7 Class <code class="highlight"><c- n>bad_expected_access</c-><c- o>&lt;</c-><c- b>void</c-><c- o>></c-></code> [<em>expected.bad_expected_access_base</em>]</span></a>
      <li><a href="#expected.unexpect"><span class="secno">5.18</span> <span class="content">�.�.8 <code class="highlight"><c- n>unexpect</c-></code> tag [<em>expected.unexpect</em>]</span></a>
      <li><a href="#macro"><span class="secno">5.19</span> <span class="content">Feature test macro</span></a>
     </ol>
    <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><a href="#viboes"><span class="secno">6.2</span> <span class="content">Vicente J. Botet Escriba</span></a>
      <li><a href="#🕸🐈"><span class="secno">6.3</span> <span class="content">WebKit</span></a>
     </ol>
    <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>
     </ol>
   </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>></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>></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 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>
   </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>></c-></code> as a supplement to <code class="highlight"><c- n>optional</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></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 is an update to <a data-link-type="biblio" href="#biblio-p0323r9">[P0323r9]</a>, which was wording-ready but targetted
the Library Fundamentals TS v3.</p>
   <p>In the 2021-04-06 LEWG telecon, LEWG decided to target the IS instead of a TS.</p>
   <p><strong>Poll:</strong> P0323r9 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>F
      <td>N
      <td>A
      <td>SA
    <tbody>
     <tr>
      <td>6
      <td>6
      <td>5
      <td>1
      <td>0
   </table>
   <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 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 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 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 data-md>
     <p><a data-link-type="biblio" href="#biblio-p0343r1">[P0343r1]</a> proposes meta-programming high-order functions.</p>
    <li data-md>
     <p><a data-link-type="biblio" href="#biblio-p0262r1">[P0262r1]</a> is a related proposal for status / optional value.</p>
    <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 data-md>
     <p><a data-link-type="biblio" href="#biblio-p0762r0">[P0762r0]</a> discussed how this paper interacts with boost.Outcome.</p>
    <li data-md>
     <p><a data-link-type="biblio" href="#biblio-p1095r0">[P1095r0]</a> proposes zero overhead deterministic failure.</p>
    <li data-md>
     <p><a data-link-type="biblio" href="#biblio-p0709r4">[P0709r4]</a> discussed zero-overhead deterministic exceptions.</p>
    <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>
   </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 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 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 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>
   </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>Exception
      <td>Return error code
    <tbody>
     <tr>
      <td>Visibility
      <td>Not visible without further analysis of the code. However, if an exception is thrown, we can follow the stack
trace.
      <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.
     <tr>
      <td>Informations
      <td>Exceptions can be arbitrarily rich.
      <td>
       Historically a simple integer. Nowadays, the header 
       <system_error> provides richer error code.</system_error>
     <tr>
      <td>Clean code
      <td>Provides clean code, exceptions can be completely invisible for the caller.
      <td>Force you to add, at least, a if statement after each function call.
     <tr>
      <td>Non-Intrusive
      <td>Proper communication channel.
      <td>Monopolization of the return channel.
   </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>></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>></c-></code> and users cannot ignore the error case if they want to retrieve the contained value.</p>
    <li data-md>
     <p><strong>Information:</strong> Arbitrarily rich.</p>
    <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>></c-></code> can also act as a bridge between an exception-oriented code and a nothrow world.</p>
    <li data-md>
     <p><strong>Non-Intrusive:</strong> Use the return channel without monopolizing it.</p>
   </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>></c-></code> include:</p>
   <ul>
    <li data-md>
     <p>Associates errors with computational goals.</p>
    <li data-md>
     <p>Naturally allows multiple errors inflight.</p>
    <li data-md>
     <p>Teleportation possible.</p>
    <li data-md>
     <p>Across thread boundaries.</p>
    <li data-md>
     <p>On weak executors which don’t support thread-local storage.</p>
    <li data-md>
     <p>Across no-throw subsystem boundaries.</p>
    <li data-md>
     <p>Across time: save now, throw later.</p>
    <li data-md>
     <p>Collect, group, combine errors.</p>
    <li data-md>
     <p>Much simpler for a compiler to optimize.</p>
   </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- n>CharacterType</c-><c- o>></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>></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>>&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>></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>></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- n>CharacterTypeForSyntaxViolation</c-><c- p>,</c-> <c- k>typename</c-> <c- n>CharacterType</c-><c- o>></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>></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>>&amp;</c-> <c- n>iteratorForSyntaxViolationPosition</c-><c- p>,</c-> <c- n>CodePointIterator</c-><c- o>&lt;</c-><c- n>CharacterType</c-><c- o>></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>></c-><c- p>,</c-> <c- mi>4</c-><c- o>></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>>=</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>></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>></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>></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>>=</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>></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>></c-></code> over <code class="highlight"><c- n>optional</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></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 data-md>
     <p>Delegate the responsibility of error handling to higher layer.</p>
    <li data-md>
     <p>Try to resolve the error.</p>
   </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>></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>></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>></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>></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>></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>></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>></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>></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>></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>></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>></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>></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>></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>></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>></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>></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>></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>></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>></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>></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- 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>></c-> <c- n>es</c-><c- p>{</c-><c- n>s</c-><c- p>};</c-> <c- c1>// requires Copyable&lt;T></c->
<c- n>expected</c-><c- o>&lt;</c-><c- n>string</c-><c- p>,</c-> <c- n>errc</c-><c- o>></c-> <c- n>et</c-> <c- o>=</c-> <c- n>s</c-><c- p>;</c-> <c- c1>// requires Copyable&lt;T></c->
<c- n>expected</c-><c- o>&lt;</c-><c- n>string</c-><c- p>,</c-> <c- n>errc</c-><c- o>></c-> <c- n>ev</c-> <c- o>=</c-> <c- n>string</c-><c- s>"STR"</c-><c- p>;</c-> <c- c1>// requires Movable&lt;T></c->

<c- n>expected</c-><c- o>&lt;</c-><c- n>string</c-><c- p>,</c-> <c- n>errc</c-><c- o>></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>></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>></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>></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>></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>></c-> <c- n>ep</c-><c- p>{</c-><c- n>unexpected</c-><c- p>(</c-><c- o>-</c-><c- mi>1</c-><c- p>)};</c-> <c- c1>// unexpected value, requires Movable&lt;E></c->
<c- n>expected</c-><c- o>&lt;</c-><c- n>string</c-><c- p>,</c-> <c- b>int</c-><c- o>></c-> <c- n>eq</c-> <c- o>=</c-> <c- n>unexpected</c-><c- p>(</c-><c- o>-</c-><c- mi>1</c-><c- p>);</c-> <c- c1>// unexpected value, requires Movable&lt;E></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>></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>></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>></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>></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>></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>></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>></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>></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>>></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>></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>></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>></c-></code>, <code class="highlight"><c- n>is_nothrow_move_constructible</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-></code>, <code class="highlight"><c- n>is_nothrow_copy_assignable</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-></code> and <code class="highlight"><c- n>is_nothrow_move_assignable</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></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>></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>>::</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>></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>></c-></code> and <code class="highlight"><c- n>future</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></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>></c-></code> default constructs to an optional with no value.</p>
    <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>></c-></code> default constructs to <code class="highlight"><c- n>T1</c-></code> if default constructible or it is ill-formed</p>
    <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>></c-></code> default constructs to an invalid future with no shared state associated, that is, no value and no exception.</p>
    <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>></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>></c-></code>.</p>
   </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>></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>></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>>></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>></c-><c- p>,</c-><c- n>T</c-><c- o>></c-></code>?</p>
    <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>></c-></code> behave like <code class="highlight"><c- n>optional</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></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>></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>></c-><c- p>,</c-><c- n>T</c-><c- o>></c-></code>.</p>
    <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>></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>>></c-></code> would not be possible.</p>
   </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>></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>></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>></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>></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>></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>></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>></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>></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>></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>></c-></code> (similar to <code class="highlight"><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></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>></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>></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>></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>></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>></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>></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>></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>></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>></c-><c- p>,</c-> <c- n>errc</c-><c- o>></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>></c-><c- p>,</c-> <c- n>errc</c-><c- o>></c-> <c- n>get2</c-><c- p>()</c-> <c- p>{</c->
    <c- k>return</c-> <c- n>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>></c-><c- p>,</c-> <c- n>errc</c-><c- o>></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>></c-><c- p>,</c-> <c- b>int</c-><c- o>></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>></c-><c- p>,</c-> <c- n>errc</c-><c- o>></c-> <c- n>get2</c-><c- p>()</c-> <c- p>{</c->
    <c- k>return</c-> <c- n>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>></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>></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>></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>></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>></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>></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>></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>></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>></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>>></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>></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>></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>></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>></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>>::</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>></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>></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>></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>></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>></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>></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>></c-><c- p>,</c-> <c- n>errc</c-><c- o>></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>></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>></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>></c-></code> is similar to <code class="highlight"><c- n>optional</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></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>></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>></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>></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>></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>></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>></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>></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>></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>></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>></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>></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>></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>></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>></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>></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>></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>>></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>></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>></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>></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>>::</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>>::</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>>::</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>></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>></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>></c->
<c- n>expected</c-><c- o>&lt;</c-><c- n>T</c-><c- p>,</c-><c- n>G</c-><c- o>></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>></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>></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>></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>
   <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>
   <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.1" id="expected"><span class="secno">4.1. </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.2" id="expected.general"><span class="secno">4.2. </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>></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>></c-></code> and manages the lifetime of the contained objects.</p>
   <h2 class="heading settled" data-level="5" id="expected.synop"><span class="secno">5. </span><span class="content">�.�.2 Header <code class="highlight"><c- o>&lt;</c-><c- n>expected</c-><c- o>></c-></code> synopsis [<em>expected.synop</em>]</span><a class="self-link" href="#expected.synop"></a></h2>
<pre class="language-c++ highlight"><c- n>namespace</c-> <c- n>std</c-> <c- p>{</c->

    <c- c1>// �.�.4, 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>></c->
        <c- n>class</c-> <c- n>expected</c-><c- p>;</c->

    <c- c1>// �.�.5, class template unexpected</c->
    <c- n>template</c-><c- o>&lt;</c-><c- n>class</c-> <c- n>E</c-><c- o>></c->
        <c- n>class</c-> <c- n>unexpected</c-><c- p>;</c->
    <c- n>template</c-><c- o>&lt;</c-><c- n>class</c-> <c- n>E</c-><c- o>></c->
      <c- n>unexpected</c-><c- p>(</c-><c- n>E</c-><c- p>)</c-> <c- o>-></c-> <c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-><c- p>;</c->

    <c- c1>// �.�.6, class bad_expected_access</c->
    <c- n>template</c-><c- o>&lt;</c-><c- n>class</c-> <c- n>E</c-><c- o>></c->
       <c- n>class</c-> <c- n>bad_expected_access</c-><c- p>;</c->

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

    <c- c1>// �.�.8, unexpect tag</c->
    <c- k>struct</c-> <c- n>unexpect_t</c-> <c- p>{</c->
       <c- n>explicit</c-> <c- n>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- p>}</c->
</pre>
   <h3 class="heading settled" data-level="5.1" id="expected.defs"><span class="secno">5.1. </span><span class="content">�.�.3 Definitions [<em>expected.defs</em>]</span><a class="self-link" href="#expected.defs"></a></h3>
   <h3 class="heading settled" data-level="5.2" id="expected.expected"><span class="secno">5.2. </span><span class="content">�.�.4 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>></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>></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>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>></c-><c- p>;</c->

    <c- c1>// �.�.4.1, constructors</c->
    <c- n>constexpr</c-> <c- nf>expected</c-><c- p>();</c->
    <c- n>constexpr</c-> <c- nf>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>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>></c->
        <c- n>explicit</c-><c- p>(</c-><c- n>see</c-> <c- n>below</c-><c- p>)</c-> <c- n>constexpr</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>>&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>></c->
        <c- n>explicit</c-><c- p>(</c-><c- n>see</c-> <c- n>below</c-><c- p>)</c-> <c- n>constexpr</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>>&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>></c->
        <c- n>explicit</c-><c- p>(</c-><c- n>see</c-> <c- n>below</c-><c- p>)</c-> <c- n>constexpr</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>=</c-> <c- n>E</c-><c- o>></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>>&amp;</c-><c- p>);</c->
    <c- n>template</c-><c- o>&lt;</c-><c- n>class</c-> <c- n>G</c-> <c- o>=</c-> <c- n>E</c-><c- o>></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>>&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>></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>></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>></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>></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>></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>></c-><c- p>,</c-> <c- n>Args</c-><c- o>&amp;&amp;</c-><c- p>...);</c->


    <c- c1>// �.�.4.2, destructor</c->
    <c- o>~</c-><c- n>expected</c-><c- p>();</c->

    <c- c1>// �.�.4.3, assignment</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>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>></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>=</c-> <c- n>E</c-><c- o>></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>>&amp;</c-><c- p>);</c->
    <c- n>template</c-><c- o>&lt;</c-><c- n>class</c-> <c- n>G</c-> <c- o>=</c-> <c- n>E</c-><c- o>></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>>&amp;&amp;</c-><c- p>);</c->

    <c- c1>// �.�.4.4, modifiers</c->

    <c- n>template</c-><c- o>&lt;</c-><c- n>class</c-><c- p>...</c-> <c- n>Args</c-><c- o>></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>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>></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>></c-><c- p>,</c-> <c- n>Args</c-><c- o>&amp;&amp;</c-><c- p>...);</c->

    <c- c1>// �.�.4.5, swap</c->
    <c- b>void</c-> <c- nf>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>// �.�.4.6, observers</c->
    <c- n>constexpr</c-> <c- k>const</c-> <c- n>T</c-><c- o>*</c-> <c- n>operator</c-><c- o>-></c-><c- p>()</c-> <c- k>const</c-><c- p>;</c->
    <c- n>constexpr</c-> <c- n>T</c-><c- o>*</c-> <c- n>operator</c-><c- o>-></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- 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- 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- 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- p>;</c->
    <c- n>constexpr</c-> <c- n>explicit</c-> <c- n>operator</c-> <c- nf>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- nf>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>></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>></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>// �.�.4.7, Expected equality operators</c->
    <c- n>template</c-><c- o>&lt;</c-><c- n>class</c-> <c- n>T1</c-><c- p>,</c-> <c- n>class</c-> <c- n>E1</c-><c- p>,</c-> <c- n>class</c-> <c- n>T2</c-><c- p>,</c-> <c- n>class</c-> <c- n>E2</c-><c- o>></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>&lt;</c-><c- n>T1</c-><c- p>,</c-> <c- n>E1</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>>&amp;</c-> <c- n>y</c-><c- p>);</c->
    <c- n>template</c-><c- o>&lt;</c-><c- n>class</c-> <c- n>T1</c-><c- p>,</c-> <c- n>class</c-> <c- n>E1</c-><c- p>,</c-> <c- n>class</c-> <c- n>T2</c-><c- p>,</c-> <c- n>class</c-> <c- n>E2</c-><c- o>></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>&lt;</c-><c- n>T1</c-><c- p>,</c-> <c- n>E1</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>>&amp;</c-> <c- n>y</c-><c- p>);</c->

    <c- c1>// �.�.4.8, Comparison with T</c->
    <c- n>template</c-><c- o>&lt;</c-><c- n>class</c-> <c- n>T1</c-><c- p>,</c-> <c- n>class</c-> <c- n>E1</c-><c- p>,</c-> <c- n>class</c-> <c- n>T2</c-><c- o>></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>&lt;</c-><c- n>T1</c-><c- p>,</c-> <c- n>E1</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>T1</c-><c- p>,</c-> <c- n>class</c-> <c- n>E1</c-><c- p>,</c-> <c- n>class</c-> <c- n>T2</c-><c- o>></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>T2</c-><c- o>&amp;</c-><c- p>,</c-> <c- k>const</c-> <c- n>expected</c-><c- o>&lt;</c-><c- n>T1</c-><c- p>,</c-> <c- n>E1</c-><c- o>>&amp;</c-><c- p>);</c->
    <c- n>template</c-><c- o>&lt;</c-><c- n>class</c-> <c- n>T1</c-><c- p>,</c-> <c- n>class</c-> <c- n>E1</c-><c- p>,</c-> <c- n>class</c-> <c- n>T2</c-><c- o>></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>&lt;</c-><c- n>T1</c-><c- p>,</c-> <c- n>E1</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>T1</c-><c- p>,</c-> <c- n>class</c-> <c- n>E1</c-><c- p>,</c-> <c- n>class</c-> <c- n>T2</c-><c- o>></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>T2</c-><c- o>&amp;</c-><c- p>,</c-> <c- k>const</c-> <c- n>expected</c-><c- o>&lt;</c-><c- n>T1</c-><c- p>,</c-> <c- n>E1</c-><c- o>>&amp;</c-><c- p>);</c->

    <c- c1>// �.�.4.9, Comparison with unexpected&lt;E></c->
    <c- n>template</c-><c- o>&lt;</c-><c- n>class</c-> <c- n>T1</c-><c- p>,</c-> <c- n>class</c-> <c- n>E1</c-><c- p>,</c-> <c- n>class</c-> <c- n>E2</c-><c- o>></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>&lt;</c-><c- n>T1</c-><c- p>,</c-> <c- n>E1</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>>&amp;</c-><c- p>);</c->
    <c- n>template</c-><c- o>&lt;</c-><c- n>class</c-> <c- n>T1</c-><c- p>,</c-> <c- n>class</c-> <c- n>E1</c-><c- p>,</c-> <c- n>class</c-> <c- n>E2</c-><c- o>></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>&lt;</c-><c- n>E2</c-><c- o>>&amp;</c-><c- p>,</c-> <c- k>const</c-> <c- n>expected</c-><c- o>&lt;</c-><c- n>T1</c-><c- p>,</c-> <c- n>E1</c-><c- o>>&amp;</c-><c- p>);</c->
    <c- n>template</c-><c- o>&lt;</c-><c- n>class</c-> <c- n>T1</c-><c- p>,</c-> <c- n>class</c-> <c- n>E1</c-><c- p>,</c-> <c- n>class</c-> <c- n>E2</c-><c- o>></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>&lt;</c-><c- n>T1</c-><c- p>,</c-> <c- n>E1</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>>&amp;</c-><c- p>);</c->
    <c- n>template</c-><c- o>&lt;</c-><c- n>class</c-> <c- n>T1</c-><c- p>,</c-> <c- n>class</c-> <c- n>E1</c-><c- p>,</c-> <c- n>class</c-> <c- n>E2</c-><c- o>></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>&lt;</c-><c- n>E2</c-><c- o>>&amp;</c-><c- p>,</c-> <c- k>const</c-> <c- n>expected</c-><c- o>&lt;</c-><c- n>T1</c-><c- p>,</c-> <c- n>E1</c-><c- o>>&amp;</c-><c- p>);</c->

    <c- c1>// �.�.4.10, Specialized algorithms</c->
    <c- n>template</c-><c- o>&lt;</c-><c- n>class</c-> <c- n>T1</c-><c- p>,</c-> <c- n>class</c-> <c- n>E1</c-><c- o>></c->
        <c- n>friend</c-> <c- b>void</c-> <c- n>swap</c-><c- p>(</c-><c- n>expected</c-><c- o>&lt;</c-><c- n>T1</c-><c- p>,</c-> <c- n>E1</c-><c- o>>&amp;</c-><c- p>,</c-> <c- n>expected</c-><c- o>&lt;</c-><c- n>T1</c-><c- p>,</c-> <c- n>E1</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>value_type</c-> <c- n>val</c-><c- p>;</c-> <c- c1>// exposition only</c->
        <c- n>unexpected_type</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>></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>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></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>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></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>></c-></code> storage suitably aligned for the 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>></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>></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>></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 <code class="highlight"><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></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>E</c-><c- o>></c-></code> with the <code class="highlight"><c- n>E</c-></code> parameter that is not a valid template parameter
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.3" id="expected.object.ctor"><span class="secno">5.3. </span><span class="content">�.�.4.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>></c-></code> is <code class="highlight">true</code> or <code class="highlight"><c- n>T</c-></code> is <em>cv</em> <code class="highlight"><c- b>void</c-></code>.</p>
   <p><em>Effects</em>: Value-initializes <code class="highlight"><c- n>val</c-></code> if <code class="highlight"><c- n>T</c-></code> is not <em>cv</em> <code class="highlight"><c- b>void</c-></code>.</p>
   <p><em>Ensures</em>: <code class="highlight"><c- b>bool</c-><c- p>(</c-><c- o>*</c-><c- k>this</c-><c- p>)</c-></code> is <code class="highlight">true</code>.</p>
   <p><em>Throws</em>: Any exception thrown by the selected constructor of <code class="highlight"><c- n>T</c-></code>.</p>
   <p><em>Remarks</em>: If value-initialization of <code class="highlight"><c- n>T</c-></code> is a constant subexpression or <code class="highlight"><c- n>T</c-></code> is <em>cv</em> <code class="highlight"><c- b>void</c-></code> this constructor is constexpr.</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- b>bool</c-><c- p>(</c-><c- n>rhs</c-><c- p>)</c-></code> and <code class="highlight"><c- n>T</c-></code> is not <em>cv</em> <code class="highlight"><c- b>void</c-></code>, initializes <code class="highlight"><c- n>val</c-></code> as if
direct-non-list-initializing an object of type <code class="highlight"><c- n>T</c-></code> with the expression <code class="highlight"><c- o>*</c-><c- n>rhs</c-></code>.</p>
   <p>Otherwise, initializes <code class="highlight"><c- n>unex</c-></code> as if direct-non-list-initializing an object
of type <code class="highlight"><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-></code> with the expression <code class="highlight"><c- n>unexpected</c-><c- p>(</c-><c- n>rhs</c-><c- p>.</c-><c- n>error</c-><c- p>())</c-></code>.</p>
   <p><em>Ensures</em>: <code class="highlight"><c- b>bool</c-><c- p>(</c-><c- n>rhs</c-><c- p>)</c-> <c- o>==</c-> <c- b>bool</c-><c- p>(</c-><c- o>*</c-><c- k>this</c-><c- p>)</c-></code>.</p>
   <p><em>Throws</em>: Any exception thrown by the selected constructor of <code class="highlight"><c- n>T</c-></code> or <code class="highlight"><c- n>E</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>></c-></code> is <code class="highlight">true</code> or <code class="highlight"><c- n>T</c-></code> is <em>cv</em> <code class="highlight"><c- b>void</c-></code>; and</p>
    <li data-md>
     <p><code class="highlight"><c- n>is_copy_constructible_v</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-></code> is <code class="highlight">true</code>.</p>
   </ul>
   <p>This constructor is a constexpr constructor 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>></c-></code> is <code class="highlight">true</code> or <code class="highlight"><c- n>T</c-></code> is <em>cv</em> <code class="highlight"><c- b>void</c-></code>; and</p>
    <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>></c-></code> is <code class="highlight">true</code>.</p>
   </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>></c-></code> is <code class="highlight">true</code>; and</p>
    <li data-md>
     <p><code class="highlight"><c- n>is_move_constructible_v</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-></code> is <code class="highlight">true</code>.</p>
   </ul>
   <p><em>Effects</em>: If <code class="highlight"><c- b>bool</c-><c- p>(</c-><c- n>rhs</c-><c- p>)</c-></code> and <code class="highlight"><c- n>T</c-></code> is not <em>cv</em> <code class="highlight"><c- b>void</c-></code>, initializes <code class="highlight"><c- n>val</c-></code> as if
direct-non-list-initializing an object of type <code class="highlight"><c- n>T</c-></code> with the expression <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>.</p>
   <p>Otherwise, initializes <code class="highlight"><c- n>val</c-></code> as if direct-non-list-initializing an object of
type <code class="highlight"><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-></code> with the expression <code class="highlight"><c- n>unexpected</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>
   <p><em>Ensures</em>: <code class="highlight"><c- b>bool</c-><c- p>(</c-><c- n>rhs</c-><c- p>)</c-></code> is unchanged, <code class="highlight"><c- b>bool</c-><c- p>(</c-><c- n>rhs</c-><c- p>)</c-> <c- o>==</c-> <c- b>bool</c-><c- p>(</c-><c- o>*</c-><c- k>this</c-><c- p>)</c-></code>.</p>
   <p><em>Throws</em>: Any exception thrown by the selected constructor of <code class="highlight"><c- n>T</c-></code> or <code class="highlight"><c- n>E</c-></code>.</p>
   <p><em>Remarks</em>: The expression inside <code class="highlight"><c- k>noexcept</c-></code> is equivalent to:</p>
   <ul>
    <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>></c-></code> is <code class="highlight">true</code> or <code class="highlight"><c- n>T</c-></code>is <em>cv</em> <code class="highlight"><c- b>void</c-></code>; and</p>
    <li data-md>
     <p><code class="highlight"><c- n>is_nothrow_move_constructible_v</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-></code> is <code class="highlight">true</code>.</p>
   </ul>
   <p><em>Remarks</em>: This constructor is a constexpr constructor 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>></c-></code> is <code class="highlight">true</code> or <code class="highlight"><c- n>T</c-></code> is <em>cv</em> <code class="highlight"><c- b>void</c-></code>; and</p>
    <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>></c-></code> is <code class="highlight">true</code>.</p>
   </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>></c->
    <c- n>explicit</c-><c- p>(</c-><c- n>see</c-> <c- n>below</c-><c- p>)</c-> <c- n>constexpr</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>>&amp;</c-> <c- n>rhs</c-><c- p>);</c->
</pre>
   <p><em>Constraints</em>: <code class="highlight"><c- n>T</c-></code> and <code class="highlight"><c- n>U</c-></code> are <em>cv</em> <code class="highlight"><c- b>void</c-></code> or:</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- k>const</c-> <c- n>U</c-><c- o>&amp;></c-></code> is <code class="highlight">true</code> ; and</p>
    <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>>&amp;></c-></code> is <code class="highlight">false</code>; and</p>
    <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>>&amp;&amp;></c-></code> is <code class="highlight">false</code>; and</p>
    <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>>&amp;></c-></code> is <code class="highlight">false</code>; and</p>
    <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>>&amp;&amp;></c-></code> is <code class="highlight">false</code>; and</p>
    <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>>&amp;</c-><c- p>,</c-> <c- n>T</c-><c- o>></c-></code> is <code class="highlight">false</code>; and</p>
    <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>>&amp;&amp;</c-><c- p>,</c-> <c- n>T</c-><c- o>></c-></code> is <code class="highlight">false</code>; and</p>
    <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>>&amp;</c-><c- p>,</c-> <c- n>T</c-><c- o>></c-></code> is <code class="highlight">false</code>; and</p>
    <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>>&amp;&amp;</c-><c- p>,</c-> <c- n>T</c-><c- o>></c-></code> is <code class="highlight">false</code>; and</p>
    <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- k>const</c-> <c- n>G</c-><c- o>&amp;></c-></code> is <code class="highlight">true</code>; and</p>
    <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>></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>>&amp;></c-></code> is <code class="highlight">false</code>; and</p>
    <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>></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>>&amp;&amp;></c-></code> is <code class="highlight">false</code>; and</p>
    <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>></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>>&amp;></c-></code> is <code class="highlight">false</code>; and</p>
    <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>></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>>&amp;&amp;></c-></code> is <code class="highlight">false</code>; and</p>
    <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>>&amp;</c-><c- p>,</c-> <c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>>></c-></code> is <code class="highlight">false</code>; and</p>
    <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>>&amp;&amp;</c-><c- p>,</c-> <c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>>></c-></code> is <code class="highlight">false</code>; and</p>
    <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>>&amp;</c-><c- p>,</c-> <c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>>></c-></code> is <code class="highlight">false</code>; and</p>
    <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>>&amp;&amp;</c-><c- p>,</c-> <c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>>></c-></code> is <code class="highlight">false</code>.</p>
   </ul>
   <p><em>Effects</em>: If <code class="highlight"><c- b>bool</c-><c- p>(</c-><c- n>rhs</c-><c- p>)</c-></code> and <code class="highlight"><c- n>T</c-></code> is not <em>cv</em> <code class="highlight"><c- b>void</c-></code>, initializes <code class="highlight"><c- n>val</c-></code> as if
direct-non-list-initializing an object of type <code class="highlight"><c- n>T</c-></code> with the expression <code class="highlight"><c- o>*</c-><c- n>rhs</c-></code>.</p>
   <p>Otherwise, initializes <code class="highlight"><c- n>unex</c-></code> as if direct-non-list-initializing an object
of type <code class="highlight"><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-></code> with the expression <code class="highlight"><c- n>unexpected</c-><c- p>(</c-><c- n>rhs</c-><c- p>.</c-><c- n>error</c-><c- p>())</c-></code>.</p>
   <p><em>Ensures</em>: <code class="highlight"><c- b>bool</c-><c- p>(</c-><c- n>rhs</c-><c- p>)</c-> <c- o>==</c-> <c- b>bool</c-><c- p>(</c-><c- o>*</c-><c- k>this</c-><c- p>)</c-></code>.</p>
   <p><em>Throws</em>: Any exception thrown by the selected constructor of <code class="highlight"><c- n>T</c-></code> or <code class="highlight"><c- n>E</c-></code>.</p>
   <p><em>Remarks</em>:
The expression inside <code class="highlight"><c- k>explicit</c-></code> is <code class="highlight">true</code> if and only if:</p>
   <ul>
    <li data-md>
     <p><code class="highlight"><c- n>T</c-></code> and <code class="highlight"><c- n>U</c-></code> are not <em>cv</em> <code class="highlight"><c- b>void</c-></code> and <code class="highlight"><c- n>is_convertible_v</c-><c- o>&lt;</c-><c- k>const</c-> <c- n>U</c-><c- o>&amp;</c-><c- p>,</c-> <c- n>T</c-><c- o>></c-></code> is <code class="highlight">false</code> or</p>
    <li data-md>
     <p><code class="highlight"><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>></c-></code> is <code class="highlight">false</code>.</p>
   </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>></c->
    <c- n>explicit</c-><c- p>(</c-><c- n>see</c-> <c- n>below</c-><c- p>)</c-> <c- n>constexpr</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>>&amp;&amp;</c-> <c- n>rhs</c-><c- p>);</c->
</pre>
   <p><em>Constraints</em>: <code class="highlight"><c- n>T</c-></code> and <code class="highlight"><c- n>U</c-></code> are <em>cv</em> <code class="highlight"><c- b>void</c-></code> or:</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>U</c-><c- o>&amp;&amp;></c-></code> is <code class="highlight">true</code>; and</p>
    <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>>&amp;></c-></code> is <code class="highlight">false</code>; and</p>
    <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>>&amp;&amp;></c-></code> is <code class="highlight">false</code>; and</p>
    <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>>&amp;></c-></code> is <code class="highlight">false</code>; and</p>
    <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>>&amp;&amp;></c-></code> is <code class="highlight">false</code>; and</p>
    <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>>&amp;</c-><c- p>,</c-> <c- n>T</c-><c- o>></c-></code> is <code class="highlight">false</code>; and</p>
    <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>>&amp;&amp;</c-><c- p>,</c-> <c- n>T</c-><c- o>></c-></code> is <code class="highlight">false</code>; and</p>
    <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>>&amp;</c-><c- p>,</c-> <c- n>T</c-><c- o>></c-></code> is <code class="highlight">false</code>; and</p>
    <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>>&amp;&amp;</c-><c- p>,</c-> <c- n>T</c-><c- o>></c-></code> is <code class="highlight">false</code>; and</p>
    <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>G</c-><c- o>&amp;&amp;></c-></code> is <code class="highlight">true</code>; and</p>
    <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>></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>>&amp;></c-></code> is <code class="highlight">false</code>; and</p>
    <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>></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>>&amp;&amp;></c-></code> is <code class="highlight">false</code>; and</p>
    <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>></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>>&amp;></c-></code> is <code class="highlight">false</code>; and</p>
    <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>></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>>&amp;&amp;></c-></code> is <code class="highlight">false</code>; and</p>
    <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>>&amp;</c-><c- p>,</c-> <c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>>></c-></code> is <code class="highlight">false</code>; and</p>
    <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>>&amp;&amp;</c-><c- p>,</c-> <c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>>></c-></code> is <code class="highlight">false</code>; and</p>
    <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>>&amp;</c-><c- p>,</c-> <c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>>></c-></code> is <code class="highlight">false</code>; and</p>
    <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>>&amp;&amp;</c-><c- p>,</c-> <c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>>></c-></code> is <code class="highlight">false</code>.</p>
   </ul>
   <p><em>Effects</em>: If <code class="highlight"><c- b>bool</c-><c- p>(</c-><c- n>rhs</c-><c- p>)</c-></code> initializes <code class="highlight"><c- n>val</c-></code> as if
direct-non-list-initializing an object of type <code class="highlight"><c- n>T</c-></code> with the expression <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> or nothing if <code class="highlight"><c- n>T</c-></code> is <em>cv</em> <code class="highlight"><c- b>void</c-></code>.</p>
   <p>Otherwise, initializes <code class="highlight"><c- n>unex</c-></code> as if direct-non-list-initializing an object
of type <code class="highlight"><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-></code> with the expression <code class="highlight"><c- n>unexpected</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>
   <p><em>Ensures</em>: <code class="highlight"><c- b>bool</c-><c- p>(</c-><c- n>rhs</c-><c- p>)</c-></code> is unchanged, <code class="highlight"><c- b>bool</c-><c- p>(</c-><c- n>rhs</c-><c- p>)</c-> <c- o>==</c-> <c- b>bool</c-><c- p>(</c-><c- o>*</c-><c- k>this</c-><c- p>)</c-></code>.</p>
   <p><em>Throws</em>: Any exception thrown by operations specified in the effect clause.</p>
   <p><em>Remarks</em>: The expression inside <code class="highlight"><c- k>explicit</c-></code> is <code class="highlight">true</code> if and only if</p>
   <ul>
    <li data-md>
     <p><code class="highlight"><c- n>T</c-></code> and <code class="highlight"><c- n>U</c-></code> are not <em>cv</em> <code class="highlight"><c- b>void</c-></code> and <code class="highlight"><c- n>is_convertible_v</c-><c- o>&lt;</c-><c- n>U</c-><c- o>&amp;&amp;</c-><c- p>,</c-> <c- n>T</c-><c- o>></c-></code> is <code class="highlight">false</code> or</p>
    <li data-md>
     <p><code class="highlight"><c- n>is_convertible_v</c-><c- o>&lt;</c-><c- n>G</c-><c- o>&amp;&amp;</c-><c- p>,</c-> <c- n>E</c-><c- o>></c-></code> is <code class="highlight">false</code>.</p>
   </ul>
<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>></c->
    <c- n>explicit</c-><c- p>(</c-><c- n>see</c-> <c- n>below</c-><c- p>)</c-> <c- n>constexpr</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>T</c-></code> is not <em>cv</em> <code class="highlight"><c- b>void</c-></code>; and</p>
    <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>&amp;&amp;></c-></code> is <code class="highlight">true</code>; and</p>
    <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>></c-><c- p>,</c-> <c- n>in_place_t</c-><c- o>></c-></code> is <code class="highlight">false</code>; and</p>
    <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>></c-><c- p>,</c-> <c- n>remove_cvref_t</c-><c- o>&lt;</c-><c- n>U</c-><c- o>>></c-></code> is <code class="highlight">false</code>; and</p>
    <li data-md>
     <p><code class="highlight"><c- n>is_same_v</c-><c- o>&lt;</c-><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-><c- p>,</c-> <c- n>remove_cvref_t</c-><c- o>&lt;</c-><c- n>U</c-><c- o>>></c-></code> is <code class="highlight">false</code>.</p>
   </ul>
   <p><em>Effects</em>: Initializes <code class="highlight"><c- n>val</c-></code> as if direct-non-list-initializing an
object of type <code class="highlight"><c- n>T</c-></code> with the expression <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>forward</c-><c- o>&lt;</c-><c- n>U</c-><c- o>></c-><c- p>(</c-><c- n>v</c-><c- p>)</c-></code>.</p>
   <p><em>Ensures</em>: <code class="highlight"><c- b>bool</c-><c- p>(</c-><c- o>*</c-><c- k>this</c-><c- p>)</c-></code> is <code class="highlight">true</code>.</p>
   <p><em>Throws</em>: Any exception thrown by the selected constructor of <code class="highlight"><c- n>T</c-></code>.</p>
   <p><em>Remarks</em>: If <code class="highlight"><c- n>T</c-></code>'s selected constructor is a constant subexpression, this
constructor is a constexpr constructor.</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>U</c-><c- o>&amp;&amp;</c-><c- p>,</c-> <c- n>T</c-><c- o>></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>=</c-> <c- n>E</c-><c- o>></c->
    <c- n>explicit</c-><c- p>(</c-><c- n>see</c-> <c- n>below</c-><c- p>)</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>>&amp;</c-> <c- n>e</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- k>const</c-> <c- n>G</c-><c- o>&amp;></c-></code> is <code class="highlight">true</code>.</p>
   <p><em>Effects</em>: Initializes <code class="highlight"><c- n>unex</c-></code> as if direct-non-list-initializing
an object of type <code class="highlight"><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-></code> with the expression <code class="highlight"><c- n>e</c-></code>.</p>
   <p><em>Ensures</em>: <code class="highlight"><c- b>bool</c-><c- p>(</c-><c- o>*</c-><c- k>this</c-><c- p>)</c-></code> is <code class="highlight">false</code>.</p>
   <p><em>Throws</em>: Any exception thrown by the selected constructor of <code class="highlight"><c- n>E</c-></code>.</p>
   <p><em>Remarks</em>: If <code class="highlight"><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-></code>'s selected constructor is a constant
subexpression, this constructor shall be a constexpr constructor.
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- k>const</c-> <c- n>G</c-><c- o>&amp;</c-><c- p>,</c-> <c- n>E</c-><c- o>></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>=</c-> <c- n>E</c-><c- o>></c->
    <c- n>explicit</c-><c- p>(</c-><c- n>see</c-> <c- n>below</c-><c- p>)</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>>&amp;&amp;</c-> <c- n>e</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>G</c-><c- o>&amp;&amp;></c-></code> is <code class="highlight">true</code>.</p>
   <p><em>Effects</em>: Initializes <code class="highlight"><c- n>unex</c-></code> as if direct-non-list-initializing
an object of type <code class="highlight"><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-></code> with the expression <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>
   <p><em>Ensures</em>: <code class="highlight"><c- b>bool</c-><c- p>(</c-><c- o>*</c-><c- k>this</c-><c- p>)</c-></code> is <code class="highlight">false</code>.</p>
   <p><em>Throws</em>: Any exception thrown by the selected constructor of <code class="highlight"><c- n>E</c-></code>.</p>
   <p><em>Remarks</em>: If <code class="highlight"><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-></code>'s selected constructor is a constant
subexpression, this constructor is a constexpr constructor. The expression
inside <code class="highlight"><c- k>noexcept</c-></code> is equivalent to: <code class="highlight"><c- n>is_nothrow_constructible_v</c-><c- o>&lt;</c-><c- n>E</c-><c- p>,</c-> <c- n>G</c-><c- o>&amp;&amp;></c-></code> is <code class="highlight">true</code>.
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>G</c-><c- o>&amp;&amp;</c-><c- p>,</c-> <c- n>E</c-><c- o>></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>></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>T</c-></code> is <em>cv</em> <code class="highlight"><c- b>void</c-></code> and <code class="highlight"><c- k>sizeof</c-><c- p>...(</c-><c- n>Args</c-><c- p>)</c-> <c- o>==</c-> <c- mi>0</c-></code>; or</p>
    <li data-md>
     <p><code class="highlight"><c- n>T</c-></code> is not <em>cv</em> <code class="highlight"><c- b>void</c-></code> and <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>></c-></code> is <code class="highlight">true</code>.</p>
   </ul>
   <p><em>Effects</em>: If <code class="highlight"><c- n>T</c-></code> is <em>cv</em> <code class="highlight"><c- b>void</c-></code>, no effects. Otherwise, initializes <code class="highlight"><c- n>val</c-></code> as if
direct-non-list-initializing an object of type <code class="highlight"><c- n>T</c-></code> with the arguments <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>forward</c-><c- o>&lt;</c-><c- n>Args</c-><c- o>></c-><c- p>(</c-><c- n>args</c-><c- p>)...</c-></code>.</p>
   <p><em>Ensures</em>: <code class="highlight"><c- b>bool</c-><c- p>(</c-><c- o>*</c-><c- k>this</c-><c- p>)</c-></code> is <code class="highlight">true</code>.</p>
   <p><em>Throws</em>: Any exception thrown by the selected constructor of <code class="highlight"><c- n>T</c-></code>.</p>
   <p><em>Remarks</em>: If <code class="highlight"><c- n>T</c-></code>'s constructor selected for the initialization is a constant subexpression,
this constructor is a constexpr constructor.</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>></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>></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>T</c-></code> is not <em>cv</em> <code class="highlight"><c- b>void</c-></code> and <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>>&amp;</c-><c- p>,</c-> <c- n>Args</c-><c- p>...</c-><c- o>></c-></code> is <code class="highlight">true</code>.</p>
   <p><em>Effects</em>: Initializes <code class="highlight"><c- n>val</c-></code> as if direct-non-list-initializing an
object of type <code class="highlight"><c- n>T</c-></code> with the arguments <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>></c-><c- p>(</c-><c- n>args</c-><c- p>)...</c-></code>.</p>
   <p><em>Ensures</em>: <code class="highlight"><c- b>bool</c-><c- p>(</c-><c- o>*</c-><c- k>this</c-><c- p>)</c-></code> is <code class="highlight">true</code>.</p>
   <p><em>Throws</em>: Any exception thrown by the selected constructor of <code class="highlight"><c- n>T</c-></code>.</p>
   <p><em>Remarks</em>: If <code class="highlight"><c- n>T</c-></code>'s constructor selected for the initialization is a constant subexpression,
this constructor is a constexpr constructor.</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>></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>></c-></code> is <code class="highlight">true</code>.</p>
   <p><em>Effects</em>: Initializes <code class="highlight"><c- n>unex</c-></code> as if direct-non-list-initializing
an object of type <code class="highlight"><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-></code>with the arguments <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>forward</c-><c- o>&lt;</c-><c- n>Args</c-><c- o>></c-><c- p>(</c-><c- n>args</c-><c- p>)...</c-></code>.</p>
   <p><em>Ensures</em>: <code class="highlight"><c- b>bool</c-><c- p>(</c-><c- o>*</c-><c- k>this</c-><c- p>)</c-></code> is <code class="highlight">false</code>.</p>
   <p><em>Throws</em>: Any exception thrown by the selected constructor of <code class="highlight"><c- n>E</c-></code>.</p>
   <p><em>Remarks</em>: If <code class="highlight"><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-></code>'s constructor selected for the initialization is a
constant subexpression, this constructor is a constexpr constructor.</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>></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>></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>>&amp;</c-><c- p>,</c-> <c- n>Args</c-><c- p>...</c-><c- o>></c-></code> is <code class="highlight">true</code>.</p>
   <p><em>Effects</em>: Initializes <code class="highlight"><c- n>unex</c-></code> as if direct-non-list-initializing
an object of type <code class="highlight"><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-></code> with the arguments <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>></c-><c- p>(</c-><c- n>args</c-><c- p>)...</c-></code>.</p>
   <p><em>Ensures</em>: <code class="highlight"><c- b>bool</c-><c- p>(</c-><c- o>*</c-><c- k>this</c-><c- p>)</c-></code> is <code class="highlight">false</code>.</p>
   <p><em>Throws</em>: Any exception thrown by the selected constructor of <code class="highlight"><c- n>E</c-></code>.</p>
   <p><em>Remarks</em>: If <code class="highlight"><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-></code>'s constructor selected for the initialization is a
constant subexpression, this constructor is a constexpr constructor.</p>
   <h3 class="heading settled" data-level="5.4" id="expected.object.dtor"><span class="secno">5.4. </span><span class="content">�.�.4.2 Destructor [<em>expected.object.dtor</em>]</span><a class="self-link" href="#expected.object.dtor"></a></h3>
<pre class="language-c++ highlight"><c- o>~</c-><c- n>expected</c-><c- p>();</c->
</pre>
   <p><em>Effects</em>: If <code class="highlight"><c- n>T</c-></code> is not <em>cv</em> <code class="highlight"><c- b>void</c-></code> and <code class="highlight"><c- n>is_trivially_destructible_v</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code> is <code class="highlight">false</code> and <code class="highlight"><c- b>bool</c-><c- p>(</c-><c- o>*</c-><c- k>this</c-><c- p>)</c-></code>, calls <code class="highlight"><c- n>val</c-><c- p>.</c-><c- o>~</c-><c- n>T</c-><c- p>()</c-></code>. If <code class="highlight"><c- n>is_trivially_destructible_v</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-></code> is <code class="highlight">false</code> and <code class="highlight"><c- o>!</c-><c- b>bool</c-><c- p>(</c-><c- o>*</c-><c- k>this</c-><c- p>)</c-></code>, calls <code class="highlight"><c- n>unexpect</c-><c- p>.</c-><c- o>~</c-><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-><c- p>()</c-></code>.</p>
   <p><em>Remarks</em>: If either <code class="highlight"><c- n>T</c-></code> is <em>cv</em> <code class="highlight"><c- b>void</c-></code> or <code class="highlight"><c- n>is_trivially_destructible_v</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></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>></c-></code> is <code class="highlight">true</code>, then this destructor
is a trivial destructor.</p>
   <h3 class="heading settled" data-level="5.5" id="expected.object.assign"><span class="secno">5.5. </span><span class="content">�.�.4.3 Assignment [<em>expected.object.assign</em>]</span><a class="self-link" href="#expected.object.assign"></a></h3>
<pre class="language-c++ highlight"><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-> <c- n>noexcept</c-><c- p>(</c-><c- n>see</c-> <c- n>below</c-><c- p>);</c->
</pre>
   <p><em>Effects</em>: See Table <em>editor-please-pick-a-number-0</em></p>
   <table>
    <caption>Table <em>editor-please-pick-a-number-0</em> — <code class="highlight"><c- k>operator</c-><c- o>=</c-><c- p>(</c-><c- k>const</c-> <c- n>expected</c-><c- o>&amp;</c-><c- p>)</c-></code> effects</caption>
    <tbody>
     <tr>
      <td>
      <td><code class="highlight"><c- b>bool</c-><c- p>(</c-><c- o>*</c-><c- k>this</c-><c- p>)</c-></code>
      <td><code class="highlight"><c- o>!</c-><c- b>bool</c-><c- p>(</c-><c- o>*</c-><c- k>this</c-><c- p>)</c-></code>
     <tr>
      <td><code class="highlight"><c- b>bool</c-><c- p>(</c-><c- n>rhs</c-><c- p>)</c-></code>
      <td>assigns <code class="highlight"><c- o>*</c-><c- n>rhs</c-></code> to <code class="highlight"><c- n>val</c-></code> if <code class="highlight"><c- n>T</c-></code> is not <em>cv</em> <code class="highlight"><c- b>void</c-></code>
      <td>
       <ul>
        <li data-md>
         <p>if <code class="highlight"><c- n>T</c-></code> is <em>cv</em> <code class="highlight"><c- b>void</c-></code> destroys <code class="highlight"><c- n>unex</c-></code> by calling <code class="highlight"><c- n>unexpect</c-><c- p>.</c-><c- o>~</c-><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-><c- p>()</c-></code> and set <code class="highlight"><c- n>has_val</c-></code> to <code class="highlight">true</code>,</p>
        <li data-md>
         <p>otherwise if <code class="highlight"><c- n>is_nothrow_copy_constructible_v</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code> is <code class="highlight">true</code></p>
         <ul>
          <li data-md>
           <p>destroys <code class="highlight"><c- n>unex</c-></code> by calling <code class="highlight"><c- n>unexpect</c-><c- p>.</c-><c- o>~</c-><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-><c- p>()</c-></code></p>
          <li data-md>
           <p>initializes <code class="highlight"><c- n>val</c-></code> as if direct-non-list-initializing an object of type <code class="highlight"><c- n>T</c-></code> with <code class="highlight"><c- o>*</c-><c- n>rhs</c-></code>;</p>
         </ul>
        <li data-md>
         <p>otherwise if <code class="highlight"><c- n>is_nothrow_move_constructible_v</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code> is <code class="highlight">true</code></p>
         <ul>
          <li data-md>
           <p>constructs a <code class="highlight"><c- n>T</c-> <c- n>tmp</c-></code> from <code class="highlight"><c- o>*</c-><c- n>rhs</c-></code> (this can throw),</p>
          <li data-md>
           <p>destroys <code class="highlight"><c- n>unex</c-></code> by calling <code class="highlight"><c- n>unexpect</c-><c- p>.</c-><c- o>~</c-><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-><c- p>()</c-></code></p>
          <li data-md>
           <p>initializes <code class="highlight"><c- n>val</c-></code> as if direct-non-list-initializing an object of type <code class="highlight"><c- n>T</c-></code> with <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>move</c-><c- p>(</c-><c- n>tmp</c-><c- p>)</c-></code>;</p>
         </ul>
        <li data-md>
         <p>otherwise</p>
         <ul>
          <li data-md>
           <p>constructs an <code class="highlight"><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-> <c- n>tmp</c-></code> from <code class="highlight"><c- n>unexpected</c-><c- p>(</c-><c- k>this</c-><c- o>-></c-><c- n>error</c-><c- p>())</c-></code> (which can throw),</p>
          <li data-md>
           <p>destroys <code class="highlight"><c- n>unex</c-></code> by calling <code class="highlight"><c- n>unexpect</c-><c- p>.</c-><c- o>~</c-><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-><c- p>()</c-></code>,</p>
          <li data-md>
           <p>initializes <code class="highlight"><c- n>val</c-></code> as if direct-non-list-initializing an object of type <code class="highlight"><c- n>T</c-></code> with <code class="highlight"><c- o>*</c-><c- n>rhs</c-></code>. Either,</p>
          <li data-md>
           <p>the constructor didn’t throw, set <code class="highlight"><c- n>has_val</c-></code> to <code class="highlight">true</code>, or</p>
          <li data-md>
           <p>the constructor did throw, so move-construct the <code class="highlight"><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-></code> from <code class="highlight"><c- n>tmp</c-></code> back into the expected storage (which can’t throw as <code class="highlight"><c- n>is_nothrow_move_constructible_v</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-></code> is <code class="highlight">true</code>), and rethrow the exception.</p>
         </ul>
       </ul>
     <tr>
      <td><code class="highlight"><c- o>!</c-><c- b>bool</c-><c- p>(</c-><c- n>rhs</c-><c- p>)</c-></code>
      <td>
       <ul>
        <li data-md>
         <p>if <code class="highlight"><c- n>T</c-></code> is <em>cv</em> <code class="highlight"><c- b>void</c-></code></p>
         <ul>
          <li data-md>
           <p>initializes <code class="highlight"><c- n>unex</c-></code> as if direct-non-list-initializing an object of type <code class="highlight"><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-></code> with <code class="highlight"><c- n>unexpected</c-><c- p>(</c-><c- n>rhs</c-><c- p>.</c-><c- n>error</c-><c- p>())</c-></code>. Either</p>
          <li data-md>
           <p>the constructor didn’t throw, set <code class="highlight"><c- n>has_val</c-></code> to <code class="highlight">false</code>, or</p>
          <li data-md>
           <p>the constructor did throw, and nothing was changed.</p>
         </ul>
        <li data-md>
         <p>otherwise if <code class="highlight"><c- n>is_nothrow_copy_constructible_v</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-></code> is <code class="highlight">true</code></p>
         <ul>
          <li data-md>
           <p>destroys <code class="highlight"><c- n>val</c-></code> by calling <code class="highlight"><c- n>val</c-><c- p>.</c-><c- o>~</c-><c- n>T</c-><c- p>()</c-></code>,</p>
          <li data-md>
           <p>initializes <code class="highlight"><c- n>unex</c-></code> as if direct-non-list-initializing an object of type <code class="highlight"><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-></code> with <code class="highlight"><c- n>unexpected</c-><c- p>(</c-><c- n>rhs</c-><c- p>.</c-><c- n>error</c-><c- p>())</c-></code> and set <code class="highlight"><c- n>has_val</c-></code> to <code class="highlight">false</code>.</p>
         </ul>
        <li data-md>
         <p>otherwise if <code class="highlight"><c- n>is_nothrow_move_constructible_v</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-></code> is <code class="highlight">true</code></p>
         <ul>
          <li data-md>
           <p>constructs an <code class="highlight"><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-> <c- n>tmp</c-></code> from <code class="highlight"><c- n>unexpected</c-><c- p>(</c-><c- n>rhs</c-><c- p>.</c-><c- n>error</c-><c- p>())</c-></code> (this can throw),</p>
          <li data-md>
           <p>destroys <code class="highlight"><c- n>val</c-></code> by calling <code class="highlight"><c- n>val</c-><c- p>.</c-><c- o>~</c-><c- n>T</c-><c- p>()</c-></code>,</p>
          <li data-md>
           <p>initializes <code class="highlight"><c- n>unex</c-></code> as if direct-non-list-initializing an object of type <code class="highlight"><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-></code> with <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>move</c-><c- p>(</c-><c- n>tmp</c-><c- p>)</c-></code> and set <code class="highlight"><c- n>has_val</c-></code> to <code class="highlight">false</code>.</p>
         </ul>
        <li data-md>
         <p>otherwise</p>
         <ul>
          <li data-md>
           <p>constructs a <code class="highlight"><c- n>T</c-> <c- n>tmp</c-></code> from <code class="highlight"><c- o>*</c-><c- k>this</c-></code> (this can throw),</p>
          <li data-md>
           <p>destroys <code class="highlight"><c- n>val</c-></code> by calling <code class="highlight"><c- n>val</c-><c- p>.</c-><c- o>~</c-><c- n>T</c-><c- p>()</c-></code>,</p>
          <li data-md>
           <p>initializes <code class="highlight"><c- n>unex</c-></code> as if direct-non-list-initializing an object of type <code class="highlight"><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-></code> with <code class="highlight"><c- n>unexpected</c-><c- p>(</c-><c- n>rhs</c-><c- p>.</c-><c- n>error</c-><c- p>())</c-></code>. Either,</p>
          <li data-md>
           <p>the last constructor didn’t throw, set <code class="highlight"><c- n>has_val</c-></code> to <code class="highlight">false</code>, or</p>
          <li data-md>
           <p>the last constructor did throw, so move-construct the <code class="highlight"><c- n>T</c-></code> from <code class="highlight"><c- n>tmp</c-></code> back into the expected storage (which can’t throw as <code class="highlight"><c- n>is_nothrow_move_constructible_v</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code> is <code class="highlight">true</code>), and rethrow the exception.</p>
         </ul>
       </ul>
      <td>assigns <code class="highlight"><c- n>unexpected</c-><c- p>(</c-><c- n>rhs</c-><c- p>.</c-><c- n>error</c-><c- p>())</c-></code> to <code class="highlight"><c- n>unex</c-></code>
   </table>
   <p><em>Returns</em>: <code class="highlight"><c- o>*</c-><c- k>this</c-></code>.</p>
   <p><em>Ensures</em>: <code class="highlight"><c- b>bool</c-><c- p>(</c-><c- n>rhs</c-><c- p>)</c-> <c- o>==</c-> <c- b>bool</c-><c- p>(</c-><c- o>*</c-><c- k>this</c-><c- p>)</c-></code>.</p>
   <p><em>Throws</em>: Any exception thrown by the operations specified in the effect clause.</p>
   <p><em>Remarks</em>: If any exception is thrown, <code class="highlight"><c- b>bool</c-><c- p>(</c-><c- o>*</c-><c- k>this</c-><c- p>)</c-></code> and <code class="highlight"><c- b>bool</c-><c- p>(</c-><c- n>rhs</c-><c- p>)</c-></code> remain unchanged.</p>
   <p>If an exception is thrown during the call to <code class="highlight"><c- n>T</c-></code>'s or <code class="highlight"><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-></code>'s copy
constructor, no effect. If an exception is thrown during the call to <code class="highlight"><c- n>T</c-></code>'s or <code class="highlight"><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-></code>'s copy assignment, the state of its contained value is as defined
by the exception safety guarantee of <code class="highlight"><c- n>T</c-></code>'s or <code class="highlight"><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-></code>'s copy assignment.</p>
   <p>This operator is defined as deleted unless:</p>
   <ul>
    <li data-md>
     <p><code class="highlight"><c- n>T</c-></code> is <em>cv</em> <code class="highlight"><c- b>void</c-></code> and <code class="highlight"><c- n>is_copy_assignable_v</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></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>></c-></code> is <code class="highlight">true</code>; or</p>
    <li data-md>
     <p><code class="highlight"><c- n>T</c-></code> is not <em>cv</em> <code class="highlight"><c- b>void</c-></code> and <code class="highlight"><c- n>is_copy_assignable_v</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></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>></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>></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>></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>></c-></code> is <code class="highlight">true</code> or <code class="highlight"><c- n>is_nothrow_move_constructible_v</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code> is <code class="highlight">true</code>).</p>
   </ul>
<pre class="language-c++ highlight"><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>: See Table <em>editor-please-pick-a-number-1</em></p>
   <table>
    <caption>Table <em>editor-please-pick-a-number-1</em> — <code class="highlight"><c- k>operator</c-><c- o>=</c-><c- p>(</c-><c- n>expected</c-><c- o>&amp;&amp;</c-><c- p>)</c-></code> effects</caption>
    <tbody>
     <tr>
      <td>
      <td><code class="highlight"><c- b>bool</c-><c- p>(</c-><c- o>*</c-><c- k>this</c-><c- p>)</c-></code>
      <td><code class="highlight"><c- o>!</c-><c- b>bool</c-><c- p>(</c-><c- o>*</c-><c- k>this</c-><c- p>)</c-></code>
     <tr>
      <td><code class="highlight"><c- b>bool</c-><c- p>(</c-><c- n>rhs</c-><c- p>)</c-></code>
      <td>move assign <code class="highlight"><c- o>*</c-><c- n>rhs</c-></code> to <code class="highlight"><c- n>val</c-></code> if <code class="highlight"><c- n>T</c-></code> is not <em>cv</em> <code class="highlight"><c- b>void</c-></code>
      <td>
       <ul>
        <li data-md>
         <p>if <code class="highlight"><c- n>T</c-></code> is <em>cv</em> <code class="highlight"><c- b>void</c-></code> destroys <code class="highlight"><c- n>unex</c-></code> by calling <code class="highlight"><c- n>unexpect</c-><c- p>.</c-><c- o>~</c-><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-><c- p>()</c-></code></p>
        <li data-md>
         <p>otherwise if <code class="highlight"><c- n>is_nothrow_move_constructible_v</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code> is <code class="highlight">true</code></p>
         <ul>
          <li data-md>
           <p>destroys <code class="highlight"><c- n>unex</c-></code> by calling <code class="highlight"><c- n>unexpect</c-><c- p>.</c-><c- o>~</c-><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-><c- p>()</c-></code>,</p>
          <li data-md>
           <p>initializes <code class="highlight"><c- n>val</c-></code> as if direct-non-list-initializing an object of type <code class="highlight"><c- n>T</c-></code> with <code class="highlight"><c- o>*</c-><c- n>std</c-><c- o>::</c-><c- n>move</c-><c- p>(</c-><c- n>rhs</c-><c- p>)</c-></code>;</p>
         </ul>
        <li data-md>
         <p>otherwise</p>
         <ul>
          <li data-md>
           <p>move constructs an <code class="highlight"><c- n>unexpected_type</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-> <c- n>tmp</c-></code> from <code class="highlight"><c- n>unexpected</c-><c- p>(</c-><c- k>this</c-><c- o>-></c-><c- n>error</c-><c- p>())</c-></code> (which can’t throw as <code class="highlight"><c- n>E</c-></code> is nothrow-move-constructible),</p>
          <li data-md>
           <p>destroys <code class="highlight"><c- n>unex</c-></code> by calling <code class="highlight"><c- n>unexpect</c-><c- p>.</c-><c- o>~</c-><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-><c- p>()</c-></code>,</p>
          <li data-md>
           <p>initializes <code class="highlight"><c- n>val</c-></code> as if direct-non-list-initializing an object of type <code class="highlight"><c- n>T</c-></code> with <code class="highlight"><c- o>*</c-><c- n>std</c-><c- o>::</c-><c- n>move</c-><c- p>(</c-><c- n>rhs</c-><c- p>)</c-></code>. Either,</p>
          <li data-md>
           <p>The constructor didn’t throw, set <code class="highlight"><c- n>has_val</c-></code> to <code class="highlight">true</code>, or</p>
          <li data-md>
           <p>The constructor did throw, so move-construct the <code class="highlight"><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-></code> from <code class="highlight"><c- n>tmp</c-></code> back into the expected storage (which can’t throw as <code class="highlight"><c- n>E</c-></code> is nothrow-move-constructible), and rethrow the exception.</p>
         </ul>
       </ul>
     <tr>
      <td><code class="highlight"><c- o>!</c-><c- b>bool</c-><c- p>(</c-><c- n>rhs</c-><c- p>)</c-></code>
      <td>
       <ul>
        <li data-md>
         <p>if <code class="highlight"><c- n>T</c-></code> is <em>cv</em> <code class="highlight"><c- b>void</c-></code></p>
         <ul>
          <li data-md>
           <p>initializes <code class="highlight"><c- n>unex</c-></code> as if direct-non-list-initializing an object of type <code class="highlight"><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-></code> with <code class="highlight"><c- n>unexpected</c-><c- p>(</c-><c- n>move</c-><c- p>(</c-><c- n>rhs</c-><c- p>).</c-><c- n>error</c-><c- p>())</c-></code>. Either</p>
          <li data-md>
           <p>the constructor didn’t throw, set <code class="highlight"><c- n>has_val</c-></code> to <code class="highlight">false</code>, or</p>
          <li data-md>
           <p>the constructor did throw, and nothing was changed.</p>
         </ul>
        <li data-md>
         <p>otherwise if <code class="highlight"><c- n>is_nothrow_move_constructible_v</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-></code> is <code class="highlight">true</code></p>
         <ul>
          <li data-md>
           <p>destroys <code class="highlight"><c- n>val</c-></code> by calling <code class="highlight"><c- n>val</c-><c- p>.</c-><c- o>~</c-><c- n>T</c-><c- p>()</c-></code>,</p>
          <li data-md>
           <p>initializes <code class="highlight"><c- n>unex</c-></code> as if direct-non-list-initializing an object of type <code class="highlight"><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-></code> with <code class="highlight"><c- n>unexpected</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>
         </ul>
        <li data-md>
         <p>otherwise</p>
         <ul>
          <li data-md>
           <p>move constructs a <code class="highlight"><c- n>T</c-> <c- n>tmp</c-></code> from <code class="highlight"><c- o>*</c-><c- k>this</c-></code> (which can’t throw as <code class="highlight"><c- n>T</c-></code> is nothrow-move-constructible),</p>
          <li data-md>
           <p>destroys <code class="highlight"><c- n>val</c-></code> by calling <code class="highlight"><c- n>val</c-><c- p>.</c-><c- o>~</c-><c- n>T</c-><c- p>()</c-></code>,</p>
          <li data-md>
           <p>initializes <code class="highlight"><c- n>unex</c-></code> as if direct-non-list-initializing an object of type <code class="highlight"><c- n>unexpected_type</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-></code> with <code class="highlight"><c- n>unexpected</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>. Either,</p>
          <li data-md>
           <p>The constructor didn’t throw, so mark the expected as holding a <code class="highlight"><c- n>unexpected_type</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-></code>, or</p>
          <li data-md>
           <p>The constructor did throw, so move-construct the <code class="highlight"><c- n>T</c-></code> from <code class="highlight"><c- n>tmp</c-></code> back into the expected storage (which can’t throw as <code class="highlight"><c- n>T</c-></code> is nothrow-move-constructible), and rethrow the exception.</p>
         </ul>
       </ul>
      <td>move assign <code class="highlight"><c- n>unexpected</c-><c- p>(</c-><c- n>rhs</c-><c- p>.</c-><c- n>error</c-><c- p>())</c-></code> to <code class="highlight"><c- n>unex</c-></code>
   </table>
   <p><em>Returns</em>: <code class="highlight"><c- o>*</c-><c- k>this</c-></code>.</p>
   <p><em>Ensures</em>: <code class="highlight"><c- b>bool</c-><c- p>(</c-><c- n>rhs</c-><c- p>)</c-> <c- o>==</c-> <c- b>bool</c-><c- p>(</c-><c- o>*</c-><c- k>this</c-><c- p>)</c-></code>.</p>
   <p><em>Remarks</em>: The expression inside noexcept is equivalent to: <code class="highlight"><c- n>is_nothrow_move_assignable_v</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></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>></c-></code> is <code class="highlight">true</code>.</p>
   <p>If any exception is thrown, <code class="highlight"><c- b>bool</c-><c- p>(</c-><c- o>*</c-><c- k>this</c-><c- p>)</c-></code> and <code class="highlight"><c- b>bool</c-><c- p>(</c-><c- n>rhs</c-><c- p>)</c-></code> remain
unchanged. If an exception is thrown during the call to <code class="highlight"><c- n>T</c-></code>'s copy constructor,
no effect. If an exception is thrown during the call to <code class="highlight"><c- n>T</c-></code>'s copy assignment,
the state of its contained value is as defined by the exception safety guarantee
of <code class="highlight"><c- n>T</c-></code>'s copy assignment. If an exception is thrown during the call to <code class="highlight"><c- n>E</c-></code>'s
copy assignment, the state of its contained <code class="highlight"><c- n>unex</c-></code> is as defined by
the exception safety guarantee of <code class="highlight"><c- n>E</c-></code>'s copy assignment.</p>
   <p>This operator is defined as deleted unless:</p>
   <ul>
    <li data-md>
     <p><code class="highlight"><c- n>T</c-></code> is <em>cv</em> <code class="highlight"><c- b>void</c-></code> and <code class="highlight"><c- n>is_nothrow_move_constructible_v</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-></code> is <code class="highlight">true</code> and <code class="highlight"><c- n>is_nothrow_move_assignable_v</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-></code> is <code class="highlight">true</code>; or</p>
    <li data-md>
     <p><code class="highlight"><c- n>T</c-></code> is not <em>cv</em> <code class="highlight"><c- b>void</c-></code> and <code class="highlight"><c- n>is_move_constructible_v</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></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>></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>></c-></code> is <code class="highlight">true</code> and <code class="highlight"><c- n>is_nothrow_move_assignable_v</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-></code> is <code class="highlight">true</code>.</p>
   </ul>
<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>></c->
    <c- n>expected</c-><c- o>&lt;</c-><c- n>T</c-><c- p>,</c-> <c- n>E</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_void_v</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code> is <code class="highlight">false</code>; and</p>
    <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>></c-><c- p>,</c-> <c- n>remove_cvref_t</c-><c- o>&lt;</c-><c- n>U</c-><c- o>>></c-></code> is <code class="highlight">false</code>; and</p>
    <li data-md>
     <p><code class="highlight"><c- n>conjunction_v</c-><c- o>&lt;</c-><c- n>is_scalar</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-><c- p>,</c-> <c- n>is_same</c-><c- o>&lt;</c-><c- n>T</c-><c- p>,</c-> <c- n>decay_t</c-><c- o>&lt;</c-><c- n>U</c-><c- o>>>></c-></code> is <code class="highlight">false</code>; and</p>
    <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>></c-></code> is <code class="highlight">true</code>; and</p>
    <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>></c-></code> is <code class="highlight">true</code>; and</p>
    <li data-md>
     <p><code class="highlight"><c- n>is_nothrow_move_constructible_v</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-></code> is <code class="highlight">true</code>.</p>
   </ul>
   <p><em>Effects</em>: See Table <em>editor-please-pick-a-number-2</em></p>
   <table>
    <caption>Table <em>editor-please-pick-a-number-2</em> — <code class="highlight"><c- k>operator</c-><c- o>=</c-><c- p>(</c-><c- n>U</c-><c- o>&amp;&amp;</c-><c- p>)</c-></code> effects</caption>
    <tbody>
     <tr>
      <td><code class="highlight"><c- b>bool</c-><c- p>(</c-><c- o>*</c-><c- k>this</c-><c- p>)</c-></code>
      <td><code class="highlight"><c- o>!</c-><c- b>bool</c-><c- p>(</c-><c- o>*</c-><c- k>this</c-><c- p>)</c-></code>
     <tr>
      <td>If <code class="highlight"><c- b>bool</c-><c- p>(</c-><c- o>*</c-><c- k>this</c-><c- p>)</c-></code>, assigns <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>forward</c-><c- o>&lt;</c-><c- n>U</c-><c- o>></c-><c- p>(</c-><c- n>v</c-><c- p>)</c-></code> to <code class="highlight"><c- n>val</c-></code>
      <td>
       <p>if <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>></c-></code> is <code class="highlight">true</code></p>
       <ul>
        <li data-md>
         <p>destroys <code class="highlight"><c- n>unex</c-></code> by calling <code class="highlight"><c- n>unexpect</c-><c- p>.</c-><c- o>~</c-><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-><c- p>()</c-></code>,</p>
        <li data-md>
         <p>initializes <code class="highlight"><c- n>val</c-></code> as if direct-non-list-initializing an object of type <code class="highlight"><c- n>T</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>></c-><c- p>(</c-><c- n>v</c-><c- p>)</c-></code> and</p>
        <li data-md>
         <p>set <code class="highlight"><c- n>has_val</c-></code> to <code class="highlight">true</code>;</p>
       </ul>
       <p>otherwise</p>
       <ul>
        <li data-md>
         <p>move constructs an <code class="highlight"><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-> <c- n>tmp</c-></code> from <code class="highlight"><c- n>unexpected</c-><c- p>(</c-><c- k>this</c-><c- o>-></c-><c- n>error</c-><c- p>())</c-></code> (which can’t throw as <code class="highlight"><c- n>E</c-></code> is nothrow-move-constructible),</p>
        <li data-md>
         <p>destroys <code class="highlight"><c- n>unex</c-></code> by calling <code class="highlight"><c- n>unexpect</c-><c- p>.</c-><c- o>~</c-><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-><c- p>()</c-></code>,</p>
        <li data-md>
         <p>initializes <code class="highlight"><c- n>val</c-></code> as if direct-non-list-initializing an object of type <code class="highlight"><c- n>T</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>></c-><c- p>(</c-><c- n>v</c-><c- p>)</c-></code>. Either,</p>
         <ul>
          <li data-md>
           <p>the constructor didn’t throw, set <code class="highlight"><c- n>has_val</c-></code> to <code class="highlight">true</code>, that is set <code class="highlight"><c- n>has_val</c-></code> to <code class="highlight">true</code>, or</p>
          <li data-md>
           <p>the constructor did throw, so move construct the <code class="highlight"><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-></code> from <code class="highlight"><c- n>tmp</c-></code> back into the expected storage (which can’t throw as <code class="highlight"><c- n>E</c-></code> is nothrow-move-constructible), and re-throw the exception.</p>
         </ul>
       </ul>
   </table>
   <p><em>Returns</em>: <code class="highlight"><c- o>*</c-><c- k>this</c-></code>.</p>
   <p><em>Ensures</em>: <code class="highlight"><c- b>bool</c-><c- p>(</c-><c- o>*</c-><c- k>this</c-><c- p>)</c-></code> is <code class="highlight">true</code>.</p>
   <p><em>Remarks</em>: If any exception is thrown, <code class="highlight"><c- b>bool</c-><c- p>(</c-><c- o>*</c-><c- k>this</c-><c- p>)</c-></code> remains
 unchanged. If an exception is thrown during the call to <code class="highlight"><c- n>T</c-></code>'s constructor, no
 effect. If an exception is thrown during the call to <code class="highlight"><c- n>T</c-></code>'s copy assignment, the
 state of its contained value is as defined by the exception safety guarantee of <code class="highlight"><c- n>T</c-></code>'s copy assignment.</p>
<pre class="language-c++ highlight"><c- n>template</c-><c- o>&lt;</c-><c- n>class</c-> <c- n>G</c-> <c- o>=</c-> <c- n>E</c-><c- o>></c->
    <c- n>expected</c-><c- o>&lt;</c-><c- n>T</c-><c- p>,</c-> <c- n>E</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>>&amp;</c-> <c- n>e</c-><c- p>);</c->
</pre>
   <p><em>Constraints</em>: <code class="highlight"><c- n>is_nothrow_copy_constructible_v</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></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>></c-></code> is <code class="highlight">true</code>.</p>
   <p><em>Effects</em>: See Table <em>editor-please-pick-a-number-3</em></p>
   <table>
    <caption>Table <em>editor-please-pick-a-number-3</em> — <code class="highlight"><c- k>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>>&amp;</c-><c- p>)</c-></code> effects</caption>
    <tbody>
     <tr>
      <td><code class="highlight"><c- b>bool</c-><c- p>(</c-><c- o>*</c-><c- k>this</c-><c- p>)</c-></code>
      <td><code class="highlight"><c- o>!</c-><c- b>bool</c-><c- p>(</c-><c- o>*</c-><c- k>this</c-><c- p>)</c-></code>
     <tr>
      <td>assigns <code class="highlight"><c- n>unexpected</c-><c- p>(</c-><c- n>e</c-><c- p>.</c-><c- n>error</c-><c- p>())</c-></code> to <code class="highlight"><c- n>unex</c-></code>
      <td>
       <ul>
        <li data-md>
         <p>destroys <code class="highlight"><c- n>val</c-></code> by calling <code class="highlight"><c- n>val</c-><c- p>.</c-><c- o>~</c-><c- n>T</c-><c- p>()</c-></code> if <code class="highlight"><c- n>T</c-></code> is not <em>cv</em> <code class="highlight"><c- b>void</c-></code>,</p>
        <li data-md>
         <p>initializes <code class="highlight"><c- n>unex</c-></code> as if direct-non-list-initializing an object of type <code class="highlight"><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-></code> with <code class="highlight"><c- n>unexpected</c-><c- p>(</c-><c- n>e</c-><c- p>.</c-><c- n>error</c-><c- p>())</c-></code> and set <code class="highlight"><c- n>has_val</c-></code> to <code class="highlight">false</code>.</p>
       </ul>
   </table>
   <p><em>Returns</em>: <code class="highlight"><c- o>*</c-><c- k>this</c-></code>.</p>
   <p><em>Ensures</em>: <code class="highlight"><c- b>bool</c-><c- p>(</c-><c- o>*</c-><c- k>this</c-><c- p>)</c-></code> is <code class="highlight">false</code>.</p>
   <p><em>Remarks</em>: If any exception is thrown, <code class="highlight"><c- b>bool</c-><c- p>(</c-><c- o>*</c-><c- k>this</c-><c- p>)</c-></code> remains unchanged.</p>
<pre class="language-c++ highlight"><c- n>expected</c-><c- o>&lt;</c-><c- n>T</c-><c- p>,</c-> <c- n>E</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>>&amp;&amp;</c-> <c- n>e</c-><c- p>);</c->
</pre>
   <p><em>Effects</em>: See Table <em>editor-please-pick-a-number-4</em></p>
   <table>
    <caption>Table <em>editor-please-pick-a-number-4</em> — <code class="highlight"><c- k>operator</c-><c- o>=</c-><c- p>(</c-><c- n>unexpected</c-><c- o>&lt;</c-><c- n>G</c-><c- o>>&amp;&amp;</c-> <c- n>e</c-><c- p>)</c-></code> effects</caption>
    <tbody>
     <tr>
      <td><code class="highlight"><c- b>bool</c-><c- p>(</c-><c- o>*</c-><c- k>this</c-><c- p>)</c-></code>
      <td><code class="highlight"><c- o>!</c-><c- b>bool</c-><c- p>(</c-><c- o>*</c-><c- k>this</c-><c- p>)</c-></code>
     <tr>
      <td>
       <ul>
        <li data-md>
         <p>destroys <code class="highlight"><c- n>val</c-></code> by calling <code class="highlight"><c- n>val</c-><c- p>.</c-><c- o>~</c-><c- n>T</c-><c- p>()</c-></code> if <code class="highlight"><c- n>T</c-></code> is not <em>cv</em> <code class="highlight"><c- b>void</c-></code>,</p>
        <li data-md>
         <p>initializes <code class="highlight"><c- n>unex</c-></code> as if direct-non-list-initializing an object of type <code class="highlight"><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-></code> with <code class="highlight"><c- n>unexpected</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>move</c-><c- p>(</c-><c- n>e</c-><c- p>.</c-><c- n>error</c-><c- p>()))</c-></code> and set <code class="highlight"><c- n>has_val</c-></code> to <code class="highlight">false</code>.</p>
       </ul>
      <td>move assign <code class="highlight"><c- n>unexpected</c-><c- p>(</c-><c- n>e</c-><c- p>.</c-><c- n>error</c-><c- p>())</c-></code> to <code class="highlight"><c- n>unex</c-></code>
   </table>
   <p><em>Constraints</em>: <code class="highlight"><c- n>is_nothrow_move_constructible_v</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></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>></c-></code> is <code class="highlight">true</code>.</p>
   <p><em>Returns</em>: <code class="highlight"><c- o>*</c-><c- k>this</c-></code>.</p>
   <p><em>Ensures</em>: <code class="highlight"><c- b>bool</c-><c- p>(</c-><c- o>*</c-><c- k>this</c-><c- p>)</c-></code> is <code class="highlight">false</code>.</p>
   <p><em>Remarks</em>: If any exception is thrown, <code class="highlight"><c- b>bool</c-><c- p>(</c-><c- o>*</c-><c- k>this</c-><c- p>)</c-></code> remains unchanged.</p>
<pre class="language-c++ highlight"><c- b>void</c-> <c- n>expected</c-><c- o>&lt;</c-><c- b>void</c-><c- p>,</c-> <c- n>E</c-><c- o>>::</c-><c- n>emplace</c-><c- p>();</c->
</pre>
   <p><em>Effects</em>:</p>
   <p>If <code class="highlight"><c- o>!</c-><c- b>bool</c-><c- p>(</c-><c- o>*</c-><c- k>this</c-><c- p>)</c-></code></p>
   <ul>
    <li data-md>
     <p>destroys <code class="highlight"><c- n>unex</c-></code> by calling <code class="highlight"><c- n>unexpect</c-><c- p>.</c-><c- o>~</c-><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-><c- p>()</c-></code>,</p>
    <li data-md>
     <p>set <code class="highlight"><c- n>has_val</c-></code> to <code class="highlight">true</code></p>
   </ul>
   <p><em>Ensures</em>: <code class="highlight"><c- b>bool</c-><c- p>(</c-><c- o>*</c-><c- k>this</c-><c- p>)</c-></code> is <code class="highlight">true</code>.</p>
   <p><em>Throws</em>: Nothing</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>></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->
</pre>
   <p><em>Constraints</em>: <code class="highlight"><c- n>T</c-></code> is not <em>cv</em> <code class="highlight"><c- b>void</c-></code> and <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>></c-></code> is <code class="highlight">true</code>.</p>
   <p><em>Effects</em>:</p>
   <p>If <code class="highlight"><c- b>bool</c-><c- p>(</c-><c- o>*</c-><c- k>this</c-><c- p>)</c-></code>, assigns <code class="highlight"><c- n>val</c-></code> as if
constructing an object of type <code class="highlight"><c- n>T</c-></code> with the arguments <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>forward</c-><c- o>&lt;</c-><c- n>Args</c-><c- o>></c-><c- p>(</c-><c- n>args</c-><c- p>)...</c-></code></p>
   <p>otherwise if <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>></c-></code> is <code class="highlight">true</code></p>
   <ul>
    <li data-md>
     <p>destroys <code class="highlight"><c- n>unex</c-></code> by calling <code class="highlight"><c- n>unexpect</c-><c- p>.</c-><c- o>~</c-><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-><c- p>()</c-></code>,</p>
    <li data-md>
     <p>initializes <code class="highlight"><c- n>val</c-></code> as if direct-non-list-initializing an object of type <code class="highlight"><c- n>T</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>></c-><c- p>(</c-><c- n>args</c-><c- p>)...</c-></code> and</p>
    <li data-md>
     <p>set <code class="highlight"><c- n>has_val</c-></code> to <code class="highlight">true</code>;</p>
   </ul>
   <p>otherwise if <code class="highlight"><c- n>is_nothrow_move_constructible_v</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code> is <code class="highlight">true</code></p>
   <ul>
    <li data-md>
     <p>constructs a <code class="highlight"><c- n>T</c-> <c- n>tmp</c-></code> from <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>forward</c-><c- o>&lt;</c-><c- n>Args</c-><c- o>></c-><c- p>(</c-><c- n>args</c-><c- p>)...</c-></code> (which can throw),</p>
    <li data-md>
     <p>destroys <code class="highlight"><c- n>unex</c-></code> by calling <code class="highlight"><c- n>unexpect</c-><c- p>.</c-><c- o>~</c-><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-><c- p>()</c-></code>,</p>
    <li data-md>
     <p>initializes <code class="highlight"><c- n>val</c-></code> as if direct-non-list-initializing an object of type <code class="highlight"><c- n>T</c-></code> with <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>move</c-><c- p>(</c-><c- n>tmp</c-><c- p>)</c-></code> (which cannot throw) and</p>
    <li data-md>
     <p>set <code class="highlight"><c- n>has_val</c-></code> to <code class="highlight">true</code>;</p>
   </ul>
   <p>otherwise</p>
   <ul>
    <li data-md>
     <p>move constructs an <code class="highlight"><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-> <c- n>tmp</c-></code> from <code class="highlight"><c- n>unexpected</c-><c- p>(</c-><c- k>this</c-><c- o>-></c-><c- n>error</c-><c- p>())</c-></code> ,</p>
    <li data-md>
     <p>destroys <code class="highlight"><c- n>unex</c-></code> by calling <code class="highlight"><c- n>unexpect</c-><c- p>.</c-><c- o>~</c-><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-><c- p>()</c-></code>,</p>
    <li data-md>
     <p>initializes <code class="highlight"><c- n>val</c-></code> as if direct-non-list-initializing an object of type <code class="highlight"><c- n>T</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>></c-><c- p>(</c-><c- n>args</c-><c- p>)...</c-></code>. Either,</p>
     <ul>
      <li data-md>
       <p>the constructor didn’t throw, set <code class="highlight"><c- n>has_val</c-></code> to <code class="highlight">true</code>, or</p>
      <li data-md>
       <p>the constructor did throw, so move-construct the <code class="highlight"><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-></code> from <code class="highlight"><c- n>tmp</c-></code> back into the expected storage (which can’t throw as <code class="highlight"><c- n>E</c-></code> is nothrow-move-constructible), and re-throw the exception.</p>
     </ul>
   </ul>
   <p><em>Ensures</em>: <code class="highlight"><c- b>bool</c-><c- p>(</c-><c- o>*</c-><c- k>this</c-><c- p>)</c-></code> is <code class="highlight">true</code>.</p>
   <p><em>Returns:</em> A reference to the new contained value <code class="highlight"><c- n>val</c-></code>.</p>
   <p><em>Throws</em>: Any exception thrown by the operations specified in the effect clause.</p>
   <p><em>Remarks</em>: If an exception is thrown during the call to <code class="highlight"><c- n>T</c-></code>'s assignment, nothing
changes.</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>></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>></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>T</c-></code> is not <em>cv</em> <code class="highlight"><c- b>void</c-></code> and <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>>&amp;</c-><c- p>,</c-> <c- n>Args</c-><c- p>...</c-><c- o>></c-></code> is <code class="highlight">true</code>.</p>
   <p><em>Effects</em>:</p>
   <p>If <code class="highlight"><c- b>bool</c-><c- p>(</c-><c- o>*</c-><c- k>this</c-><c- p>)</c-></code>, assigns <code class="highlight"><c- n>val</c-></code> as if
constructing an object of type <code class="highlight"><c- n>T</c-></code> with the arguments <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>></c-><c- p>(</c-><c- n>args</c-><c- p>)...</c-></code></p>
   <p>otherwise if <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>>&amp;</c-><c- p>,</c-> <c- n>Args</c-><c- p>...</c-><c- o>></c-></code> is <code class="highlight">true</code></p>
   <ul>
    <li data-md>
     <p>destroys <code class="highlight"><c- n>unex</c-></code> by calling <code class="highlight"><c- n>unexpect</c-><c- p>.</c-><c- o>~</c-><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-><c- p>()</c-></code>,</p>
    <li data-md>
     <p>initializes <code class="highlight"><c- n>val</c-></code> as if direct-non-list-initializing an object of type <code class="highlight"><c- n>T</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>></c-><c- p>(</c-><c- n>args</c-><c- p>)...</c-></code> and</p>
    <li data-md>
     <p>set <code class="highlight"><c- n>has_val</c-></code> to <code class="highlight">true</code>;</p>
   </ul>
   <p>otherwise if <code class="highlight"><c- n>is_nothrow_move_constructible_v</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code> is <code class="highlight">true</code></p>
   <ul>
    <li data-md>
     <p>constructs a <code class="highlight"><c- n>T</c-> <c- n>tmp</c-></code> from <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>></c-><c- p>(</c-><c- n>args</c-><c- p>)...</c-></code> (which can throw),</p>
    <li data-md>
     <p>destroys <code class="highlight"><c- n>unex</c-></code> by calling <code class="highlight"><c- n>unexpect</c-><c- p>.</c-><c- o>~</c-><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-><c- p>()</c-></code>,</p>
    <li data-md>
     <p>initializes <code class="highlight"><c- n>val</c-></code> as if direct-non-list-initializing an object of type <code class="highlight"><c- n>T</c-></code> with <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>move</c-><c- p>(</c-><c- n>tmp</c-><c- p>)</c-></code> (which cannot throw) and</p>
    <li data-md>
     <p>set <code class="highlight"><c- n>has_val</c-></code> to <code class="highlight">true</code>;</p>
   </ul>
   <p>otherwise</p>
   <ul>
    <li data-md>
     <p>move constructs an <code class="highlight"><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-> <c- n>tmp</c-></code> from <code class="highlight"><c- n>unexpected</c-><c- p>(</c-><c- k>this</c-><c- o>-></c-><c- n>error</c-><c- p>())</c-></code> ,</p>
    <li data-md>
     <p>destroys <code class="highlight"><c- n>unex</c-></code> by calling <code class="highlight"><c- n>unexpect</c-><c- p>.</c-><c- o>~</c-><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-><c- p>()</c-></code>,</p>
    <li data-md>
     <p>initializes <code class="highlight"><c- n>val</c-></code> as if direct-non-list-initializing an object of type <code class="highlight"><c- n>T</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>></c-><c- p>(</c-><c- n>args</c-><c- p>)...</c-></code>. Either,</p>
     <ul>
      <li data-md>
       <p>the constructor didn’t throw, set <code class="highlight"><c- n>has_val</c-></code> to <code class="highlight">true</code>, or</p>
      <li data-md>
       <p>the constructor did throw, so move-construct the <code class="highlight"><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-></code> from <code class="highlight"><c- n>tmp</c-></code> back into the expected storage (which can’t throw as <code class="highlight"><c- n>E</c-></code> is nothrow-move-constructible), and re-throw the exception.</p>
     </ul>
   </ul>
   <p><em>Ensures</em>: <code class="highlight"><c- b>bool</c-><c- p>(</c-><c- o>*</c-><c- k>this</c-><c- p>)</c-></code> is <code class="highlight">true</code>.</p>
   <p><em>Returns:</em> A reference to the new contained value <code class="highlight"><c- n>val</c-></code>.</p>
   <p><em>Throws</em>: Any exception thrown by the operations specified in the effect clause.</p>
   <p><em>Remarks</em>: If an exception is thrown during the call to <code class="highlight"><c- n>T</c-></code>'s assignment nothing
changes.</p>
   <h3 class="heading settled" data-level="5.6" id="expected.object.swap"><span class="secno">5.6. </span><span class="content">�.�.4.4 Swap [<em>expected.object.swap</em>]</span><a class="self-link" href="#expected.object.swap"></a></h3>
<pre class="language-c++ highlight"><c- b>void</c-> <c- nf>swap</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>>&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>Lvalues of type <code class="highlight"><c- n>T</c-></code> are <code class="highlight"><c- n>Swappable</c-></code>; and</p>
    <li data-md>
     <p>Lvalues of type <code class="highlight"><c- n>E</c-></code> are <code class="highlight"><c- n>Swappable</c-></code>; and</p>
    <li data-md>
     <p><code class="highlight"><c- n>is_void_v</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code> is <code class="highlight">true</code> or <code class="highlight"><c- n>is_void_v</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code> is <code class="highlight">false</code> and either:</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>></c-></code> is <code class="highlight">true</code>; or</p>
      <li data-md>
       <p><code class="highlight"><c- n>is_move_constructible_v</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-></code> is <code class="highlight">true</code>.</p>
     </ul>
   </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>&lt;</c-><c- n>T</c-><c- p>,</c-> <c- n>E</c-><c- o>>&amp;</c-><c- p>)</c-></code> effects</caption>
    <tbody>
     <tr>
      <td>
      <td><code class="highlight"><c- b>bool</c-><c- p>(</c-><c- o>*</c-><c- k>this</c-><c- p>)</c-></code>
      <td><code class="highlight"><c- o>!</c-><c- b>bool</c-><c- p>(</c-><c- o>*</c-><c- k>this</c-><c- p>)</c-></code>
     <tr>
      <td><code class="highlight"><c- b>bool</c-><c- p>(</c-><c- n>rhs</c-><c- p>)</c-></code>
      <td>if <code class="highlight"><c- n>T</c-></code> is not <em>cv</em> <code class="highlight"><c- b>void</c-></code> calls <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>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>
     <tr>
      <td><code class="highlight"><c- o>!</c-><c- b>bool</c-><c- p>(</c-><c- n>rhs</c-><c- p>)</c-></code>
      <td>
       <ul>
        <li data-md>
         <p>if <code class="highlight"><c- n>T</c-></code> is <em>cv</em> <code class="highlight"><c- b>void</c-></code></p>
         <ul>
          <li data-md>
           <p>initializes <code class="highlight"><c- n>unex</c-></code> as if direct-non-list-initializing an object of type <code class="highlight"><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-></code> with <code class="highlight"><c- n>unexpected</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-></code>. Either</p>
          <li data-md>
           <p>the constructor didn’t throw, set <code class="highlight"><c- n>has_val</c-></code> to <code class="highlight">false</code>, destroys <code class="highlight"><c- n>rhs</c-><c- p>.</c-><c- n>unexpect</c-></code> by calling <code class="highlight"><c- n>rhs</c-><c- p>.</c-><c- n>unexpect</c-><c- p>.</c-><c- o>~</c-><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-><c- p>()</c-></code> set <code class="highlight"><c- n>rhs</c-><c- p>.</c-><c- n>has_val</c-></code> to <code class="highlight">true</code>.</p>
          <li data-md>
           <p>the constructor did throw, rethrow the exception.</p>
         </ul>
        <li data-md>
         <p>otherwise if <code class="highlight"><c- n>is_nothrow_move_constructible_v</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-></code> is <code class="highlight">true</code>,</p>
         <ul>
          <li data-md>
           <p>the <code class="highlight"><c- n>unex</c-></code> of <code class="highlight"><c- n>rhs</c-></code> is moved to a temporary variable <code class="highlight"><c- n>tmp</c-></code> of type <code class="highlight"><c- n>unexpected_type</c-></code>,</p>
          <li data-md>
           <p>followed by destruction of <code class="highlight"><c- n>unex</c-></code> as if by <code class="highlight"><c- n>rhs</c-><c- p>.</c-><c- n>unexpect</c-><c- p>.</c-><c- o>~</c-><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-><c- p>()</c-></code>,</p>
          <li data-md>
           <p><code class="highlight"><c- n>rhs</c-><c- p>.</c-><c- n>val</c-></code> is direct-initialized from <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>move</c-><c- p>(</c-><c- o>*</c-><c- k>this</c-><c- p>)</c-></code>. Either</p>
           <ul>
            <li data-md>
             <p>the constructor didn’t throw</p>
             <ul>
              <li data-md>
               <p>destroy <code class="highlight"><c- n>val</c-></code> as if by <code class="highlight"><c- k>this</c-><c- o>-></c-><c- n>val</c-><c- p>.</c-><c- o>~</c-><c- n>T</c-><c- p>()</c-></code>,</p>
              <li data-md>
               <p>the <code class="highlight"><c- n>unex</c-></code> of <code class="highlight"><c- k>this</c-></code> is direct-initialized from <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>move</c-><c- p>(</c-><c- n>tmp</c-><c- p>)</c-></code>, after this, <code class="highlight"><c- k>this</c-></code> does not contain a value; and <code class="highlight"><c- b>bool</c-><c- p>(</c-><c- n>rhs</c-><c- p>)</c-></code>.</p>
             </ul>
            <li data-md>
             <p>the constructor did throw, so move-construct the <code class="highlight"><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-></code> from <code class="highlight"><c- n>tmp</c-></code> back into the expected storage (which can’t throw as <code class="highlight"><c- n>E</c-></code> is nothrow-move-constructible), and re-throw the exception.</p>
           </ul>
         </ul>
        <li data-md>
         <p>otherwise if <code class="highlight"><c- n>is_nothrow_move_constructible_v</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code> is <code class="highlight">true</code>,</p>
         <ul>
          <li data-md>
           <p><code class="highlight"><c- n>val</c-></code> is moved to a temporary variable <code class="highlight"><c- n>tmp</c-></code> of type <code class="highlight"><c- n>T</c-></code>,</p>
          <li data-md>
           <p>followed by destruction of <code class="highlight"><c- n>val</c-></code> as if by <code class="highlight"><c- n>val</c-><c- p>.</c-><c- o>~</c-><c- n>T</c-><c- p>()</c-></code>,</p>
          <li data-md>
           <p>the <code class="highlight"><c- n>unex</c-></code> is direct-initialized from <code class="highlight"><c- n>unexpected</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>move</c-><c- p>(</c-><c- n>other</c-><c- p>.</c-><c- n>error</c-><c- p>()))</c-></code>. Either</p>
           <ul>
            <li data-md>
             <p>the constructor didn’t throw</p>
             <ul>
              <li data-md>
               <p>destroy <code class="highlight"><c- n>rhs</c-><c- p>.</c-><c- n>unexpect</c-></code> as if by <code class="highlight"><c- n>rhs</c-><c- p>.</c-><c- n>unexpect</c-><c- p>.</c-><c- o>~</c-><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-><c- p>()</c-></code>,</p>
              <li data-md>
               <p><code class="highlight"><c- n>rhs</c-><c- p>.</c-><c- n>val</c-></code> is direct-initialized from <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>move</c-><c- p>(</c-><c- n>tmp</c-><c- p>)</c-></code>, after this, <code class="highlight"><c- k>this</c-></code> does not contain a value; and <code class="highlight"><c- b>bool</c-><c- p>(</c-><c- n>rhs</c-><c- p>)</c-></code>.</p>
             </ul>
            <li data-md>
             <p>the constructor did throw, so move-construct the <code class="highlight"><c- n>T</c-></code> from <code class="highlight"><c- n>tmp</c-></code> back into the expected storage (which can’t throw as <code class="highlight"><c- n>T</c-></code> is nothrow-move-constructible), and re-throw the exception.</p>
           </ul>
         </ul>
        <li data-md>
         <p>otherwise, the function is not defined.</p>
       </ul>
      <td>calls <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>unexpect</c-><c- p>,</c-> <c- n>rhs</c-><c- p>.</c-><c- n>unexpect</c-><c- p>)</c-></code>
   </table>
   <p><em>Throws</em>: Any exceptions that the expressions in the Effects clause throw.</p>
   <p><em>Remarks</em>: The expression inside noexcept is equivalent to: <code class="highlight"><c- n>is_nothrow_move_constructible_v</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code> is <code class="highlight">true</code> and <code class="highlight"><c- n>is_nothrow_swappable_v</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></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>></c-></code> is <code class="highlight">true</code> and <code class="highlight"><c- n>is_nothrow_swappable_v</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-></code> is <code class="highlight">true</code>.</p>
   <h3 class="heading settled" data-level="5.7" id="expected.object.observe"><span class="secno">5.7. </span><span class="content">�.�.4.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>-></c-><c- p>()</c-> <c- k>const</c-><c- p>;</c->
<c- n>T</c-><c- o>*</c-> <c- n>operator</c-><c- o>-></c-><c- p>();</c->
</pre>
   <p><em>Constraints</em>: <code class="highlight"><c- n>T</c-></code> is not <em>cv</em> <code class="highlight"><c- b>void</c-></code>.</p>
   <p><em>Expects</em>: <code class="highlight"><c- b>bool</c-><c- p>(</c-><c- o>*</c-><c- k>this</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- p>;</c->
<c- n>T</c-><c- o>&amp;</c-> <c- n>operator</c-><c- o>*</c-><c- p>()</c-> <c- o>&amp;</c-><c- p>;</c->
</pre>
   <p><em>Constraints</em>: <code class="highlight"><c- n>T</c-></code> is not <em>cv</em> <code class="highlight"><c- b>void</c-></code>.</p>
   <p><em>Expects</em>: <code class="highlight"><c- b>bool</c-><c- p>(</c-><c- o>*</c-><c- k>this</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- 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- p>;</c->
</pre>
   <p><em>Constraints</em>: <code class="highlight"><c- n>T</c-></code> is not <em>cv</em> <code class="highlight"><c- b>void</c-></code>.</p>
   <p><em>Expects</em>: <code class="highlight"><c- b>bool</c-><c- p>(</c-><c- o>*</c-><c- k>this</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- nf>bool</c-><c- p>()</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>bool</c-> <c- nf>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>expected</c-><c- o>&lt;</c-><c- b>void</c-><c- p>,</c-> <c- n>E</c-><c- o>>::</c-><c- n>value</c-><c- p>()</c-> <c- k>const</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- o>!</c-><c- b>bool</c-><c- p>(</c-><c- o>*</c-><c- k>this</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>expected</c-><c- o>::</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>expected</c-><c- o>::</c-><c- n>value</c-><c- p>()</c-> <c- o>&amp;</c-><c- p>;</c->
</pre>
   <p><em>Constraints</em>: <code class="highlight"><c- n>T</c-></code> is not <em>cv</em> <code class="highlight"><c- b>void</c-></code>.</p>
   <p><em>Returns</em>: <code class="highlight"><c- n>val</c-></code>, if <code class="highlight"><c- b>bool</c-><c- p>(</c-><c- o>*</c-><c- k>this</c-><c- p>)</c-></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- o>!</c-><c- b>bool</c-><c- p>(</c-><c- o>*</c-><c- k>this</c-><c- p>)</c-></code>.</p>
<pre class="language-c++ highlight"><c- n>constexpr</c-> <c- n>T</c-><c- o>&amp;&amp;</c-> <c- n>expected</c-><c- o>::</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>expected</c-><c- o>::</c-><c- n>value</c-><c- p>()</c-> <c- k>const</c-><c- o>&amp;&amp;</c-><c- p>;</c->
</pre>
   <p><em>Constraints</em>: <code class="highlight"><c- n>T</c-></code> is not <em>cv</em> <code class="highlight"><c- b>void</c-></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>, if <code class="highlight"><c- b>bool</c-><c- p>(</c-><c- o>*</c-><c- k>this</c-><c- p>)</c-></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- o>!</c-><c- b>bool</c-><c- p>(</c-><c- o>*</c-><c- k>this</c-><c- p>)</c-></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>Expects</em>: <code class="highlight"><c- b>bool</c-><c- p>(</c-><c- o>*</c-><c- k>this</c-><c- p>)</c-></code> is <code class="highlight">false</code>.</p>
   <p><em>Returns</em>: <code class="highlight"><c- n>unexpect</c-><c- p>.</c-><c- n>value</c-><c- p>()</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>Expects</em>: <code class="highlight"><c- b>bool</c-><c- p>(</c-><c- o>*</c-><c- k>this</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>unexpect</c-><c- p>.</c-><c- n>value</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>></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>Returns</em>: <code class="highlight"><c- b>bool</c-><c- p>(</c-><c- o>*</c-><c- k>this</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>></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>></c-><c- p>(</c-><c- n>v</c-><c- p>));</c-></code>.</p>
   <p><em>Remarks</em>: If <code class="highlight"><c- n>is_copy_constructible_v</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code> is <code class="highlight">true</code>and <code class="highlight"><c- n>is_convertible_v</c-><c- o>&lt;</c-><c- n>U</c-><c- p>,</c-> <c- n>T</c-><c- o>></c-></code> is <code class="highlight">false</code> the program is ill-formed.</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>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>Returns</em>: <code class="highlight"><c- b>bool</c-><c- p>(</c-><c- o>*</c-><c- k>this</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>></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>></c-><c- p>(</c-><c- n>v</c-><c- p>));</c-></code>.</p>
   <p><em>Remarks</em>: If <code class="highlight"><c- n>is_move_constructible_v</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code> is <code class="highlight">true</code> and <code class="highlight"><c- n>is_convertible_v</c-><c- o>&lt;</c-><c- n>U</c-><c- p>,</c-> <c- n>T</c-><c- o>></c-></code> is <code class="highlight">false</code> the program is ill-formed.</p>
   <h3 class="heading settled" data-level="5.8" id="expected.equality_op"><span class="secno">5.8. </span><span class="content">�.�.4.6 Expected Equality operators [<em>expected.equality_op</em>]</span><a class="self-link" href="#expected.equality_op"></a></h3>
<pre class="language-c++ highlight"><c- n>template</c-><c- o>&lt;</c-><c- n>class</c-> <c- n>T1</c-><c- p>,</c-> <c- n>class</c-> <c- n>E1</c-><c- p>,</c-> <c- n>class</c-> <c- n>T2</c-><c- p>,</c-> <c- n>class</c-> <c- n>E2</c-><c- o>></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>&lt;</c-><c- n>T1</c-><c- p>,</c-> <c- n>E1</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>>&amp;</c-> <c- n>y</c-><c- p>);</c->
</pre>
   <p><em>Expects</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- b>bool</c-><c- p>(</c-><c- n>x</c-><c- p>)</c-> <c- o>!=</c-> <c- b>bool</c-><c- p>(</c-><c- n>y</c-><c- p>)</c-></code>, <code class="highlight">false</code>; otherwise if <code class="highlight"><c- b>bool</c-><c- p>(</c-><c- n>x</c-><c- p>)</c-> <c- o>==</c-> false</code>, <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>; otherwise <code class="highlight">true</code> if <code class="highlight"><c- n>T1</c-></code> and <code class="highlight"><c- n>T2</c-></code> are <em>cv</em> <code class="highlight"><c- b>void</c-></code> or <code class="highlight"><c- o>*</c-><c- n>x</c-> <c- o>==</c-> <c- o>*</c-><c- n>y</c-></code> otherwise.</p>
   <p><em>Remarks</em>: Specializations of this function template, for which <code class="highlight"><c- n>T1</c-></code> and <code class="highlight"><c- n>T2</c-></code> are <em>cv</em> <code class="highlight"><c- b>void</c-></code> or <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> is a core constant expression, are
constexpr functions.</p>
<pre class="language-c++ highlight"><c- n>template</c-><c- o>&lt;</c-><c- n>class</c-> <c- n>T1</c-><c- p>,</c-> <c- n>class</c-> <c- n>E1</c-><c- p>,</c-> <c- n>class</c-> <c- n>T2</c-><c- p>,</c-> <c- n>class</c-> <c- n>E2</c-><c- o>></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>&lt;</c-><c- n>T1</c-><c- p>,</c-> <c- n>E1</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>>&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- b>bool</c-><c- p>(</c-><c- n>x</c-><c- p>)</c-> <c- o>!=</c-> <c- b>bool</c-><c- p>(</c-><c- n>y</c-><c- p>)</c-></code>, <code class="highlight">true</code>; otherwise if <code class="highlight"><c- b>bool</c-><c- p>(</c-><c- n>x</c-><c- p>)</c-> <c- o>==</c-> false</code>, <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>; otherwise <code class="highlight">true</code> if <code class="highlight"><c- n>T1</c-></code> and <code class="highlight"><c- n>T2</c-></code> are <em>cv</em> <code class="highlight"><c- b>void</c-></code> or <code class="highlight"><c- o>*</c-><c- n>x</c-> <c- o>!=</c-> <c- o>*</c-><c- n>y</c-></code>.</p>
   <p><em>Remarks</em>: Specializations of this function template, for which <code class="highlight"><c- n>T1</c-></code> and <code class="highlight"><c- n>T2</c-></code> are <em>cv</em> <code class="highlight"><c- b>void</c-></code> or <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> is a core
constant expression, are constexpr functions.</p>
   <h3 class="heading settled" data-level="5.9" id="expected.comparison_T"><span class="secno">5.9. </span><span class="content">�.�.4.7 Comparison with <code class="highlight"><c- n>T</c-></code> [<em>expected.comparison_T</em>]</span><a class="self-link" href="#expected.comparison_T"></a></h3>
<pre class="language-c++ highlight"><c- n>template</c-><c- o>&lt;</c-><c- n>class</c-> <c- n>T1</c-><c- p>,</c-> <c- n>class</c-> <c- n>E1</c-><c- p>,</c-> <c- n>class</c-> <c- n>T2</c-><c- o>></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>&lt;</c-><c- n>T1</c-><c- p>,</c-> <c- n>E1</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->
<c- n>template</c-><c- o>&lt;</c-><c- n>class</c-> <c- n>T1</c-><c- p>,</c-> <c- n>class</c-> <c- n>E1</c-><c- p>,</c-> <c- n>class</c-> <c- n>T2</c-><c- o>></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>T2</c-><c- o>&amp;</c-> <c- n>v</c-><c- p>,</c-> <c- k>const</c-> <c- n>expected</c-><c- o>&lt;</c-><c- n>T1</c-><c- p>,</c-> <c- n>E1</c-><c- o>>&amp;</c-> <c- n>x</c-><c- p>);</c->
</pre>
   <p><em>Mandates</em>: <code class="highlight"><c- n>T1</c-></code> and <code class="highlight"><c- n>T2</c-></code> are not <em>cv</em> <code class="highlight"><c- b>void</c-></code> and 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>EqualityComparable</em>. - <em>end note</em>]</p>
   <p><em>Returns</em>: <code class="highlight"><c- b>bool</c-><c- p>(</c-><c- n>x</c-><c- p>)</c-> <c- o>?</c-> <c- o>*</c-><c- n>x</c-> <c- o>==</c-> <c- nl>v</c-> <c- p>:</c-> false<c- p>;</c-></code>.</p>
<pre class="language-c++ highlight"><c- n>template</c-><c- o>&lt;</c-><c- n>class</c-> <c- n>T1</c-><c- p>,</c-> <c- n>class</c-> <c- n>E1</c-><c- p>,</c-> <c- n>class</c-> <c- n>T2</c-><c- o>></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>&lt;</c-><c- n>T1</c-><c- p>,</c-> <c- n>E1</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->
<c- n>template</c-><c- o>&lt;</c-><c- n>class</c-> <c- n>T1</c-><c- p>,</c-> <c- n>class</c-> <c- n>E1</c-><c- p>,</c-> <c- n>class</c-> <c- n>T2</c-><c- o>></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>T2</c-><c- o>&amp;</c-> <c- n>v</c-><c- p>,</c-> <c- k>const</c-> <c- n>expected</c-><c- o>&lt;</c-><c- n>T1</c-><c- p>,</c-> <c- n>E1</c-><c- o>>&amp;</c-> <c- n>x</c-><c- p>);</c->
</pre>
   <p><em>Mandates</em>: <code class="highlight"><c- n>T1</c-></code> and <code class="highlight"><c- n>T2</c-></code> are not <em>cv</em> <code class="highlight"><c- b>void</c-></code> and 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>EqualityComparable</em>. - <em>end note</em>]</p>
   <p><em>Returns</em>: <code class="highlight"><c- b>bool</c-><c- p>(</c-><c- n>x</c-><c- p>)</c-> <c- o>?</c-> <c- o>*</c-><c- n>x</c-> <c- o>!=</c-> <c- nl>v</c-> <c- p>:</c-> false<c- p>;</c-></code>.</p>
   <h3 class="heading settled" data-level="5.10" id="expected.comparison_unexpected_E"><span class="secno">5.10. </span><span class="content">�.�.4.8 Comparison with <code class="highlight"><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-></code> [<em>expected.comparison_unexpected_E</em>]</span><a class="self-link" href="#expected.comparison_unexpected_E"></a></h3>
<pre class="language-c++ highlight"><c- n>template</c-><c- o>&lt;</c-><c- n>class</c-> <c- n>T1</c-><c- p>,</c-> <c- n>class</c-> <c- n>E1</c-><c- p>,</c-> <c- n>class</c-> <c- n>E2</c-><c- o>></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>&lt;</c-><c- n>T1</c-><c- p>,</c-> <c- n>E1</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>>&amp;</c-> <c- n>e</c-><c- p>);</c->
<c- n>template</c-><c- o>&lt;</c-><c- n>class</c-> <c- n>T1</c-><c- p>,</c-> <c- n>class</c-> <c- n>E1</c-><c- p>,</c-> <c- n>class</c-> <c- n>E2</c-><c- o>></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>&lt;</c-><c- n>E2</c-><c- o>>&amp;</c-> <c- n>e</c-><c- p>,</c-> <c- k>const</c-> <c- n>expected</c-><c- o>&lt;</c-><c- n>T1</c-><c- p>,</c-> <c- n>E1</c-><c- o>>&amp;</c-> <c- n>x</c-><c- p>);</c->
</pre>
   <p><em>Mandates</em>: The expression <code class="highlight"><c- n>unexpected</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-></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- b>bool</c-><c- p>(</c-><c- n>x</c-><c- p>)</c-> <c- o>?</c-> false <c- o>:</c-> <c- n>unexpected</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-></code>.</p>
<pre class="language-c++ highlight"><c- n>template</c-><c- o>&lt;</c-><c- n>class</c-> <c- n>T1</c-><c- p>,</c-> <c- n>class</c-> <c- n>E1</c-><c- p>,</c-> <c- n>class</c-> <c- n>E2</c-><c- o>></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>&lt;</c-><c- n>T1</c-><c- p>,</c-> <c- n>E1</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>>&amp;</c-> <c- n>e</c-><c- p>);</c->
<c- n>template</c-><c- o>&lt;</c-><c- n>class</c-> <c- n>T1</c-><c- p>,</c-> <c- n>class</c-> <c- n>E1</c-><c- p>,</c-> <c- n>class</c-> <c- n>E2</c-><c- o>></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>&lt;</c-><c- n>E2</c-><c- o>>&amp;</c-> <c- n>e</c-><c- p>,</c-> <c- k>const</c-> <c- n>expected</c-><c- o>&lt;</c-><c- n>T1</c-><c- p>,</c-> <c- n>E1</c-><c- o>>&amp;</c-> <c- n>x</c-><c- p>);</c->
</pre>
   <p><em>Mandates</em>: The expression <code class="highlight"><c- n>unexpected</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-></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- b>bool</c-><c- p>(</c-><c- n>x</c-><c- p>)</c-> <c- o>?</c-> true <c- o>:</c-> <c- n>unexpected</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-></code>.</p>
   <h3 class="heading settled" data-level="5.11" id="expected.specalg"><span class="secno">5.11. </span><span class="content">�.�.4.9 Specialized algorithms [<em>expected.specalg</em>]</span><a class="self-link" href="#expected.specalg"></a></h3>
<pre class="language-c++ highlight"><c- n>template</c-><c- o>&lt;</c-><c- n>class</c-> <c- n>T1</c-><c- p>,</c-> <c- n>class</c-> <c- n>E1</c-><c- o>></c->
<c- b>void</c-> <c- n>swap</c-><c- p>(</c-><c- n>expected</c-><c- o>&lt;</c-><c- n>T1</c-><c- p>,</c-> <c- n>E1</c-><c- o>>&amp;</c-> <c- n>x</c-><c- p>,</c-> <c- n>expected</c-><c- o>&lt;</c-><c- n>T1</c-><c- p>,</c-> <c- n>E1</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>:</p>
   <ul>
    <li data-md>
     <p><code class="highlight"><c- n>T1</c-></code> is <em>cv</em> <code class="highlight"><c- b>void</c-></code> or <code class="highlight"><c- n>is_move_constructible_v</c-><c- o>&lt;</c-><c- n>T1</c-><c- o>></c-></code> is <code class="highlight">true</code>; and</p>
    <li data-md>
     <p><code class="highlight"><c- n>is_swappable_v</c-><c- o>&lt;</c-><c- n>T1</c-><c- o>></c-></code> is <code class="highlight">true</code>; and</p>
    <li data-md>
     <p><code class="highlight"><c- n>is_move_constructible_v</c-><c- o>&lt;</c-><c- n>E1</c-><c- o>></c-></code> is <code class="highlight">true</code>; and</p>
    <li data-md>
     <p><code class="highlight"><c- n>is_swappable_v</c-><c- o>&lt;</c-><c- n>E1</c-><c- o>></c-></code> is <code class="highlight">true</code>.</p>
   </ul>
   <p><em>Effects</em>: Calls <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.unexpected"><span class="secno">5.12. </span><span class="content">�.�.5 Unexpected objects [<em>expected.unexpected</em>]</span><a class="self-link" href="#expected.unexpected"></a></h3>
   <h3 class="heading settled" data-level="5.13" id="expected.unexpected.general"><span class="secno">5.13. </span><span class="content">�.�.5.1 General [<em>expected.unexpected.general</em>]</span><a class="self-link" href="#expected.unexpected.general"></a></h3>
   <p>This subclause describes class template <code class="highlight"><c- n>unexpected</c-></code> that
represents unexpected objects.</p>
   <h3 class="heading settled" data-level="5.14" id="expected.unexpected.object"><span class="secno">5.14. </span><span class="content">�.�.5.2 Class template <code class="highlight"><c- n>unexpected</c-></code> [<em>expected.unexpected.object</em>]</span><a class="self-link" href="#expected.unexpected.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>></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>></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>></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>></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>></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>template</c-><c- o>&lt;</c-><c- n>class</c-> <c- n>Err</c-><c- o>></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>unexpected</c-><c- p>(</c-><c- k>const</c-> <c- n>unexpected</c-><c- o>&lt;</c-><c- n>Err</c-><c- o>>&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>constexpr</c-> <c- n>explicit</c-><c- p>(</c-><c- n>see</c-> <c- n>below</c-><c- p>)</c-> <c- n>unexpected</c-><c- p>(</c-><c- n>unexpected</c-><c- o>&lt;</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>template</c-><c- o>&lt;</c-><c- n>class</c-> <c- n>Err</c-> <c- o>=</c-> <c- n>E</c-><c- o>></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>&lt;</c-><c- n>Err</c-><c- o>>&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>></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>&lt;</c-><c- n>Err</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>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- b>void</c-> <c- nf>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>E1</c-><c- p>,</c-> <c- n>class</c-> <c- n>E2</c-><c- o>></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>&lt;</c-><c- n>E1</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>>&amp;</c-><c- p>);</c->
    <c- n>template</c-><c- o>&lt;</c-><c- n>class</c-> <c- n>E1</c-><c- p>,</c-> <c- n>class</c-> <c- n>E2</c-><c- o>></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>&lt;</c-><c- n>E1</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>>&amp;</c-><c- p>);</c->

    <c- n>template</c-><c- o>&lt;</c-><c- n>class</c-> <c- n>E1</c-><c- o>></c->
    <c- n>friend</c-> <c- b>void</c-> <c- n>swap</c-><c- p>(</c-><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E1</c-><c- o>>&amp;</c-> <c- n>x</c-><c- p>,</c-> <c- n>unexpected</c-><c- o>&lt;</c-><c- n>E1</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>></c-> <c- n>unexpected</c-><c- p>(</c-><c- n>E</c-><c- p>)</c-> <c- o>-></c-> <c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></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 an cv-qualified type is
ill-formed.</p>
   <h4 class="heading settled" data-level="5.14.1" id="expected.unexpected.ctor"><span class="secno">5.14.1. </span><span class="content">�.�.5.2.1 Constructors [<em>expected.unexpected.ctor</em>]</span><a class="self-link" href="#expected.unexpected.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>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_constructible_v</c-><c- o>&lt;</c-><c- n>E</c-><c- p>,</c-> <c- n>Err</c-><c- o>></c-></code> is <code class="highlight">true</code>; and</p>
    <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>></c-><c- p>,</c-> <c- n>in_place_t</c-><c- o>></c-></code> is <code class="highlight">false</code>; and</p>
    <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>></c-><c- p>,</c-> <c- n>unexpected</c-><c- o>></c-></code> is <code class="highlight">false</code>.</p>
   </ul>
   <p><em>Effects</em>: Initializes <code class="highlight"><c- n>val</c-></code> as if direct-non-list-initializing an
object of type <code class="highlight"><c- n>E</c-></code> with the expression <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>forward</c-><c- o>&lt;</c-><c- n>Err</c-><c- o>></c-><c- p>(</c-><c- n>e</c-><c- p>)</c-></code>.</p>
   <p><em>Throws</em>: Any exception thrown by the selected constructor of <code class="highlight"><c- n>E</c-></code>.</p>
   <p><em>Remarks</em>: If <code class="highlight"><c- n>E</c-></code>’s selected constructor is a constant subexpression, this
constructor is a constexpr constructor.</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>></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>></c-></code> is <code class="highlight">true</code>.</p>
   <p><em>Effects</em>: Initializes <code class="highlight"><c- n>val</c-></code> as if direct-non-list-initializing an
object of type <code class="highlight"><c- n>E</c-></code> with the arguments <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>forward</c-><c- o>&lt;</c-><c- n>Args</c-><c- o>></c-><c- p>(</c-><c- n>args</c-><c- p>)...</c-></code>.</p>
   <p><em>Throws</em>: Any exception thrown by the selected constructor of <code class="highlight"><c- n>E</c-></code>.</p>
   <p><em>Remarks</em>:
If <code class="highlight"><c- n>E</c-></code>’s selected constructor is a constant subexpression, this constructor is a constexpr constructor.</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>></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>></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>>&amp;</c-><c- p>,</c-> <c- n>Args</c-><c- p>...</c-><c- o>></c-></code> is <code class="highlight">true</code>.</p>
   <p><em>Effects</em>: Initializes <code class="highlight"><c- n>val</c-></code> as if direct-non-list-initializing an
object of type <code class="highlight"><c- n>E</c-></code> with the arguments <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>></c-><c- p>(</c-><c- n>args</c-><c- p>)...</c-></code>.</p>
   <p><em>Throws</em>: Any exception thrown by the selected constructor of <code class="highlight"><c- n>E</c-></code>.</p>
   <p><em>Remarks</em>:
If <code class="highlight"><c- n>E</c-></code>’s selected constructor is a constant subexpression, this constructor is a constexpr constructor.</p>
<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>constexpr</c-> <c- n>explicit</c-><c- p>(</c-><c- n>see</c-> <c- n>below</c-><c- p>)</c-> <c- n>unexpected</c-><c- p>(</c-><c- k>const</c-> <c- n>unexpected</c-><c- o>&lt;</c-><c- n>Err</c-><c- o>>&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_constructible_v</c-><c- o>&lt;</c-><c- n>E</c-><c- p>,</c-> <c- k>const</c-> <c- n>Err</c-><c- o>&amp;></c-></code> is <code class="highlight">true</code>; and</p>
    <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>unexpected</c-><c- o>&lt;</c-><c- n>Err</c-><c- o>>&amp;></c-></code> is <code class="highlight">false</code>; and</p>
    <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>unexpected</c-><c- o>&lt;</c-><c- n>Err</c-><c- o>>></c-></code> is <code class="highlight">false</code>; and</p>
    <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- k>const</c-> <c- n>unexpected</c-><c- o>&lt;</c-><c- n>Err</c-><c- o>>&amp;></c-></code> is <code class="highlight">false</code>; and</p>
    <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- k>const</c-> <c- n>unexpected</c-><c- o>&lt;</c-><c- n>Err</c-><c- o>>></c-></code> is <code class="highlight">false</code>; and</p>
    <li data-md>
     <p><code class="highlight"><c- n>is_convertible_v</c-><c- o>&lt;</c-><c- n>unexpected</c-><c- o>&lt;</c-><c- n>Err</c-><c- o>>&amp;</c-><c- p>,</c-> <c- n>E</c-><c- o>></c-></code> is <code class="highlight">false</code>; and</p>
    <li data-md>
     <p><code class="highlight"><c- n>is_convertible_v</c-><c- o>&lt;</c-><c- n>unexpected</c-><c- o>&lt;</c-><c- n>Err</c-><c- o>></c-><c- p>,</c-> <c- n>E</c-><c- o>></c-></code> is <code class="highlight">false</code>; and</p>
    <li data-md>
     <p><code class="highlight"><c- n>is_convertible_v</c-><c- o>&lt;</c-><c- k>const</c-> <c- n>unexpected</c-><c- o>&lt;</c-><c- n>Err</c-><c- o>>&amp;</c-><c- p>,</c-> <c- n>E</c-><c- o>></c-></code> is <code class="highlight">false</code>; and</p>
    <li data-md>
     <p><code class="highlight"><c- n>is_convertible_v</c-><c- o>&lt;</c-><c- k>const</c-> <c- n>unexpected</c-><c- o>&lt;</c-><c- n>Err</c-><c- o>></c-><c- p>,</c-> <c- n>E</c-><c- o>></c-></code> is <code class="highlight">false</code>.</p>
   </ul>
   <p><em>Effects</em>: Initializes <code class="highlight"><c- n>val</c-></code> as if direct-non-list-initializing an
object of type <code class="highlight"><c- n>E</c-></code> with the expression <code class="highlight"><c- n>e</c-><c- p>.</c-><c- n>val</c-></code>.</p>
   <p><em>Throws</em>: Any exception thrown by the selected constructor of <code class="highlight"><c- n>E</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- k>const</c-> <c- n>Err</c-><c- o>&amp;</c-><c- p>,</c-> <c- n>E</c-><c- o>></c-></code>.</p>
<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>constexpr</c-> <c- n>explicit</c-><c- p>(</c-><c- n>see</c-> <c- n>below</c-><c- p>)</c-> <c- n>unexpected</c-><c- p>(</c-><c- n>unexpected</c-><c- o>&lt;</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_constructible_v</c-><c- o>&lt;</c-><c- n>E</c-><c- p>,</c-> <c- n>Err</c-><c- o>></c-></code> is <code class="highlight">true</code>; and</p>
    <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>unexpected</c-><c- o>&lt;</c-><c- n>Err</c-><c- o>>&amp;></c-></code> is <code class="highlight">false</code>; and</p>
    <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>unexpected</c-><c- o>&lt;</c-><c- n>Err</c-><c- o>>></c-></code> is <code class="highlight">false</code>; and</p>
    <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- k>const</c-> <c- n>unexpected</c-><c- o>&lt;</c-><c- n>Err</c-><c- o>>&amp;></c-></code> is <code class="highlight">false</code>; and</p>
    <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- k>const</c-> <c- n>unexpected</c-><c- o>&lt;</c-><c- n>Err</c-><c- o>>></c-></code> is <code class="highlight">false</code>; and</p>
    <li data-md>
     <p><code class="highlight"><c- n>is_convertible_v</c-><c- o>&lt;</c-><c- n>unexpected</c-><c- o>&lt;</c-><c- n>Err</c-><c- o>>&amp;</c-><c- p>,</c-> <c- n>E</c-><c- o>></c-></code> is <code class="highlight">false</code>; and</p>
    <li data-md>
     <p><code class="highlight"><c- n>is_convertible_v</c-><c- o>&lt;</c-><c- n>unexpected</c-><c- o>&lt;</c-><c- n>Err</c-><c- o>></c-><c- p>,</c-> <c- n>E</c-><c- o>></c-></code> is <code class="highlight">false</code>; and</p>
    <li data-md>
     <p><code class="highlight"><c- n>is_convertible_v</c-><c- o>&lt;</c-><c- k>const</c-> <c- n>unexpected</c-><c- o>&lt;</c-><c- n>Err</c-><c- o>>&amp;</c-><c- p>,</c-> <c- n>E</c-><c- o>></c-></code> is <code class="highlight">false</code>; and</p>
    <li data-md>
     <p><code class="highlight"><c- n>is_convertible_v</c-><c- o>&lt;</c-><c- k>const</c-> <c- n>unexpected</c-><c- o>&lt;</c-><c- n>Err</c-><c- o>></c-><c- p>,</c-> <c- n>E</c-><c- o>></c-></code> is <code class="highlight">false</code>.</p>
   </ul>
   <p><em>Effects</em>: Initializes <code class="highlight"><c- n>val</c-></code> as if direct-non-list-initializing an
object of type <code class="highlight"><c- n>E</c-></code> with the expression <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>move</c-><c- p>(</c-><c- n>e</c-><c- p>.</c-><c- n>val</c-><c- p>)</c-></code>.</p>
   <p><em>Throws</em>: Any exception thrown by the selected constructor of <code class="highlight"><c- n>E</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>Err</c-><c- p>,</c-> <c- n>E</c-><c- o>></c-></code>.</p>
   <h4 class="heading settled" data-level="5.14.2" id="expected.unexpected.assign"><span class="secno">5.14.2. </span><span class="content">�.�.5.2.2 Assignment [<em>expected.unexpected.assign</em>]</span><a class="self-link" href="#expected.unexpected.assign"></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>></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>&lt;</c-><c- n>Err</c-><c- o>>&amp;</c-> <c- n>e</c-><c- p>);</c->
</pre>
   <p><em>Constraints</em>: <code class="highlight"><c- n>is_assignable_v</c-><c- o>&lt;</c-><c- n>E</c-><c- p>,</c-> <c- k>const</c-> <c- n>Err</c-><c- o>&amp;></c-></code> is <code class="highlight">true</code>.</p>
   <p><em>Effects</em>: Equivalent to <code class="highlight"><c- n>val</c-> <c- o>=</c-> <c- n>e</c-><c- p>.</c-><c- n>val</c-></code>.</p>
   <p><em>Returns</em>: <code class="highlight"><c- o>*</c-><c- k>this</c-></code>.</p>
   <p><em>Remarks</em>: If <code class="highlight"><c- n>E</c-></code>’s selected assignment operator is a constant subexpression,
this function is a constexpr function.</p>
<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>></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>&lt;</c-><c- n>Err</c-><c- o>>&amp;&amp;</c-> <c- n>e</c-><c- p>);</c->
</pre>
   <p><em>Constraints</em>: <code class="highlight"><c- n>is_assignable_v</c-><c- o>&lt;</c-><c- n>E</c-><c- p>,</c-> <c- n>Err</c-><c- o>></c-></code> is <code class="highlight">true</code>.</p>
   <p><em>Effects</em>: 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- n>e</c-><c- p>.</c-><c- n>val</c-><c- p>)</c-></code>.</p>
   <p><em>Returns</em>: <code class="highlight"><c- o>*</c-><c- k>this</c-></code>.</p>
   <p><em>Remarks</em>: If <code class="highlight"><c- n>E</c-></code>’s selected assignment operator is a constant subexpression,
this function is a constexpr function.</p>
   <h4 class="heading settled" data-level="5.14.3" id="expected.unexpected.observe"><span class="secno">5.14.3. </span><span class="content">�.�.5.2.3 Observers [<em>expected.unexpected.observe</em>]</span><a class="self-link" href="#expected.unexpected.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- 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- 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- 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- 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.14.4" id="expected.unexpected.swap"><span class="secno">5.14.4. </span><span class="content">�.�.5.2.4 Swap [<em>expected.unexpected.ctor</em>]</span><a class="self-link" href="#expected.unexpected.swap"></a></h4>
<pre class="language-c++ highlight"><c- b>void</c-> <c- nf>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->
</pre>
   <p><em>Mandates</em>: <code class="highlight"><c- n>is_swappable_v</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></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>
   <p><em>Throws</em>: Any exceptions thrown by the operations in the relevant part of [<strong>expected.swap</strong>].</p>
   <p><em>Remarks</em>: The expression inside <code class="highlight"><c- k>noexcept</c-></code> is equivalent to: <code class="highlight"><c- n>is_nothrow_swappable_v</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-></code> is <code class="highlight">true</code>.</p>
   <h3 class="heading settled" data-level="5.15" id="expected.unexpected.equality_op"><span class="secno">5.15. </span><span class="content">�.�.5.2.5 Equality operators [<em>expected.unexpected.equality_op</em>]</span><a class="self-link" href="#expected.unexpected.equality_op"></a></h3>
<pre class="language-c++ highlight"><c- n>template</c-><c- o>&lt;</c-><c- n>class</c-> <c- n>E1</c-><c- p>,</c-> <c- n>class</c-> <c- n>E2</c-><c- o>></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>&lt;</c-><c- n>E1</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>>&amp;</c-> <c- n>y</c-><c- p>);</c->
</pre>
   <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>
<pre class="language-c++ highlight"><c- n>template</c-><c- o>&lt;</c-><c- n>class</c-> <c- n>E1</c-><c- p>,</c-> <c- n>class</c-> <c- n>E2</c-><c- o>></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>&lt;</c-><c- n>E1</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>>&amp;</c-> <c- n>y</c-><c- p>);</c->
</pre>
   <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>
   <h4 class="heading settled" data-level="5.15.1" id="expected.unexpected.specalg"><span class="secno">5.15.1. </span><span class="content">�.�.5.2.5 Specialized algorithms [<em>expected.unexpected.specalg</em>]</span><a class="self-link" href="#expected.unexpected.specalg"></a></h4>
<pre class="language-c++ highlight"><c- n>template</c-><c- o>&lt;</c-><c- n>class</c-> <c- n>E1</c-><c- o>></c->
    <c- n>friend</c-> <c- b>void</c-> <c- n>swap</c-><c- p>(</c-><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E1</c-><c- o>>&amp;</c-> <c- n>x</c-><c- p>,</c-> <c- n>unexpected</c-><c- o>&lt;</c-><c- n>E1</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>E1</c-><c- o>></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.16" id="expected.bad_expected_access"><span class="secno">5.16. </span><span class="content">�.�.6 Template Class <code class="highlight"><c- n>bad_expected_access</c-></code> [<em>expected.bad_expected_access</em>]</span><a class="self-link" href="#expected.bad_expected_access"></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>></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>></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- n>virtual</c-> <c- k>const</c-> <c- b>char</c-><c- o>*</c-> <c- nf>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- n>error</c-><c- p>()</c-> <c- o>&amp;</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- p>;</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- 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- 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-></code> object that contains an <code class="highlight"><c- n>unexpected</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-></code>.</p>
<pre class="language-c++ highlight"><c- n>bad_expected_access</c-><c- o>::</c-><c- n>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>e</c-></code>.</p>
   <p><em>Ensures</em>: <code class="highlight"><c- n>what</c-><c- p>()</c-></code> returns an implementation-defined NTBS.</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- p>;</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>Returns</em>: <code class="highlight"><c- n>val</c-><c- p>;</c-></code></p>
<pre class="language-c++ highlight"><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- 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>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>virtual</c-> <c- k>const</c-> <c- b>char</c-><c- o>*</c-> <c- nf>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.17" id="expected.bad_expected_access_base"><span class="secno">5.17. </span><span class="content">�.�.7 Class <code class="highlight"><c- n>bad_expected_access</c-><c- o>&lt;</c-><c- b>void</c-><c- o>></c-></code> [<em>expected.bad_expected_access_base</em>]</span><a class="self-link" href="#expected.bad_expected_access_base"></a></h3>
<pre class="language-c++ highlight"><c- n>template</c-><c- o>&lt;></c->
<c- n>class</c-> <c- n>bad_expected_access</c-><c- o>&lt;</c-><c- b>void</c-><c- o>></c-> <c- o>:</c-> <c- n>public</c-> <c- n>exception</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- p>};</c->
</pre>
   <h3 class="heading settled" data-level="5.18" id="expected.unexpect"><span class="secno">5.18. </span><span class="content">�.�.8 <code class="highlight"><c- n>unexpect</c-></code> tag [<em>expected.unexpect</em>]</span><a class="self-link" href="#expected.unexpect"></a></h3>
<pre class="highlight"><code class="highlight"><c- k><c- k>struct</c-></c-> <c- nf><c- nf>unexpect_t</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>see</c-></c-> <c- n><c- n>below</c-></c-></i><c- p><c- p>);</c-></c->
<c- kr><c- kr>inline</c-></c-> <c- k><c- k>constexpr</c-></c-> <c- n><c- n>unexpect_t</c-></c-> <c- nf><c- nf>unexpect</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>unspecified</c-></c-></i><c- p><c- p>);</c-></c->
</code></pre>
   <p>Type <code class="highlight"><c- n>unexpect_t</c-></code> does not have a default constructor or an initializer-list
constructor, and is not an aggregate.</p>
   <h3 class="heading settled" data-level="5.19" id="macro"><span class="secno">5.19. </span><span class="content">Feature test macro</span><a class="self-link" href="#macro"></a></h3>
   <p>The proposed library feature test macro is <code class="highlight"><c- n>__cpp_lib_expected</c-></code>.</p>
   <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>
     Non comprehensive usage list: 
     <ul>
      <li>Telegram desktop client 
      <li>Ceph distributed storage system 
      <li>FiveM and RedM mod frameworks 
      <li>Rspamd spam filtering system 
      <li>OTTO hardware synth 
      <li>Some NIST project 
      <li>about 10 cryptocurrency projects 
     </ul>
    <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>
       <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>
       <a href="https://twitter.com/bjorn_fahller/status/1229803982685638656">https://twitter.com/bjorn_fahller/status/1229803982685638656</a> 
       <blockquote>I used tl::expected&lt;> and a few higher order functions to extend functionality with 1/3 code size ;-)</blockquote>
      <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>
       <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>
     </ul>
   </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>
   </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>
   </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]
   <dd>F. Cacciola, A. Krzemieński. <a href="https://wg21.link/n3527">A proposal to add a utility class to represent optional objects (Revision 2)</a>. 10 March 2013. URL: <a href="https://wg21.link/n3527">https://wg21.link/n3527</a>
   <dt id="biblio-n3672">[N3672]
   <dd>F. Cacciola, A. Krzemieński. <a href="https://wg21.link/n3672">A proposal to add a utility class to represent optional objects (Revision 4)</a>. 19 April 2013. URL: <a href="https://wg21.link/n3672">https://wg21.link/n3672</a>
   <dt id="biblio-n3793">[N3793]
   <dd>F. Cacciola, A. Krzemieński. <a href="https://wg21.link/n3793">A proposal to add a utility class to represent optional objects (Revision 5)</a>. 3 October 2013. URL: <a href="https://wg21.link/n3793">https://wg21.link/n3793</a>
   <dt id="biblio-n4015">[N4015]
   <dd>V. Escriba, P. Talbot. <a href="https://wg21.link/n4015">A proposal to add a utility class to represent expected monad</a>. 26 May 2014. URL: <a href="https://wg21.link/n4015">https://wg21.link/n4015</a>
   <dt id="biblio-n4109">[N4109]
   <dd>V. Escriba, P. Talbot. <a href="https://wg21.link/n4109">A proposal to add a utility class to represent expected monad - Revision 1</a>. 29 June 2014. URL: <a href="https://wg21.link/n4109">https://wg21.link/n4109</a>
   <dt id="biblio-p0032r2">[P0032R2]
   <dd>Vicente J. Botet Escriba. <a href="https://wg21.link/p0032r2">Homogeneous interface for variant, any and optional (Revision 2)</a>. 13 March 2016. URL: <a href="https://wg21.link/p0032r2">https://wg21.link/p0032r2</a>
   <dt id="biblio-p0110r0">[P0110R0]
   <dd>Anthony Williams. <a href="https://wg21.link/p0110r0">Implementing the strong guarantee for variant&lt;> assignment</a>. 25 September 2015. URL: <a href="https://wg21.link/p0110r0">https://wg21.link/p0110r0</a>
   <dt id="biblio-p0157r0">[P0157R0]
   <dd>Lawrence Crowl. <a href="https://wg21.link/p0157r0">Handling Disappointment in C++</a>. 7 November 2015. URL: <a href="https://wg21.link/p0157r0">https://wg21.link/p0157r0</a>
   <dt id="biblio-p0262r1">[P0262r1]
   <dd>Lawrence Crowl, Chris Mysen. <a href="https://wg21.link/p0262r1">A Class for Status and Optional Value</a>. 15 October 2016. URL: <a href="https://wg21.link/p0262r1">https://wg21.link/p0262r1</a>
   <dt id="biblio-p0323r2">[P0323R2]
   <dd>Vicente J. Botet Escriba. <a href="https://wg21.link/p0323r2">A proposal to add a utility class to represent expected object (Revision 4)</a>. 15 June 2017. URL: <a href="https://wg21.link/p0323r2">https://wg21.link/p0323r2</a>
   <dt id="biblio-p0323r3">[P0323r3]
   <dd>Vicente J. Botet Escriba. <a href="https://wg21.link/p0323r3">Utility class to represent expected object</a>. 15 October 2017. URL: <a href="https://wg21.link/p0323r3">https://wg21.link/p0323r3</a>
   <dt id="biblio-p0323r9">[P0323r9]
   <dd>JF Bastien, Vicente Botet. <a href="https://wg21.link/p0323r9">std::expected</a>. 3 August 2019. URL: <a href="https://wg21.link/p0323r9">https://wg21.link/p0323r9</a>
   <dt id="biblio-p0343r1">[P0343r1]
   <dd>Vicente J. Botet Escriba. <a href="https://wg21.link/p0343r1">Meta-programming High-Order Functions</a>. 15 June 2017. URL: <a href="https://wg21.link/p0343r1">https://wg21.link/p0343r1</a>
   <dt id="biblio-p0650r0">[P0650R0]
   <dd>Vicente J. Botet Escriba. <a href="https://wg21.link/p0650r0">C++ Monadic interface</a>. 15 June 2017. URL: <a href="https://wg21.link/p0650r0">https://wg21.link/p0650r0</a>
   <dt id="biblio-p0650r2">[P0650r2]
   <dd>Vicente J. Botet Escribá. <a href="https://wg21.link/p0650r2">C++ Monadic interface</a>. 11 February 2018. URL: <a href="https://wg21.link/p0650r2">https://wg21.link/p0650r2</a>
   <dt id="biblio-p0709r4">[P0709r4]
   <dd>Herb Sutter. <a href="https://wg21.link/p0709r4">Zero-overhead deterministic exceptions: Throwing values</a>. 4 August 2019. URL: <a href="https://wg21.link/p0709r4">https://wg21.link/p0709r4</a>
   <dt id="biblio-p0762r0">[P0762r0]
   <dd>Niall Douglas. <a href="https://wg21.link/p0762r0">Concerns about expected&lt;T, E> from the Boost.Outcome peer review</a>. 15 October 2017. URL: <a href="https://wg21.link/p0762r0">https://wg21.link/p0762r0</a>
   <dt id="biblio-p0786r0">[P0786R0]
   <dd>Vicente J. Botet Escriba. <a href="https://wg21.link/p0786r0">SuccessOrFailure, ValuedOrError and ValuedOrNone types</a>. 15 October 2017. URL: <a href="https://wg21.link/p0786r0">https://wg21.link/p0786r0</a>
   <dt id="biblio-p1028r3">[P1028R3]
   <dd>Niall Douglas. <a href="https://wg21.link/p1028r3">SG14 status_code and standard error object</a>. 12 January 2020. URL: <a href="https://wg21.link/p1028r3">https://wg21.link/p1028r3</a>
   <dt id="biblio-p1051r0">[P1051r0]
   <dd>Vicente J. Botet Escribá. <a href="https://wg21.link/p1051r0">std::experimental::expected LWG design issues</a>. 3 May 2018. URL: <a href="https://wg21.link/p1051r0">https://wg21.link/p1051r0</a>
   <dt id="biblio-p1095r0">[P1095r0]
   <dd>Niall Douglas. <a href="https://wg21.link/p1095r0">Zero overhead deterministic failure - A unified mechanism for C and C++</a>. 29 August 2018. URL: <a href="https://wg21.link/p1095r0">https://wg21.link/p1095r0</a>
  </dl>