<!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>P0323R7: 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)
 *
 ******************************************************************************/

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

	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;

		/* Colors */
		color: black;
		background: white 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-width: .65rem .7rem .6rem;
		border-radius: .4rem;
		background: #1a5e9a;
		color: white;
		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;
		border-color: #c00;
	}

	/* 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;
			color: black;
		}
		#toc-nav > a {
			display: block;
			white-space: nowrap;

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

			background: white;
			box-shadow: 0 0 2px;
			border: none;
			border-top-right-radius: 1.33em;
			background: white;
		}
		#toc-nav > #toc-jump {
			padding-bottom: 2em;
			margin-bottom: -1.9em;
		}

		#toc-nav > a:hover,
		#toc-nav > a:focus {
			background: #f8f8f8;
		}
		#toc-nav > a:not(:hover):not(:focus) {
			color: #707070;
		}

		/* 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-toggle-inline {
			vertical-align: 0.05em;
			font-size: 80%;
			color: gray;
			color: hsla(203,20%,40%,.7);
			border-style: none;
			background: transparent;
			position: relative;
		}
		#toc-toggle-inline:hover:not(:active),
		#toc-toggle-inline:focus:not(:active) {
			text-shadow: 1px 1px silver;
			top: -1px;
			left: -1px;
		}

		#toc-nav :active {
			color: #C00;
		}
	}

/** 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);
			background: inherit;
			background-color: #f7f8f9;
			z-index: 1;
			box-shadow: -.1em 0 .25em rgba(0,0,0,.1) 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);
		}
		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);
			background: inherit;
			background-color: #f7f8f9;
			z-index: 1;
			box-shadow: -.1em 0 .25em rgba(0,0,0,.1) 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);
		}

		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;
		background: transparent;
	}

	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) > hr {
		font-size: 1.5em;
		text-align: center;
		margin: 1em auto;
		height: auto;
		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;
	}

	/* Put nice boxes around each algorithm. */
	[data-algorithm]:not(.heading) {
	  padding: .5em;
	  border: thin solid #ddd; 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;  text-decoration: line-through; }
	ins { color: #080; 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;
		page-break-inside: avoid;
		hyphens: none;
		text-transform: none;
	}
	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;
		text-decoration: none;
		border-bottom: 1px solid #707070;
		/* Need a bit of extending for it to look okay */
		padding: 0 1px 0;
		margin: 0 -1px 0;
	}
	a:visited {
		border-bottom-color: #BBB;
	}

	/* Use distinguishing colors when user is interacting with the link */
	a[href]:focus,
	a[href]:hover {
		background: #f8f8f8;
		background: rgba(75%, 75%, 75%, .25);
		border-bottom-width: 3px;
		margin-bottom: -2px;
	}
	a[href]:active {
		color: #C00;
		border-color: #C00;
	}

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

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

	img {
		border-style: none;
	}

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

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

	blockquote {
		border-color: silver;
	}

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

	.issue {
		border-color: #E05252;
		background: #FBE9E9;
		counter-increment: issue;
		overflow: auto;
	}
	.issue::before, .issue > .marker {
		text-transform: uppercase;
		color: #AE1E1E;
		padding-right: 1em;
		text-transform: uppercase;
	}
	/* 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;
		background: #FCFAEE;
		counter-increment: example;
		overflow: auto;
		clear: both;
	}
	.example::before, .example > .marker {
		text-transform: uppercase;
		color: #827017;
		min-width: 7.5em;
		display: block;
	}
	/* 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;
		background: #E9FBE9;
		overflow: auto;
	}

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

	details.note > summary {
		display: block;
		color: hsl(120, 70%, 30%);
	}
	details.note[open] > summary {
		border-bottom: 1px silver solid;
	}

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

	.assertion {
		border-color: #AAA;
		background: #EEE;
	}

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

	.advisement {
		border-color: orange;
		border-style: none solid;
		background: #FFEECC;
	}
	strong.advisement {
		display: block;
		text-align: center;
	}
	.advisement > .marker {
		color: #B35F00;
	}

/** 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: #fdd;
		color: red;
		font-weight: bold;
		padding: .75em 1em;
		border: thick red;
		border-style: solid;
		border-radius: 1em;
	}
	.annoying-warning :last-child {
		margin-bottom: 0;
	}

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

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

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

	.def {
		padding: .5em 1em;
		background: #DEF;
		margin: 1.2em 0;
		border-left: 0.5em solid #8CCBF2;
	}

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

	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-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;
		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;
		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;
		border-color: #3980B5;
		border-bottom-width: 3px !important;
		margin-bottom: 0px !important;
	}
	.toc a:visited {
		border-color: #054572;
	}
	.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; }
		}
	/* } */

	@supports (display:grid) {
		/* 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 .secno {
			grid-column: 1;
			width: auto;
		}
		#toc .content {
			grid-column: 2;
			width: auto;
			margin-right: 1rem;
		}
		#toc .content:hover {
			background: rgba(75%, 75%, 75%, .25);
			border-bottom: 3px solid #054572;
			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 {
			white-space: nowrap;
			color: transparent; }
		ul.index li a:hover + span,
		ul.index li a:focus + span {
			color: #707070;
		}
	}

/** 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]) {
		background: #f7f8f9;
	}

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

/******************************************************************************/
/*                                    Legacy                                  */
/******************************************************************************/

	/* This rule is inherited from past style sheets. No idea what it's for. */
	.hide { display: none }



/******************************************************************************/
/*                             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 > table {
		/* limit preferred width of table */
		max-width: 50em;
		margin-left: auto;
		margin-right: auto;
	}

	@media (min-width: 55em) {
		.overlarge {
			margin-left: calc(13px + 26.5rem - 50vw);
			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-left: calc(40em - 50vw) !important;
			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-left: 0 !important;
			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;
    }
  </style>
  <meta content="Bikeshed version 5888e02cf0071ba98c44312075d6903689282c04" name="generator">
  <link href="https://wg21.link/p0323r7" rel="canonical">
  <meta content="3c9f8d53f5fbce7deaa2a6bc4c70f7f80a1a130c" name="document-revision">
<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-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-syntax-highlighting */

.highlight:not(.idl) { background: hsl(24, 20%, 95%); }
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 .c { color: #708090 } /* Comment */
.highlight .k { color: #990055 } /* Keyword */
.highlight .l { color: #000000 } /* Literal */
.highlight .n { color: #0077aa } /* Name */
.highlight .o { color: #999999 } /* Operator */
.highlight .p { color: #999999 } /* Punctuation */
.highlight .cm { color: #708090 } /* Comment.Multiline */
.highlight .cp { color: #708090 } /* Comment.Preproc */
.highlight .c1 { color: #708090 } /* Comment.Single */
.highlight .cs { color: #708090 } /* Comment.Special */
.highlight .kc { color: #990055 } /* Keyword.Constant */
.highlight .kd { color: #990055 } /* Keyword.Declaration */
.highlight .kn { color: #990055 } /* Keyword.Namespace */
.highlight .kp { color: #990055 } /* Keyword.Pseudo */
.highlight .kr { color: #990055 } /* Keyword.Reserved */
.highlight .kt { color: #990055 } /* Keyword.Type */
.highlight .ld { color: #000000 } /* Literal.Date */
.highlight .m { color: #000000 } /* Literal.Number */
.highlight .s { color: #a67f59 } /* Literal.String */
.highlight .na { color: #0077aa } /* Name.Attribute */
.highlight .nc { color: #0077aa } /* Name.Class */
.highlight .no { color: #0077aa } /* Name.Constant */
.highlight .nd { color: #0077aa } /* Name.Decorator */
.highlight .ni { color: #0077aa } /* Name.Entity */
.highlight .ne { color: #0077aa } /* Name.Exception */
.highlight .nf { color: #0077aa } /* Name.Function */
.highlight .nl { color: #0077aa } /* Name.Label */
.highlight .nn { color: #0077aa } /* Name.Namespace */
.highlight .py { color: #0077aa } /* Name.Property */
.highlight .nt { color: #669900 } /* Name.Tag */
.highlight .nv { color: #222222 } /* Name.Variable */
.highlight .ow { color: #999999 } /* Operator.Word */
.highlight .mb { color: #000000 } /* Literal.Number.Bin */
.highlight .mf { color: #000000 } /* Literal.Number.Float */
.highlight .mh { color: #000000 } /* Literal.Number.Hex */
.highlight .mi { color: #000000 } /* Literal.Number.Integer */
.highlight .mo { color: #000000 } /* Literal.Number.Oct */
.highlight .sb { color: #a67f59 } /* Literal.String.Backtick */
.highlight .sc { color: #a67f59 } /* Literal.String.Char */
.highlight .sd { color: #a67f59 } /* Literal.String.Doc */
.highlight .s2 { color: #a67f59 } /* Literal.String.Double */
.highlight .se { color: #a67f59 } /* Literal.String.Escape */
.highlight .sh { color: #a67f59 } /* Literal.String.Heredoc */
.highlight .si { color: #a67f59 } /* Literal.String.Interpol */
.highlight .sx { color: #a67f59 } /* Literal.String.Other */
.highlight .sr { color: #a67f59 } /* Literal.String.Regex */
.highlight .s1 { color: #a67f59 } /* Literal.String.Single */
.highlight .ss { color: #a67f59 } /* Literal.String.Symbol */
.highlight .vc { color: #0077aa } /* Name.Variable.Class */
.highlight .vg { color: #0077aa } /* Name.Variable.Global */
.highlight .vi { color: #0077aa } /* Name.Variable.Instance */
.highlight .il { color: #000000 } /* Literal.Number.Integer.Long */
</style>
<style>/* style-selflinks */

.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: gray;
    color: white;
    font-style: normal;
    transition: opacity .2s, background-color .2s, color .2s;
}
dfn:hover > a.self-link {
    opacity: 1;
}
dfn > a.self-link:hover {
    color: black;
}

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

.css.css, .property.property, .descriptor.descriptor {
    color: #005a9c;
    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>
 <body class="h-entry">
  <div class="head">
   <p data-fill-with="logo"></p>
   <h1 class="p-name no-ref" id="title">P0323R7<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="2018-06-22">22 June 2018</time></span></h2>
   <div data-fill-with="spec-metadata">
    <dl>
     <dt>This version:
     <dd><a class="u-url" href="https://wg21.link/p0323r7">https://wg21.link/p0323r7</a>
     <dt>Issue Tracking:
     <dd><a href="#issues-index">Inline In Spec</a>
     <dt>Authors:
     <dd>
      <dd class="editor p-author h-card vcard"><a class="p-name fn u-email email" href="mailto:vicente.botet@nokia.com">Vicente Botet</a> (<span class="p-org org">Nokia</span>)
     <dd>
      <dd class="editor p-author h-card vcard"><a class="p-name fn u-email email" href="mailto:jfbastien@apple.com">JF Bastien</a> (<span class="p-org org">Apple</span>)
     <dt>Audience:
     <dd>LWG
     <dt>Project:
     <dd>ISO JTC1/SC22/WG21: Programming Language C++
     <dt>Source:
     <dd><a href="https://github.com/jfbastien/papers/blob/master/source/p0323r7.bs">github.com/jfbastien/papers/blob/master/source/p0323r7.bs</a>
    </dl>
   </div>
   <div data-fill-with="warning"></div>
   <hr title="Separator for header">
  </div>
  <div class="p-summary" data-fill-with="abstract">
   <h2 class="no-num no-toc no-ref heading settled" id="abstract"><span class="content">Abstract</span></h2>
   <p>Utility class to represent expected object: wording and open questions.</p>
  </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="#word"><span class="secno">1</span> <span class="content">Wording</span></a>
     <ol class="toc">
      <li><a href="#expected"><span class="secno">1.1</span> <span class="content">�.� Expected objects [<em>expected</em>]</span></a>
      <li><a href="#expected.general"><span class="secno">1.2</span> <span class="content">�.�.1 In general [<em>expected.general</em>]</span></a>
      <li><a href="#expected.synop"><span class="secno">1.3</span> <span class="content">�.�.2 Header <code class="highlight"><span class="o">&lt;</span><span class="n">experimental</span><span class="o">/</span><span class="n">expected</span><span class="o">></span></code> synopsis [<em>expected.synop</em>]</span></a>
      <li><a href="#expected.defs"><span class="secno">1.4</span> <span class="content">�.�.3 Definitions [<em>expected.defs</em>]</span></a>
      <li><a href="#expected.expected"><span class="secno">1.5</span> <span class="content">�.�.4 Class template expected [<em>expected.expected</em>]</span></a>
      <li><a href="#expected.object.ctor"><span class="secno">1.6</span> <span class="content">�.�.4.1 Constructors [<em>expected.object.ctor</em>]</span></a>
      <li><a href="#expected.object.dtor"><span class="secno">1.7</span> <span class="content">�.�.4.2 Destructor [<em>expected.object.dtor</em>]</span></a>
      <li><a href="#expected.object.assign"><span class="secno">1.8</span> <span class="content">�.�.4.3 Assignment [<em>expected.object.assign</em>]</span></a>
      <li><a href="#expected.object.swap"><span class="secno">1.9</span> <span class="content">�.�.4.4 Swap [<em>expected.object.swap</em>]</span></a>
      <li><a href="#expected.object.observe"><span class="secno">1.10</span> <span class="content">�.�.4.5 Observers [<em>expected.object.observe</em>]</span></a>
      <li><a href="#expected.equality_op"><span class="secno">1.11</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">1.12</span> <span class="content">�.�.4.7 Comparison with <code class="highlight"><span class="n">T</span></code> [<em>expected.comparison_T</em>]</span></a>
      <li><a href="#expected.comparison_unexpected_E"><span class="secno">1.13</span> <span class="content">�.�.4.8 Comparison with <code class="highlight"><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code> [<em>expected.comparison_unexpected_E</em>]</span></a>
      <li><a href="#expected.specalg"><span class="secno">1.14</span> <span class="content">�.�.4.9 Specialized algorithms [<em>expected.specalg</em>]</span></a>
      <li><a href="#expected.unexpected"><span class="secno">1.15</span> <span class="content">�.�.5 Unexpected objects [<em>expected.unexpected</em>]</span></a>
      <li><a href="#expected.unexpected.general"><span class="secno">1.16</span> <span class="content">�.�.5.1 General [<em>expected.unexpected.general</em>]</span></a>
      <li><a href="#expected.unexpected.object"><span class="secno">1.17</span> <span class="content">�.�.5.2 Class template <code class="highlight"><span class="n">unexpected</span></code> [<em>expected.unexpected.object</em>]</span></a>
      <li><a href="#expected.unexpected.equality_op"><span class="secno">1.18</span> <span class="content">�.�.5.2.5 Equality operators [<em>expected.unexpected.equality_op</em>]</span></a>
      <li><a href="#expected.bad_expected_access"><span class="secno">1.19</span> <span class="content">�.�.6 Template Class <code class="highlight"><span class="n">bad_expected_access</span></code> [<em>expected.bad_expected_access</em>]</span></a>
      <li><a href="#expected.bad_expected_access_base"><span class="secno">1.20</span> <span class="content">�.�.7 Class <code class="highlight"><span class="n">bad_expected_access</span><span class="o">&lt;</span><span class="kt">void</span><span class="o">></span></code> [<em>expected.bad_expected_access_base</em>]</span></a>
      <li><a href="#expected.unexpect"><span class="secno">1.21</span> <span class="content">�.�.8 <code class="highlight"><span class="n">unexpect</span></code> tag [<em>expected.unexpect</em>]</span></a>
     </ol>
    <li>
     <a href="#qq"><span class="secno">2</span> <span class="content">Open Questions</span></a>
     <ol class="toc">
      <li><a href="#ergo"><span class="secno">2.1</span> <span class="content">Ergonomics</span></a>
      <li><a href="#dis"><span class="secno">2.2</span> <span class="content">Disappointment</span></a>
      <li><a href="#stl"><span class="secno">2.3</span> <span class="content">STL Usage</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>
    <li><a href="#issues-index"><span class="secno"></span> <span class="content">Issues Index</span></a>
   </ol>
  </nav>
  <main>
   <p>This paper revises <a data-link-type="biblio" href="#biblio-p0323r6">[P0323r6]</a> and <a data-link-type="biblio" href="#biblio-p0323r5">[P0323r5]</a> with feedback received from LWG. <a data-link-type="biblio" href="#biblio-p0323r4">[P0323r4]</a> contains motivation, design rationale, implementability information,
sample usage, history, alternative designs and related types. r5 onwards only
contain wording and open questions because their purpose is twofold:</p>
   <ul>
    <li data-md="">
     <p>Present appropriate wording for inclusion in the Library Fundamentals TS v3.</p>
    <li data-md="">
     <p>List open questions which the TS should aim to answer.</p>
   </ul>
   <h2 class="heading settled" data-level="1" id="word"><span class="secno">1. </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="1.1" id="expected"><span class="secno">1.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="1.2" id="expected.general"><span class="secno">1.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"><span class="n">expected</span></code> that represents expected
objects. An <code class="highlight"><span class="n">expected</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span> <span class="n">E</span><span class="o">></span></code> object holds an object of type <code class="highlight"><span class="n">T</span></code> or an object of
type <code class="highlight"><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code> and manages the lifetime of the contained objects.</p>
   <h3 class="heading settled" data-level="1.3" id="expected.synop"><span class="secno">1.3. </span><span class="content">�.�.2 Header <code class="highlight"><span class="o">&lt;</span><span class="n">experimental</span><span class="o">/</span><span class="n">expected</span><span class="o">></span></code> synopsis [<em>expected.synop</em>]</span><a class="self-link" href="#expected.synop"></a></h3>
<pre class="language-c++ highlight"><span class="n">namespace</span> <span class="n">std</span> <span class="p">{</span>
<span class="n">namespace</span> <span class="n">experimental</span> <span class="p">{</span>
<span class="kr">inline</span> <span class="n">namespace</span> <span class="n">fundamentals_v3</span> <span class="p">{</span>
    <span class="c1">// �.�.4, class template expected</span>
<span class="c1"></span>    <span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">T</span><span class="p">,</span> <span class="n">class</span> <span class="n">E</span><span class="o">></span>
        <span class="n">class</span> <span class="n">expected</span><span class="p">;</span>

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

    <span class="c1">// �.�.6, class bad_expected_access</span>
<span class="c1"></span>    <span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">E</span><span class="o">></span>
       <span class="n">class</span> <span class="n">bad_expected_access</span><span class="p">;</span>

    <span class="c1">// �.�.7, Specialization for void</span>
<span class="c1"></span>    <span class="n">template</span><span class="o">&lt;></span>
       <span class="n">class</span> <span class="n">bad_expected_access</span><span class="o">&lt;</span><span class="kt">void</span><span class="o">></span><span class="p">;</span>

    <span class="c1">// �.�.8, unexpect tag</span>
<span class="c1"></span>    <span class="k">struct</span> <span class="n">unexpect_t</span> <span class="p">{</span>
       <span class="n">explicit</span> <span class="n">unexpect_t</span><span class="p">()</span> <span class="o">=</span> <span class="k">default</span><span class="p">;</span>
    <span class="p">};</span>
    <span class="kr">inline</span> <span class="n">constexpr</span> <span class="n">unexpect_t</span> <span class="n">unexpect</span><span class="p">{};</span>

<span class="p">}}}</span>
</pre>
   <h3 class="heading settled" data-level="1.4" id="expected.defs"><span class="secno">1.4. </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="1.5" id="expected.expected"><span class="secno">1.5. </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"><span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">T</span><span class="p">,</span> <span class="n">class</span> <span class="n">E</span><span class="o">></span>
<span class="n">class</span> <span class="n">expected</span> <span class="p">{</span>
<span class="nl">public</span><span class="p">:</span>
    <span class="n">using</span> <span class="n">value_type</span> <span class="o">=</span> <span class="n">T</span><span class="p">;</span>
    <span class="n">using</span> <span class="n">error_type</span> <span class="o">=</span> <span class="n">E</span><span class="p">;</span>
    <span class="n">using</span> <span class="n">unexpected_type</span> <span class="o">=</span> <span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span><span class="p">;</span>

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

    <span class="c1">// �.�.4.1, constructors</span>
<span class="c1"></span>    <span class="n">constexpr</span> <span class="nf">expected</span><span class="p">();</span>
    <span class="n">constexpr</span> <span class="nf">expected</span><span class="p">(</span><span class="k">const</span> <span class="n">expected</span><span class="o">&amp;</span><span class="p">);</span>
    <span class="n">constexpr</span> <span class="nf">expected</span><span class="p">(</span><span class="n">expected</span><span class="o">&amp;&amp;</span><span class="p">)</span> <span class="n">noexcept</span><span class="p">(</span><span class="n">see</span> <span class="n">below</span><span class="p">);</span>
    <span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">U</span><span class="p">,</span> <span class="n">class</span> <span class="n">G</span><span class="o">></span>
        <span class="n">EXPLICIT</span> <span class="n">constexpr</span> <span class="n">expected</span><span class="p">(</span><span class="k">const</span> <span class="n">expected</span><span class="o">&lt;</span><span class="n">U</span><span class="p">,</span> <span class="n">G</span><span class="o">>&amp;</span><span class="p">);</span>
    <span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">U</span><span class="p">,</span> <span class="n">class</span> <span class="n">G</span><span class="o">></span>
        <span class="n">EXPLICIT</span> <span class="n">constexpr</span> <span class="n">expected</span><span class="p">(</span><span class="n">expected</span><span class="o">&lt;</span><span class="n">U</span><span class="p">,</span> <span class="n">G</span><span class="o">>&amp;&amp;</span><span class="p">);</span>

    <span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">U</span> <span class="o">=</span> <span class="n">T</span><span class="o">></span>
        <span class="n">EXPLICIT</span> <span class="n">constexpr</span> <span class="n">expected</span><span class="p">(</span><span class="n">U</span><span class="o">&amp;&amp;</span> <span class="n">v</span><span class="p">);</span>

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

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


    <span class="c1">// �.�.4.2, destructor</span>
<span class="c1"></span>    <span class="o">~</span><span class="n">expected</span><span class="p">();</span>

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

    <span class="c1">// �.�.4.4, modifiers</span>
<span class="c1"></span>
    <span class="n">template</span><span class="o">&lt;</span><span class="n">class</span><span class="p">...</span> <span class="n">Args</span><span class="o">></span>
        <span class="n">T</span><span class="o">&amp;</span> <span class="n">emplace</span><span class="p">(</span><span class="n">Args</span><span class="o">&amp;&amp;</span><span class="p">...);</span>
    <span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">U</span><span class="p">,</span> <span class="n">class</span><span class="p">...</span> <span class="n">Args</span><span class="o">></span>
        <span class="n">T</span><span class="o">&amp;</span> <span class="n">emplace</span><span class="p">(</span><span class="n">initializer_list</span><span class="o">&lt;</span><span class="n">U</span><span class="o">></span><span class="p">,</span> <span class="n">Args</span><span class="o">&amp;&amp;</span><span class="p">...);</span>

    <span class="c1">// �.�.4.5, swap</span>
<span class="c1"></span>    <span class="kt">void</span> <span class="nf">swap</span><span class="p">(</span><span class="n">expected</span><span class="o">&amp;</span><span class="p">)</span> <span class="n">noexcept</span><span class="p">(</span><span class="n">see</span> <span class="n">below</span><span class="p">);</span>

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

    <span class="c1">// �.�.4.7, Expected equality operators</span>
<span class="c1"></span>    <span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">T1</span><span class="p">,</span> <span class="n">class</span> <span class="n">E1</span><span class="p">,</span> <span class="n">class</span> <span class="n">T2</span><span class="p">,</span> <span class="n">class</span> <span class="n">E2</span><span class="o">></span>
        <span class="n">friend</span> <span class="n">constexpr</span> <span class="kt">bool</span> <span class="n">operator</span><span class="o">==</span><span class="p">(</span><span class="k">const</span> <span class="n">expected</span><span class="o">&lt;</span><span class="n">T1</span><span class="p">,</span> <span class="n">E1</span><span class="o">>&amp;</span> <span class="n">x</span><span class="p">,</span> <span class="k">const</span> <span class="n">expected</span><span class="o">&lt;</span><span class="n">T2</span><span class="p">,</span> <span class="n">E2</span><span class="o">>&amp;</span> <span class="n">y</span><span class="p">);</span>
    <span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">T1</span><span class="p">,</span> <span class="n">class</span> <span class="n">E1</span><span class="p">,</span> <span class="n">class</span> <span class="n">T2</span><span class="p">,</span> <span class="n">class</span> <span class="n">E2</span><span class="o">></span>
        <span class="n">friend</span> <span class="n">constexpr</span> <span class="kt">bool</span> <span class="n">operator</span><span class="o">!=</span><span class="p">(</span><span class="k">const</span> <span class="n">expected</span><span class="o">&lt;</span><span class="n">T1</span><span class="p">,</span> <span class="n">E1</span><span class="o">>&amp;</span> <span class="n">x</span><span class="p">,</span> <span class="k">const</span> <span class="n">expected</span><span class="o">&lt;</span><span class="n">T2</span><span class="p">,</span> <span class="n">E2</span><span class="o">>&amp;</span> <span class="n">y</span><span class="p">);</span>

    <span class="c1">// �.�.4.8, Comparison with T</span>
<span class="c1"></span>    <span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">T1</span><span class="p">,</span> <span class="n">class</span> <span class="n">E1</span><span class="p">,</span> <span class="n">class</span> <span class="n">T2</span><span class="o">></span>
        <span class="n">friend</span> <span class="n">constexpr</span> <span class="kt">bool</span> <span class="n">operator</span><span class="o">==</span><span class="p">(</span><span class="k">const</span> <span class="n">expected</span><span class="o">&lt;</span><span class="n">T1</span><span class="p">,</span> <span class="n">E1</span><span class="o">>&amp;</span><span class="p">,</span> <span class="k">const</span> <span class="n">T2</span><span class="o">&amp;</span><span class="p">);</span>
    <span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">T1</span><span class="p">,</span> <span class="n">class</span> <span class="n">E1</span><span class="p">,</span> <span class="n">class</span> <span class="n">T2</span><span class="o">></span>
        <span class="n">friend</span> <span class="n">constexpr</span> <span class="kt">bool</span> <span class="n">operator</span><span class="o">==</span><span class="p">(</span><span class="k">const</span> <span class="n">T2</span><span class="o">&amp;</span><span class="p">,</span> <span class="k">const</span> <span class="n">expected</span><span class="o">&lt;</span><span class="n">T1</span><span class="p">,</span> <span class="n">E1</span><span class="o">>&amp;</span><span class="p">);</span>
    <span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">T1</span><span class="p">,</span> <span class="n">class</span> <span class="n">E1</span><span class="p">,</span> <span class="n">class</span> <span class="n">T2</span><span class="o">></span>
        <span class="n">friend</span> <span class="n">constexpr</span> <span class="kt">bool</span> <span class="n">operator</span><span class="o">!=</span><span class="p">(</span><span class="k">const</span> <span class="n">expected</span><span class="o">&lt;</span><span class="n">T1</span><span class="p">,</span> <span class="n">E1</span><span class="o">>&amp;</span><span class="p">,</span> <span class="k">const</span> <span class="n">T2</span><span class="o">&amp;</span><span class="p">);</span>
    <span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">T1</span><span class="p">,</span> <span class="n">class</span> <span class="n">E1</span><span class="p">,</span> <span class="n">class</span> <span class="n">T2</span><span class="o">></span>
        <span class="n">friend</span> <span class="n">constexpr</span> <span class="kt">bool</span> <span class="n">operator</span><span class="o">!=</span><span class="p">(</span><span class="k">const</span> <span class="n">T2</span><span class="o">&amp;</span><span class="p">,</span> <span class="k">const</span> <span class="n">expected</span><span class="o">&lt;</span><span class="n">T1</span><span class="p">,</span> <span class="n">E1</span><span class="o">>&amp;</span><span class="p">);</span>

    <span class="c1">// �.�.4.9, Comparison with unexpected&lt;E></span>
<span class="c1"></span>    <span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">T1</span><span class="p">,</span> <span class="n">class</span> <span class="n">E1</span><span class="p">,</span> <span class="n">class</span> <span class="n">E2</span><span class="o">></span>
        <span class="n">friend</span> <span class="n">constexpr</span> <span class="kt">bool</span> <span class="n">operator</span><span class="o">==</span><span class="p">(</span><span class="k">const</span> <span class="n">expected</span><span class="o">&lt;</span><span class="n">T1</span><span class="p">,</span> <span class="n">E1</span><span class="o">>&amp;</span><span class="p">,</span> <span class="k">const</span> <span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E2</span><span class="o">>&amp;</span><span class="p">);</span>
    <span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">T1</span><span class="p">,</span> <span class="n">class</span> <span class="n">E1</span><span class="p">,</span> <span class="n">class</span> <span class="n">E2</span><span class="o">></span>
        <span class="n">friend</span> <span class="n">constexpr</span> <span class="kt">bool</span> <span class="n">operator</span><span class="o">==</span><span class="p">(</span><span class="k">const</span> <span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E2</span><span class="o">>&amp;</span><span class="p">,</span> <span class="k">const</span> <span class="n">expected</span><span class="o">&lt;</span><span class="n">T1</span><span class="p">,</span> <span class="n">E1</span><span class="o">>&amp;</span><span class="p">);</span>
    <span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">T1</span><span class="p">,</span> <span class="n">class</span> <span class="n">E1</span><span class="p">,</span> <span class="n">class</span> <span class="n">E2</span><span class="o">></span>
        <span class="n">friend</span> <span class="n">constexpr</span> <span class="kt">bool</span> <span class="n">operator</span><span class="o">!=</span><span class="p">(</span><span class="k">const</span> <span class="n">expected</span><span class="o">&lt;</span><span class="n">T1</span><span class="p">,</span> <span class="n">E1</span><span class="o">>&amp;</span><span class="p">,</span> <span class="k">const</span> <span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E2</span><span class="o">>&amp;</span><span class="p">);</span>
    <span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">T1</span><span class="p">,</span> <span class="n">class</span> <span class="n">E1</span><span class="p">,</span> <span class="n">class</span> <span class="n">E2</span><span class="o">></span>
        <span class="n">friend</span> <span class="n">constexpr</span> <span class="kt">bool</span> <span class="n">operator</span><span class="o">!=</span><span class="p">(</span><span class="k">const</span> <span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E2</span><span class="o">>&amp;</span><span class="p">,</span> <span class="k">const</span> <span class="n">expected</span><span class="o">&lt;</span><span class="n">T1</span><span class="p">,</span> <span class="n">E1</span><span class="o">>&amp;</span><span class="p">);</span>

    <span class="c1">// �.�.4.10, Specialized algorithms</span>
<span class="c1"></span>    <span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">T1</span><span class="p">,</span> <span class="n">class</span> <span class="n">E1</span><span class="o">></span>
        <span class="n">friend</span> <span class="kt">void</span> <span class="n">swap</span><span class="p">(</span><span class="n">expected</span><span class="o">&lt;</span><span class="n">T1</span><span class="p">,</span> <span class="n">E1</span><span class="o">>&amp;</span><span class="p">,</span> <span class="n">expected</span><span class="o">&lt;</span><span class="n">T1</span><span class="p">,</span> <span class="n">E1</span><span class="o">>&amp;</span><span class="p">)</span> <span class="n">noexcept</span><span class="p">(</span><span class="n">see</span> <span class="n">below</span><span class="p">);</span>

<span class="nl">private</span><span class="p">:</span>
    <span class="kt">bool</span> <span class="n">has_val</span><span class="p">;</span> <span class="c1">// exposition only</span>
<span class="c1"></span>    <span class="k">union</span>
    <span class="p">{</span>
        <span class="n">value_type</span> <span class="n">val</span><span class="p">;</span> <span class="c1">// exposition only</span>
<span class="c1"></span>        <span class="n">unexpected_type</span> <span class="n">unex</span><span class="p">;</span> <span class="c1">// exposition only</span>
<span class="c1"></span>    <span class="p">};</span>
<span class="p">};</span>
</pre>
   <p>Any object of <code class="highlight"><span class="n">expected</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span> <span class="n">E</span><span class="o">></span></code> either contains a value of type <code class="highlight"><span class="n">T</span></code> or a value of
type <code class="highlight"><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></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"><span class="n">T</span></code> or the object of type <code class="highlight"><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code>. These objects shall be allocated
in a region of the <code class="highlight"><span class="n">expected</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span> <span class="n">E</span><span class="o">></span></code> storage suitably aligned for the types <code class="highlight"><span class="n">T</span></code> and <code class="highlight"><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code>. Members <code class="highlight"><span class="n">has_val</span></code>, <code class="highlight"><span class="n">val</span></code> and <code class="highlight"><span class="n">unex</span></code> are provided for
exposition only. <code class="highlight"><span class="n">has_val</span></code> indicates whether the <code class="highlight"><span class="n">expected</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span> <span class="n">E</span><span class="o">></span></code> object
contains an object of type <code class="highlight"><span class="n">T</span></code>.</p>
   <p>A program that instantiates the definition of template <code class="highlight"><span class="n">expected</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span> <span class="n">E</span><span class="o">></span></code> for a
reference type, a function type, or for possibly cv-qualified types <code class="highlight"><span class="n">in_place_t</span></code>, <code class="highlight"><span class="n">unexpect_t</span></code> or <code class="highlight"><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code> for the <code class="highlight"><span class="n">T</span></code> parameter is
ill-formed. A program that instantiates the definition of template <code class="highlight"><span class="n">expected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code> with the <code class="highlight"><span class="n">E</span></code> parameter that is not a valid template parameter
for <code class="highlight"><span class="n">unexpected</span></code> is ill-formed.</p>
   <p>When <code class="highlight"><span class="n">T</span></code> is not <em>cv</em> <code class="highlight"><span class="kt">void</span></code>, it shall satisfy the requirements of <code class="highlight"><span class="n">Destructible</span></code> (Table 27).</p>
   <p><code class="highlight"><span class="n">E</span></code> shall satisfy the requirements of <code class="highlight"><span class="n">Destructible</span></code> (Table 27).</p>
   <h3 class="heading settled" data-level="1.6" id="expected.object.ctor"><span class="secno">1.6. </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"><span class="n">constexpr</span> <span class="nf">expected</span><span class="p">();</span>
</pre>
   <p><em>Effects</em>: Value-Initializes <code class="highlight"><span class="n">val</span></code> if <code class="highlight"><span class="n">T</span></code> is not <em>cv</em> <code class="highlight"><span class="kt">void</span></code>.</p>
   <p><em>Postconditions</em>: <code class="highlight"><span class="kt">bool</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="p">)</span></code>.</p>
   <p><em>Throws</em>: Any exception thrown by the selected constructor of <code class="highlight"><span class="n">T</span></code>.</p>
   <p><em>Remarks</em>: If value-initialization of <code class="highlight"><span class="n">T</span></code> is a constant subexpression or <code class="highlight"><span class="n">T</span></code> is <em>cv</em> <code class="highlight"><span class="kt">void</span></code> this constructor shall be constexpr. This constructor shall not participate in
overload resolution unless <code class="highlight"><span class="n">is_default_constructible_v</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span></code> is <code class="highlight">true</code> or <code class="highlight"><span class="n">T</span></code> is <em>cv</em> <code class="highlight"><span class="kt">void</span></code>.</p>
<pre class="language-c++ highlight"><span class="n">constexpr</span> <span class="nf">expected</span><span class="p">(</span><span class="k">const</span> <span class="n">expected</span><span class="o">&amp;</span> <span class="n">rhs</span><span class="p">);</span>
</pre>
   <p><em>Effects</em>: If <code class="highlight"><span class="kt">bool</span><span class="p">(</span><span class="n">rhs</span><span class="p">)</span></code> and <code class="highlight"><span class="n">T</span></code> is not <em>cv</em> <code class="highlight"><span class="kt">void</span></code>, initializes <code class="highlight"><span class="n">val</span></code> as if
direct-non-list-initializing an object of type <code class="highlight"><span class="n">T</span></code> with the expression <code class="highlight"><span class="o">*</span><span class="n">rhs</span></code>.</p>
   <p>Otherwise, initializes <code class="highlight"><span class="n">unex</span></code> as if direct-non-list-initializing an object
of type <code class="highlight"><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code> with the expression <code class="highlight"><span class="n">unexpected</span><span class="p">(</span><span class="n">rhs</span><span class="p">.</span><span class="n">error</span><span class="p">())</span></code>.</p>
   <p><em>Postconditions</em>: <code class="highlight"><span class="kt">bool</span><span class="p">(</span><span class="n">rhs</span><span class="p">)</span> <span class="o">==</span> <span class="kt">bool</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="p">)</span></code>.</p>
   <p><em>Throws</em>: Any exception thrown by the selected constructor of <code class="highlight"><span class="n">T</span></code> or <code class="highlight"><span class="n">E</span></code>.</p>
   <p><em>Remarks</em>: This constructor shall be defined as deleted unless:</p>
   <ul>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_copy_constructible_v</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span></code> is <code class="highlight">true</code> or <code class="highlight"><span class="n">T</span></code> is <em>cv</em> <code class="highlight"><span class="kt">void</span></code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_copy_constructible_v</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code> is <code class="highlight">true</code>.</p>
   </ul>
   <p>This constructor shall be a constexpr constructor if:</p>
   <ul>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_trivially_copy_constructible_v</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span></code> is <code class="highlight">true</code> or <code class="highlight"><span class="n">T</span></code> is <em>cv</em> <code class="highlight"><span class="kt">void</span></code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_trivially_copy_constructible_v</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code> is <code class="highlight">true</code>.</p>
   </ul>
<pre class="language-c++ highlight"><span class="n">constexpr</span> <span class="nf">expected</span><span class="p">(</span><span class="n">expected</span><span class="o">&amp;&amp;</span> <span class="n">rhs</span><span class="p">)</span> <span class="n">noexcept</span><span class="p">(</span><span class="n">see</span> <span class="n">below</span><span class="p">);</span>
</pre>
   <p><em>Effects</em>: If <code class="highlight"><span class="kt">bool</span><span class="p">(</span><span class="n">rhs</span><span class="p">)</span></code> and <code class="highlight"><span class="n">T</span></code> is not <em>cv</em> <code class="highlight"><span class="kt">void</span></code>, initializes <code class="highlight"><span class="n">val</span></code> as if
direct-non-list-initializing an object of type <code class="highlight"><span class="n">T</span></code> with the expression <code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">move</span><span class="p">(</span><span class="o">*</span><span class="n">rhs</span><span class="p">)</span></code>.</p>
   <p>Otherwise, initializes <code class="highlight"><span class="n">val</span></code> as if direct-non-list-initializing an object of
type <code class="highlight"><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code> with the expression <code class="highlight"><span class="n">unexpected</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">move</span><span class="p">(</span><span class="n">rhs</span><span class="p">.</span><span class="n">error</span><span class="p">()))</span></code>.</p>
   <p><em>Postconditions</em>: <code class="highlight"><span class="kt">bool</span><span class="p">(</span><span class="n">rhs</span><span class="p">)</span></code> is unchanged, <code class="highlight"><span class="kt">bool</span><span class="p">(</span><span class="n">rhs</span><span class="p">)</span> <span class="o">==</span> <span class="kt">bool</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="p">)</span></code>.</p>
   <p><em>Throws</em>: Any exception thrown by the selected constructor of <code class="highlight"><span class="n">T</span></code> or <code class="highlight"><span class="n">E</span></code>.</p>
   <p><em>Remarks</em>: The expression inside <code class="highlight"><span class="k">noexcept</span></code> is equivalent to:</p>
   <ul>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_nothrow_move_constructible_v</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span></code> is <code class="highlight">true</code> or <code class="highlight"><span class="n">T</span></code>is <em>cv</em> <code class="highlight"><span class="kt">void</span></code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_nothrow_move_constructible_v</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code> is <code class="highlight">true</code>.</p>
   </ul>
   <p>This constructor shall not participate in overload resolution unless:</p>
   <ul>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_move_constructible_v</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span></code> is <code class="highlight">true</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_move_constructible_v</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code> is <code class="highlight">true</code>.</p>
   </ul>
   <p>This constructor shall be a constexpr constructor if:</p>
   <ul>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_trivially_move_constructible_v</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span></code> is <code class="highlight">true</code> or <code class="highlight"><span class="n">T</span></code> is <em>cv</em> <code class="highlight"><span class="kt">void</span></code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_trivially_move_constructible_v</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code> is <code class="highlight">true</code>.</p>
   </ul>
<pre class="language-c++ highlight">    <span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">U</span><span class="p">,</span> <span class="n">class</span> <span class="n">G</span><span class="o">></span>
    <span class="n">EXPLICIT</span> <span class="n">constexpr</span> <span class="n">expected</span><span class="p">(</span><span class="k">const</span> <span class="n">expected</span><span class="o">&lt;</span><span class="n">U</span><span class="p">,</span> <span class="n">G</span><span class="o">>&amp;</span> <span class="n">rhs</span><span class="p">);</span>
</pre>
   <p><em>Effects</em>: If <code class="highlight"><span class="kt">bool</span><span class="p">(</span><span class="n">rhs</span><span class="p">)</span></code> and <code class="highlight"><span class="n">T</span></code> is not <em>cv</em> <code class="highlight"><span class="kt">void</span></code>, initializes <code class="highlight"><span class="n">val</span></code> as if
direct-non-list-initializing an object of type <code class="highlight"><span class="n">T</span></code> with the expression <code class="highlight"><span class="o">*</span><span class="n">rhs</span></code>.</p>
   <p>Otherwise, initializes <code class="highlight"><span class="n">unex</span></code> as if direct-non-list-initializing an object
of type <code class="highlight"><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code> with the expression <code class="highlight"><span class="n">unexpected</span><span class="p">(</span><span class="n">rhs</span><span class="p">.</span><span class="n">error</span><span class="p">())</span></code>.</p>
   <p><em>Postconditions</em>: <code class="highlight"><span class="kt">bool</span><span class="p">(</span><span class="n">rhs</span><span class="p">)</span> <span class="o">==</span> <span class="kt">bool</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="p">)</span></code>.</p>
   <p><em>Throws</em>: Any exception thrown by the selected constructor of <code class="highlight"><span class="n">T</span></code> or <code class="highlight"><span class="n">E</span></code>.</p>
   <p><em>Remarks</em>: This constructor shall not participate in overload resolution unless <code class="highlight"><span class="n">T</span></code> and <code class="highlight"><span class="n">U</span></code> are <em>cv</em> <code class="highlight"><span class="kt">void</span></code> or:</p>
   <ul>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_constructible_v</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span> <span class="k">const</span> <span class="n">U</span><span class="o">&amp;></span></code> is <code class="highlight">true</code> ; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_constructible_v</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span> <span class="n">expected</span><span class="o">&lt;</span><span class="n">U</span><span class="p">,</span> <span class="n">G</span><span class="o">>&amp;></span></code> is <code class="highlight">false</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_constructible_v</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span> <span class="n">expected</span><span class="o">&lt;</span><span class="n">U</span><span class="p">,</span> <span class="n">G</span><span class="o">>&amp;&amp;></span></code> is <code class="highlight">false</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_constructible_v</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span> <span class="k">const</span> <span class="n">expected</span><span class="o">&lt;</span><span class="n">U</span><span class="p">,</span> <span class="n">G</span><span class="o">>&amp;></span></code> is <code class="highlight">false</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_constructible_v</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span> <span class="k">const</span> <span class="n">expected</span><span class="o">&lt;</span><span class="n">U</span><span class="p">,</span> <span class="n">G</span><span class="o">>&amp;&amp;></span></code> is <code class="highlight">false</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_convertible_v</span><span class="o">&lt;</span><span class="n">expected</span><span class="o">&lt;</span><span class="n">U</span><span class="p">,</span> <span class="n">G</span><span class="o">>&amp;</span><span class="p">,</span> <span class="n">T</span><span class="o">></span></code> is <code class="highlight">false</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_convertible_v</span><span class="o">&lt;</span><span class="n">expected</span><span class="o">&lt;</span><span class="n">U</span><span class="p">,</span> <span class="n">G</span><span class="o">>&amp;&amp;</span><span class="p">,</span> <span class="n">T</span><span class="o">></span></code> is <code class="highlight">false</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_convertible_v</span><span class="o">&lt;</span><span class="k">const</span> <span class="n">expected</span><span class="o">&lt;</span><span class="n">U</span><span class="p">,</span> <span class="n">G</span><span class="o">>&amp;</span><span class="p">,</span> <span class="n">T</span><span class="o">></span></code> is <code class="highlight">false</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_convertible_v</span><span class="o">&lt;</span><span class="k">const</span> <span class="n">expected</span><span class="o">&lt;</span><span class="n">U</span><span class="p">,</span> <span class="n">G</span><span class="o">>&amp;&amp;</span><span class="p">,</span> <span class="n">T</span><span class="o">></span></code> is <code class="highlight">false</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_constructible_v</span><span class="o">&lt;</span><span class="n">E</span><span class="p">,</span> <span class="k">const</span> <span class="n">G</span><span class="o">&amp;></span></code> is <code class="highlight">true</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_constructible_v</span><span class="o">&lt;</span><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span><span class="p">,</span> <span class="n">expected</span><span class="o">&lt;</span><span class="n">U</span><span class="p">,</span> <span class="n">G</span><span class="o">>&amp;></span></code> is <code class="highlight">false</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_constructible_v</span><span class="o">&lt;</span><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span><span class="p">,</span> <span class="n">expected</span><span class="o">&lt;</span><span class="n">U</span><span class="p">,</span> <span class="n">G</span><span class="o">>&amp;&amp;></span></code> is <code class="highlight">false</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_constructible_v</span><span class="o">&lt;</span><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span><span class="p">,</span> <span class="k">const</span> <span class="n">expected</span><span class="o">&lt;</span><span class="n">U</span><span class="p">,</span> <span class="n">G</span><span class="o">>&amp;></span></code> is <code class="highlight">false</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_constructible_v</span><span class="o">&lt;</span><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span><span class="p">,</span> <span class="k">const</span> <span class="n">expected</span><span class="o">&lt;</span><span class="n">U</span><span class="p">,</span> <span class="n">G</span><span class="o">>&amp;&amp;></span></code> is <code class="highlight">false</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_convertible_v</span><span class="o">&lt;</span><span class="n">expected</span><span class="o">&lt;</span><span class="n">U</span><span class="p">,</span> <span class="n">G</span><span class="o">>&amp;</span><span class="p">,</span> <span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">>></span></code> is <code class="highlight">false</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_convertible_v</span><span class="o">&lt;</span><span class="n">expected</span><span class="o">&lt;</span><span class="n">U</span><span class="p">,</span> <span class="n">G</span><span class="o">>&amp;&amp;</span><span class="p">,</span> <span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">>></span></code> is <code class="highlight">false</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_convertible_v</span><span class="o">&lt;</span><span class="k">const</span> <span class="n">expected</span><span class="o">&lt;</span><span class="n">U</span><span class="p">,</span> <span class="n">G</span><span class="o">>&amp;</span><span class="p">,</span> <span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">>></span></code> is <code class="highlight">false</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_convertible_v</span><span class="o">&lt;</span><span class="k">const</span> <span class="n">expected</span><span class="o">&lt;</span><span class="n">U</span><span class="p">,</span> <span class="n">G</span><span class="o">>&amp;&amp;</span><span class="p">,</span> <span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">>></span></code> is <code class="highlight">false</code>.</p>
   </ul>
   <p>The constructor is explicit if and only if</p>
   <ul>
    <li data-md="">
     <p><code class="highlight"><span class="n">T</span></code> and <code class="highlight"><span class="n">U</span></code> are not <em>cv</em> <code class="highlight"><span class="kt">void</span></code> and <code class="highlight"><span class="n">is_convertible_v</span><span class="o">&lt;</span><span class="k">const</span> <span class="n">U</span><span class="o">&amp;</span><span class="p">,</span> <span class="n">T</span><span class="o">></span></code> is <code class="highlight">false</code> or</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_convertible_v</span><span class="o">&lt;</span><span class="k">const</span> <span class="n">G</span><span class="o">&amp;</span><span class="p">,</span> <span class="n">E</span><span class="o">></span></code> is <code class="highlight">false</code>.</p>
   </ul>
<pre class="language-c++ highlight"><span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">U</span><span class="p">,</span> <span class="n">class</span> <span class="n">G</span><span class="o">></span>
    <span class="n">EXPLICIT</span> <span class="n">constexpr</span> <span class="n">expected</span><span class="p">(</span><span class="n">expected</span><span class="o">&lt;</span><span class="n">U</span><span class="p">,</span> <span class="n">G</span><span class="o">>&amp;&amp;</span> <span class="n">rhs</span><span class="p">);</span>
</pre>
   <p><em>Effects</em>: If <code class="highlight"><span class="kt">bool</span><span class="p">(</span><span class="n">rhs</span><span class="p">)</span></code> initializes <code class="highlight"><span class="n">val</span></code> as if
direct-non-list-initializing an object of type <code class="highlight"><span class="n">T</span></code> with the expression <code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">move</span><span class="p">(</span><span class="o">*</span><span class="n">rhs</span><span class="p">)</span></code> or nothing if <code class="highlight"><span class="n">T</span></code> is <em>cv</em> <code class="highlight"><span class="kt">void</span></code>.</p>
   <p>Otherwise, initializes <code class="highlight"><span class="n">unex</span></code> as if direct-non-list-initializing an object
of type <code class="highlight"><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code> with the expression <code class="highlight"><span class="n">unexpected</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">move</span><span class="p">(</span><span class="n">rhs</span><span class="p">.</span><span class="n">error</span><span class="p">()))</span></code>.</p>
   <p><em>Postconditions</em>: <code class="highlight"><span class="kt">bool</span><span class="p">(</span><span class="n">rhs</span><span class="p">)</span></code> is unchanged, <code class="highlight"><span class="kt">bool</span><span class="p">(</span><span class="n">rhs</span><span class="p">)</span> <span class="o">==</span> <span class="kt">bool</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="p">)</span></code>.</p>
   <p><em>Throws</em>: Any exception thrown by operations specified in the effect clause.</p>
   <p><em>Remarks</em>: This constructor shall not participate in overload resolution unless: <code class="highlight"><span class="n">T</span></code> and <code class="highlight"><span class="n">U</span></code> are <em>cv</em> <code class="highlight"><span class="kt">void</span></code> or:</p>
   <ul>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_constructible_v</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span> <span class="n">U</span><span class="o">&amp;&amp;></span></code> is <code class="highlight">true</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_constructible_v</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span> <span class="n">expected</span><span class="o">&lt;</span><span class="n">U</span><span class="p">,</span> <span class="n">G</span><span class="o">>&amp;></span></code> is <code class="highlight">false</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_constructible_v</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span> <span class="n">expected</span><span class="o">&lt;</span><span class="n">U</span><span class="p">,</span> <span class="n">G</span><span class="o">>&amp;&amp;></span></code> is <code class="highlight">false</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_constructible_v</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span> <span class="k">const</span> <span class="n">expected</span><span class="o">&lt;</span><span class="n">U</span><span class="p">,</span> <span class="n">G</span><span class="o">>&amp;></span></code> is <code class="highlight">false</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_constructible_v</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span> <span class="k">const</span> <span class="n">expected</span><span class="o">&lt;</span><span class="n">U</span><span class="p">,</span> <span class="n">G</span><span class="o">>&amp;&amp;></span></code> is <code class="highlight">false</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_convertible_v</span><span class="o">&lt;</span><span class="n">expected</span><span class="o">&lt;</span><span class="n">U</span><span class="p">,</span> <span class="n">G</span><span class="o">>&amp;</span><span class="p">,</span> <span class="n">T</span><span class="o">></span></code> is <code class="highlight">false</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_convertible_v</span><span class="o">&lt;</span><span class="n">expected</span><span class="o">&lt;</span><span class="n">U</span><span class="p">,</span> <span class="n">G</span><span class="o">>&amp;&amp;</span><span class="p">,</span> <span class="n">T</span><span class="o">></span></code> is <code class="highlight">false</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_convertible_v</span><span class="o">&lt;</span><span class="k">const</span> <span class="n">expected</span><span class="o">&lt;</span><span class="n">U</span><span class="p">,</span> <span class="n">G</span><span class="o">>&amp;</span><span class="p">,</span> <span class="n">T</span><span class="o">></span></code> is <code class="highlight">false</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_convertible_v</span><span class="o">&lt;</span><span class="k">const</span> <span class="n">expected</span><span class="o">&lt;</span><span class="n">U</span><span class="p">,</span> <span class="n">G</span><span class="o">>&amp;&amp;</span><span class="p">,</span> <span class="n">T</span><span class="o">></span></code> is <code class="highlight">false</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_constructible_v</span><span class="o">&lt;</span><span class="n">E</span><span class="p">,</span> <span class="n">G</span><span class="o">&amp;&amp;></span></code> is <code class="highlight">true</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_constructible_v</span><span class="o">&lt;</span><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span><span class="p">,</span> <span class="n">expected</span><span class="o">&lt;</span><span class="n">U</span><span class="p">,</span> <span class="n">G</span><span class="o">>&amp;></span></code> is <code class="highlight">false</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_constructible_v</span><span class="o">&lt;</span><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span><span class="p">,</span> <span class="n">expected</span><span class="o">&lt;</span><span class="n">U</span><span class="p">,</span> <span class="n">G</span><span class="o">>&amp;&amp;></span></code> is <code class="highlight">false</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_constructible_v</span><span class="o">&lt;</span><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span><span class="p">,</span> <span class="k">const</span> <span class="n">expected</span><span class="o">&lt;</span><span class="n">U</span><span class="p">,</span> <span class="n">G</span><span class="o">>&amp;></span></code> is <code class="highlight">false</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_constructible_v</span><span class="o">&lt;</span><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span><span class="p">,</span> <span class="k">const</span> <span class="n">expected</span><span class="o">&lt;</span><span class="n">U</span><span class="p">,</span> <span class="n">G</span><span class="o">>&amp;&amp;></span></code> is <code class="highlight">false</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_convertible_v</span><span class="o">&lt;</span><span class="n">expected</span><span class="o">&lt;</span><span class="n">U</span><span class="p">,</span> <span class="n">G</span><span class="o">>&amp;</span><span class="p">,</span> <span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">>></span></code> is <code class="highlight">false</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_convertible_v</span><span class="o">&lt;</span><span class="n">expected</span><span class="o">&lt;</span><span class="n">U</span><span class="p">,</span> <span class="n">G</span><span class="o">>&amp;&amp;</span><span class="p">,</span> <span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">>></span></code> is <code class="highlight">false</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_convertible_v</span><span class="o">&lt;</span><span class="k">const</span> <span class="n">expected</span><span class="o">&lt;</span><span class="n">U</span><span class="p">,</span> <span class="n">G</span><span class="o">>&amp;</span><span class="p">,</span> <span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">>></span></code> is <code class="highlight">false</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_convertible_v</span><span class="o">&lt;</span><span class="k">const</span> <span class="n">expected</span><span class="o">&lt;</span><span class="n">U</span><span class="p">,</span> <span class="n">G</span><span class="o">>&amp;&amp;</span><span class="p">,</span> <span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">>></span></code> is <code class="highlight">false</code>.</p>
   </ul>
   <p>The constructor is explicit if and only if</p>
   <ul>
    <li data-md="">
     <p><code class="highlight"><span class="n">T</span></code> and <code class="highlight"><span class="n">U</span></code> are not <em>cv</em> <code class="highlight"><span class="kt">void</span></code> and <code class="highlight"><span class="n">is_convertible_v</span><span class="o">&lt;</span><span class="n">U</span><span class="o">&amp;&amp;</span><span class="p">,</span> <span class="n">T</span><span class="o">></span></code> is <code class="highlight">false</code> or</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_convertible_v</span><span class="o">&lt;</span><span class="n">G</span><span class="o">&amp;&amp;</span><span class="p">,</span> <span class="n">E</span><span class="o">></span></code> is <code class="highlight">false</code>.</p>
   </ul>
<pre class="language-c++ highlight"><span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">U</span> <span class="o">=</span> <span class="n">T</span><span class="o">></span>
    <span class="n">EXPLICIT</span> <span class="n">constexpr</span> <span class="n">expected</span><span class="p">(</span><span class="n">U</span><span class="o">&amp;&amp;</span> <span class="n">v</span><span class="p">);</span>
</pre>
   <p><em>Effects</em>: Initializes <code class="highlight"><span class="n">val</span></code> as if direct-non-list-initializing an
object of type <code class="highlight"><span class="n">T</span></code> with the expression <code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">forward</span><span class="o">&lt;</span><span class="n">U</span><span class="o">></span><span class="p">(</span><span class="n">v</span><span class="p">)</span></code>.</p>
   <p><em>Postconditions</em>: <code class="highlight"><span class="kt">bool</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="p">)</span></code> .</p>
   <p><em>Throws</em>: Any exception thrown by the selected constructor of <code class="highlight"><span class="n">T</span></code>.</p>
   <p><em>Remarks</em>: If <code class="highlight"><span class="n">T</span></code>'s selected constructor is a constant subexpression, this
constructor shall be a constexpr constructor. This constructor shall not
participate in overload resolution unless:</p>
   <ul>
    <li data-md="">
     <p><code class="highlight"><span class="n">T</span></code> is not <em>cv</em> <code class="highlight"><span class="kt">void</span></code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_constructible_v</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span> <span class="n">U</span><span class="o">&amp;&amp;></span></code> is <code class="highlight">true</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_same_v</span><span class="o">&lt;</span><span class="n">remove_cvref_t</span><span class="o">&lt;</span><span class="n">U</span><span class="o">></span><span class="p">,</span> <span class="n">in_place_t</span><span class="o">></span></code> is <code class="highlight">false</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_same_v</span><span class="o">&lt;</span><span class="n">expected</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span> <span class="n">E</span><span class="o">></span><span class="p">,</span> <span class="n">remove_cvref_t</span><span class="o">&lt;</span><span class="n">U</span><span class="o">>></span></code> is <code class="highlight">false</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_same_v</span><span class="o">&lt;</span><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span><span class="p">,</span> <span class="n">remove_cvref_t</span><span class="o">&lt;</span><span class="n">U</span><span class="o">>></span></code> is <code class="highlight">false</code>.</p>
   </ul>
   <p>The constructor is explicit if and only if <code class="highlight"><span class="n">is_convertible_v</span><span class="o">&lt;</span><span class="n">U</span><span class="o">&amp;&amp;</span><span class="p">,</span> <span class="n">T</span><span class="o">></span></code> is <code class="highlight">false</code>.</p>
<pre class="language-c++ highlight"><span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">G</span> <span class="o">=</span> <span class="n">E</span><span class="o">></span>
    <span class="n">EXPLICIT</span> <span class="n">constexpr</span> <span class="n">expected</span><span class="p">(</span><span class="k">const</span> <span class="n">unexpected</span><span class="o">&lt;</span><span class="n">G</span><span class="o">>&amp;</span> <span class="n">e</span><span class="p">);</span>
</pre>
   <p><em>Effects</em>: Initializes <code class="highlight"><span class="n">unex</span></code> as if direct-non-list-initializing
an object of type <code class="highlight"><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code> with the expression <code class="highlight"><span class="n">e</span></code>.</p>
   <p><em>Postconditions</em>: <code class="highlight"><span class="o">!</span><span class="kt">bool</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="p">)</span></code>.</p>
   <p><em>Throws</em>: Any exception thrown by the selected constructor of <code class="highlight"><span class="n">E</span></code>.</p>
   <p><em>Remarks</em>: If <code class="highlight"><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code>'s selected constructor is a constant subexpression,
this constructor shall be a constexpr constructor. This constructor shall not
participate in overload resolution unless <code class="highlight"><span class="n">is_constructible_v</span><span class="o">&lt;</span><span class="n">E</span><span class="p">,</span> <span class="k">const</span> <span class="n">G</span><span class="o">&amp;></span></code> is <code class="highlight">true</code>. The
constructor is explicit if and only if <code class="highlight"><span class="n">is_convertible_v</span><span class="o">&lt;</span><span class="k">const</span> <span class="n">G</span><span class="o">&amp;</span><span class="p">,</span> <span class="n">E</span><span class="o">></span></code> is <code class="highlight">false</code>.</p>
<pre class="language-c++ highlight"><span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">G</span> <span class="o">=</span> <span class="n">E</span><span class="o">></span>
    <span class="n">EXPLICIT</span> <span class="n">constexpr</span> <span class="n">expected</span><span class="p">(</span><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">G</span><span class="o">>&amp;&amp;</span> <span class="n">e</span><span class="p">);</span>
</pre>
   <p><em>Effects</em>: Initializes <code class="highlight"><span class="n">unex</span></code> as if direct-non-list-initializing
an object of type <code class="highlight"><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code> with the expression <code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">move</span><span class="p">(</span><span class="n">e</span><span class="p">)</span></code>.</p>
   <p><em>Postconditions</em>: <code class="highlight"><span class="o">!</span><span class="kt">bool</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="p">)</span></code>.</p>
   <p><em>Throws</em>: Any exception thrown by the selected constructor of <code class="highlight"><span class="n">E</span></code>.</p>
   <p><em>Remarks</em>: If <code class="highlight"><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code>'s selected constructor is a constant subexpression,
this constructor shall be a constexpr constructor. The expression inside <code class="highlight"><span class="k">noexcept</span></code> is equivalent to: <code class="highlight"><span class="n">is_nothrow_constructible_v</span><span class="o">&lt;</span><span class="n">E</span><span class="p">,</span> <span class="n">G</span><span class="o">&amp;&amp;></span></code> is <code class="highlight">true</code>. This
constructor shall not participate in overload resolution unless <code class="highlight"><span class="n">is_constructible_v</span><span class="o">&lt;</span><span class="n">E</span><span class="p">,</span> <span class="n">G</span><span class="o">&amp;&amp;></span></code> is <code class="highlight">true</code>. The constructor is explicit if and only if <code class="highlight"><span class="n">is_convertible_v</span><span class="o">&lt;</span><span class="n">G</span><span class="o">&amp;&amp;</span><span class="p">,</span> <span class="n">E</span><span class="o">></span></code> is <code class="highlight">false</code>.</p>
<pre class="language-c++ highlight"><span class="n">template</span><span class="o">&lt;</span><span class="n">class</span><span class="p">...</span> <span class="n">Args</span><span class="o">></span>
    <span class="n">constexpr</span> <span class="n">explicit</span> <span class="n">expected</span><span class="p">(</span><span class="n">in_place_t</span><span class="p">,</span> <span class="n">Args</span><span class="o">&amp;&amp;</span><span class="p">...</span> <span class="n">args</span><span class="p">);</span>
</pre>
   <p><em>Effects</em>: If <code class="highlight"><span class="n">T</span></code> is <em>cv</em> <code class="highlight"><span class="kt">void</span></code>, no effects. Otherwise, initializes <code class="highlight"><span class="n">val</span></code> as if
direct-non-list-initializing an object of type <code class="highlight"><span class="n">T</span></code> with the arguments <code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">forward</span><span class="o">&lt;</span><span class="n">Args</span><span class="o">></span><span class="p">(</span><span class="n">args</span><span class="p">)...</span></code>.</p>
   <p><em>Postconditions</em>: <code class="highlight"><span class="kt">bool</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="p">)</span></code> .</p>
   <p><em>Throws</em>: Any exception thrown by the selected constructor of <code class="highlight"><span class="n">T</span></code>.</p>
   <p><em>Remarks</em>: If <code class="highlight"><span class="n">T</span></code>'s constructor selected for the initialization is a constant subexpression,
this constructor shall be a constexpr constructor. This
constructor shall not participate in overload resolution unless:</p>
   <ul>
    <li data-md="">
     <p><code class="highlight"><span class="n">T</span></code> is <em>cv</em> <code class="highlight"><span class="kt">void</span></code> and <code class="highlight"><span class="k">sizeof</span><span class="p">...(</span><span class="n">Args</span><span class="p">)</span> <span class="o">==</span> <span class="mi">0</span></code>; or</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">T</span></code> is not <em>cv</em> <code class="highlight"><span class="kt">void</span></code> and <code class="highlight"><span class="n">is_constructible_v</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span> <span class="n">Args</span><span class="p">...</span><span class="o">></span></code> is <code class="highlight">true</code>.</p>
   </ul>
<pre class="language-c++ highlight"><span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">U</span><span class="p">,</span> <span class="n">class</span><span class="p">...</span> <span class="n">Args</span><span class="o">></span>
    <span class="n">constexpr</span> <span class="n">explicit</span> <span class="n">expected</span><span class="p">(</span><span class="n">in_place_t</span><span class="p">,</span> <span class="n">initializer_list</span><span class="o">&lt;</span><span class="n">U</span><span class="o">></span> <span class="n">il</span><span class="p">,</span> <span class="n">Args</span><span class="o">&amp;&amp;</span><span class="p">...</span> <span class="n">args</span><span class="p">);</span>
</pre>
   <p><em>Effects</em>: Initializes <code class="highlight"><span class="n">val</span></code> as if direct-non-list-initializing an
object of type <code class="highlight"><span class="n">T</span></code> with the arguments <code class="highlight"><span class="n">il</span><span class="p">,</span> <span class="n">std</span><span class="o">::</span><span class="n">forward</span><span class="o">&lt;</span><span class="n">Args</span><span class="o">></span><span class="p">(</span><span class="n">args</span><span class="p">)...</span></code>.</p>
   <p><em>Postconditions</em>: <code class="highlight"><span class="kt">bool</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="p">)</span></code> .</p>
   <p><em>Throws</em>: Any exception thrown by the selected constructor of <code class="highlight"><span class="n">T</span></code>.</p>
   <p><em>Remarks</em>: If <code class="highlight"><span class="n">T</span></code>'s constructor selected for the initialization is a constant subexpression,
this constructor shall be a constexpr constructor. This
constructor shall not participate in overload resolution unless <code class="highlight"><span class="n">T</span></code> is not <em>cv</em> <code class="highlight"><span class="kt">void</span></code> and <code class="highlight"><span class="n">is_constructible_v</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span> <span class="n">initializer_list</span><span class="o">&lt;</span><span class="n">U</span><span class="o">>&amp;</span><span class="p">,</span> <span class="n">Args</span><span class="p">...</span><span class="o">></span></code> is <code class="highlight">true</code>.</p>
<pre class="language-c++ highlight"><span class="n">template</span><span class="o">&lt;</span><span class="n">class</span><span class="p">...</span> <span class="n">Args</span><span class="o">></span>
    <span class="n">constexpr</span> <span class="n">explicit</span> <span class="n">expected</span><span class="p">(</span><span class="n">unexpect_t</span><span class="p">,</span> <span class="n">Args</span><span class="o">&amp;&amp;</span><span class="p">...</span> <span class="n">args</span><span class="p">);</span>
</pre>
   <p><em>Effects</em>: Initializes <code class="highlight"><span class="n">unex</span></code> as if direct-non-list-initializing
an object of type <code class="highlight"><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code>with the arguments <code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">forward</span><span class="o">&lt;</span><span class="n">Args</span><span class="o">></span><span class="p">(</span><span class="n">args</span><span class="p">)...</span></code>.</p>
   <p><em>Postconditions</em>: <code class="highlight"><span class="o">!</span><span class="kt">bool</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="p">)</span></code>.</p>
   <p><em>Throws</em>: Any exception thrown by the selected constructor of <code class="highlight"><span class="n">E</span></code>.</p>
   <p><em>Remarks</em>: If <code class="highlight"><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code>'s constructor selected for the initialization is a
constant subexpression, this constructor shall be a constexpr constructor. This
constructor shall not participate in overload resolution unless <code class="highlight"><span class="n">is_constructible_v</span><span class="o">&lt;</span><span class="n">E</span><span class="p">,</span> <span class="n">Args</span><span class="p">...</span><span class="o">></span></code> is <code class="highlight">true</code>.</p>
<pre class="language-c++ highlight"><span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">U</span><span class="p">,</span> <span class="n">class</span><span class="p">...</span> <span class="n">Args</span><span class="o">></span>
    <span class="n">constexpr</span> <span class="n">explicit</span> <span class="n">expected</span><span class="p">(</span><span class="n">unexpect_t</span><span class="p">,</span> <span class="n">initializer_list</span><span class="o">&lt;</span><span class="n">U</span><span class="o">></span> <span class="n">il</span><span class="p">,</span> <span class="n">Args</span><span class="o">&amp;&amp;</span><span class="p">...</span> <span class="n">args</span><span class="p">);</span>
</pre>
   <p><em>Effects</em>: Initializes <code class="highlight"><span class="n">unex</span></code> as if direct-non-list-initializing
an object of type <code class="highlight"><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code> with the arguments <code class="highlight"><span class="n">il</span><span class="p">,</span> <span class="n">std</span><span class="o">::</span><span class="n">forward</span><span class="o">&lt;</span><span class="n">Args</span><span class="o">></span><span class="p">(</span><span class="n">args</span><span class="p">)...</span></code>.</p>
   <p><em>Postconditions</em>: <code class="highlight"><span class="o">!</span><span class="kt">bool</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="p">)</span></code>.</p>
   <p><em>Throws</em>: Any exception thrown by the selected constructor of <code class="highlight"><span class="n">E</span></code>.</p>
   <p><em>Remarks</em>: If <code class="highlight"><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code>'s constructor selected for the initialization is a
constant subexpression, this constructor shall be a constexpr constructor. This
constructor shall not participate in overload resolution unless <code class="highlight"><span class="n">is_constructible_v</span><span class="o">&lt;</span><span class="n">E</span><span class="p">,</span> <span class="n">initializer_list</span><span class="o">&lt;</span><span class="n">U</span><span class="o">>&amp;</span><span class="p">,</span> <span class="n">Args</span><span class="p">...</span><span class="o">></span></code> is <code class="highlight">true</code>.</p>
   <h3 class="heading settled" data-level="1.7" id="expected.object.dtor"><span class="secno">1.7. </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"><span class="o">~</span><span class="n">expected</span><span class="p">();</span>
</pre>
   <p><em>Effects</em>: If <code class="highlight"><span class="n">T</span></code> is not <em>cv</em> <code class="highlight"><span class="kt">void</span></code> and <code class="highlight"><span class="n">is_trivially_destructible_v</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span></code> is <code class="highlight">false</code> and <code class="highlight"><span class="kt">bool</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="p">)</span></code>, calls <code class="highlight"><span class="n">val</span><span class="p">.</span><span class="o">~</span><span class="n">T</span><span class="p">()</span></code>. If <code class="highlight"><span class="n">is_trivially_destructible_v</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code> is <code class="highlight">false</code> and <code class="highlight"><span class="o">!</span><span class="kt">bool</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="p">)</span></code>, calls <code class="highlight"><span class="n">unexpect</span><span class="p">.</span><span class="o">~</span><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span><span class="p">()</span></code>.</p>
   <p><em>Remarks</em>: If either <code class="highlight"><span class="n">T</span></code> is <em>cv</em> <code class="highlight"><span class="kt">void</span></code> or <code class="highlight"><span class="n">is_trivially_destructible_v</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span></code> is <code class="highlight">true</code>, and <code class="highlight"><span class="n">is_trivially_destructible_v</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code> is <code class="highlight">true</code>, then this destructor
shall be a trivial destructor.</p>
   <h3 class="heading settled" data-level="1.8" id="expected.object.assign"><span class="secno">1.8. </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"><span class="n">expected</span><span class="o">&amp;</span> <span class="n">operator</span><span class="o">=</span><span class="p">(</span><span class="k">const</span> <span class="n">expected</span><span class="o">&amp;</span> <span class="n">rhs</span><span class="p">)</span> <span class="n">noexcept</span><span class="p">(</span><span class="n">see</span> <span class="n">below</span><span class="p">);</span>
</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"><span class="k">operator</span><span class="o">=</span><span class="p">(</span><span class="k">const</span> <span class="n">expected</span><span class="o">&amp;</span><span class="p">)</span></code> effects</caption>
    <tbody>
     <tr>
      <td>
      <td><code class="highlight"><span class="kt">bool</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="p">)</span></code>
      <td><code class="highlight"><span class="o">!</span><span class="kt">bool</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="p">)</span></code>
     <tr>
      <td><code class="highlight"><span class="kt">bool</span><span class="p">(</span><span class="n">rhs</span><span class="p">)</span></code>
      <td>assigns <code class="highlight"><span class="o">*</span><span class="n">rhs</span></code> to <code class="highlight"><span class="n">val</span></code> if <code class="highlight"><span class="n">T</span></code> is not <em>cv</em> <code class="highlight"><span class="kt">void</span></code>
      <td>
       <ul>
        <li data-md="">
         <p>if <code class="highlight"><span class="n">T</span></code> is <em>cv</em> <code class="highlight"><span class="kt">void</span></code> destroys <code class="highlight"><span class="n">unex</span></code> by calling <code class="highlight"><span class="n">unexpect</span><span class="p">.</span><span class="o">~</span><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span><span class="p">()</span></code> and set <code class="highlight"><span class="n">has_val</span></code> to <code class="highlight">true</code>,</p>
        <li data-md="">
         <p>otherwise if <code class="highlight"><span class="n">is_nothrow_copy_constructible_v</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span></code> is <code class="highlight">true</code></p>
         <ul>
          <li data-md="">
           <p>destroys <code class="highlight"><span class="n">unex</span></code> by calling <code class="highlight"><span class="n">unexpect</span><span class="p">.</span><span class="o">~</span><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span><span class="p">()</span></code></p>
          <li data-md="">
           <p>initializes <code class="highlight"><span class="n">val</span></code> as if direct-non-list-initializing an object of type <code class="highlight"><span class="n">T</span></code> with <code class="highlight"><span class="o">*</span><span class="n">rhs</span></code>;</p>
         </ul>
        <li data-md="">
         <p>otherwise if <code class="highlight"><span class="n">is_nothrow_move_constructible_v</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span></code> is <code class="highlight">true</code></p>
         <ul>
          <li data-md="">
           <p>constructs a <code class="highlight"><span class="n">T</span> <span class="n">tmp</span></code> from <code class="highlight"><span class="o">*</span><span class="n">rhs</span></code> (this can throw),</p>
          <li data-md="">
           <p>destroys <code class="highlight"><span class="n">unex</span></code> by calling <code class="highlight"><span class="n">unexpect</span><span class="p">.</span><span class="o">~</span><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span><span class="p">()</span></code></p>
          <li data-md="">
           <p>initializes <code class="highlight"><span class="n">val</span></code> as if direct-non-list-initializing an object of type <code class="highlight"><span class="n">T</span></code> with <code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">move</span><span class="p">(</span><span class="n">tmp</span><span class="p">)</span></code>;</p>
         </ul>
        <li data-md="">
         <p>otherwise</p>
         <ul>
          <li data-md="">
           <p>constructs an <code class="highlight"><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span> <span class="n">tmp</span></code> from <code class="highlight"><span class="n">unexpected</span><span class="p">(</span><span class="k">this</span><span class="o">-></span><span class="n">error</span><span class="p">())</span></code> (which can throw),</p>
          <li data-md="">
           <p>destroys <code class="highlight"><span class="n">unex</span></code> by calling <code class="highlight"><span class="n">unexpect</span><span class="p">.</span><span class="o">~</span><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span><span class="p">()</span></code>,</p>
          <li data-md="">
           <p>initializes <code class="highlight"><span class="n">val</span></code> as if direct-non-list-initializing an object of type <code class="highlight"><span class="n">T</span></code> with <code class="highlight"><span class="o">*</span><span class="n">rhs</span></code>. Either,</p>
          <li data-md="">
           <p>the constructor didn’t throw, set <code class="highlight"><span class="n">has_val</span></code> to <code class="highlight">true</code>, or</p>
          <li data-md="">
           <p>the constructor did throw, so move-construct the <code class="highlight"><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code> from <code class="highlight"><span class="n">tmp</span></code> back into the expected storage (which can’t throw as <code class="highlight"><span class="n">is_nothrow_move_constructible_v</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code> is <code class="highlight">true</code>), and rethrow the exception.</p>
         </ul>
       </ul>
     <tr>
      <td><code class="highlight"><span class="o">!</span><span class="kt">bool</span><span class="p">(</span><span class="n">rhs</span><span class="p">)</span></code>
      <td>
       <ul>
        <li data-md="">
         <p>if <code class="highlight"><span class="n">T</span></code> is <em>cv</em> <code class="highlight"><span class="kt">void</span></code></p>
         <ul>
          <li data-md="">
           <p>initializes <code class="highlight"><span class="n">unex</span></code> as if direct-non-list-initializing an object of type <code class="highlight"><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code> with <code class="highlight"><span class="n">unexpected</span><span class="p">(</span><span class="n">rhs</span><span class="p">.</span><span class="n">error</span><span class="p">())</span></code>. Either</p>
          <li data-md="">
           <p>the constructor didn’t throw, set <code class="highlight"><span class="n">has_val</span></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"><span class="n">is_nothrow_copy_constructible_v</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code> is <code class="highlight">true</code></p>
         <ul>
          <li data-md="">
           <p>destroys <code class="highlight"><span class="n">val</span></code> by calling <code class="highlight"><span class="n">val</span><span class="p">.</span><span class="o">~</span><span class="n">T</span><span class="p">()</span></code>,</p>
          <li data-md="">
           <p>initializes <code class="highlight"><span class="n">unex</span></code> as if direct-non-list-initializing an object of type <code class="highlight"><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code> with <code class="highlight"><span class="n">unexpected</span><span class="p">(</span><span class="n">rhs</span><span class="p">.</span><span class="n">error</span><span class="p">())</span></code> and set <code class="highlight"><span class="n">has_val</span></code> to <code class="highlight">false</code>.</p>
         </ul>
        <li data-md="">
         <p>otherwise if <code class="highlight"><span class="n">is_nothrow_move_constructible_v</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code> is <code class="highlight">true</code></p>
         <ul>
          <li data-md="">
           <p>constructs an <code class="highlight"><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span> <span class="n">tmp</span></code> from <code class="highlight"><span class="n">unexpected</span><span class="p">(</span><span class="n">rhs</span><span class="p">.</span><span class="n">error</span><span class="p">())</span></code> (this can throw),</p>
          <li data-md="">
           <p>destroys <code class="highlight"><span class="n">val</span></code> by calling <code class="highlight"><span class="n">val</span><span class="p">.</span><span class="o">~</span><span class="n">T</span><span class="p">()</span></code>,</p>
          <li data-md="">
           <p>initializes <code class="highlight"><span class="n">unex</span></code> as if direct-non-list-initializing an object of type <code class="highlight"><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code> with <code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">move</span><span class="p">(</span><span class="n">tmp</span><span class="p">)</span></code> and set <code class="highlight"><span class="n">has_val</span></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"><span class="n">T</span> <span class="n">tmp</span></code> from <code class="highlight"><span class="o">*</span><span class="k">this</span></code> (this can throw),</p>
          <li data-md="">
           <p>destroys <code class="highlight"><span class="n">val</span></code> by calling <code class="highlight"><span class="n">val</span><span class="p">.</span><span class="o">~</span><span class="n">T</span><span class="p">()</span></code>,</p>
          <li data-md="">
           <p>initializes <code class="highlight"><span class="n">unex</span></code> as if direct-non-list-initializing an object of type <code class="highlight"><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code> with <code class="highlight"><span class="n">unexpected</span><span class="p">(</span><span class="n">rhs</span><span class="p">.</span><span class="n">error</span><span class="p">())</span></code>. Either,</p>
          <li data-md="">
           <p>the last constructor didn’t throw, set <code class="highlight"><span class="n">has_val</span></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"><span class="n">T</span></code> from <code class="highlight"><span class="n">tmp</span></code> back into the expected storage (which can’t throw as <code class="highlight"><span class="n">is_nothrow_move_constructible_v</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span></code> is <code class="highlight">true</code>), and rethrow the exception.</p>
         </ul>
       </ul>
      <td>assigns <code class="highlight"><span class="n">unexpected</span><span class="p">(</span><span class="n">rhs</span><span class="p">.</span><span class="n">error</span><span class="p">())</span></code> to <code class="highlight"><span class="n">unex</span></code>
   </table>
   <p><em>Returns</em>: <code class="highlight"><span class="o">*</span><span class="k">this</span></code>.</p>
   <p><em>Postconditions</em>: <code class="highlight"><span class="kt">bool</span><span class="p">(</span><span class="n">rhs</span><span class="p">)</span> <span class="o">==</span> <span class="kt">bool</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="p">)</span></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"><span class="kt">bool</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="p">)</span></code> and <code class="highlight"><span class="kt">bool</span><span class="p">(</span><span class="n">rhs</span><span class="p">)</span></code> remain unchanged.</p>
   <p>If an exception is thrown during the call to <code class="highlight"><span class="n">T</span></code>'s or <code class="highlight"><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code>'s copy
constructor, no effect. If an exception is thrown during the call to <code class="highlight"><span class="n">T</span></code>'s or <code class="highlight"><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code>'s copy assignment, the state of its contained value is as defined
by the exception safety guarantee of <code class="highlight"><span class="n">T</span></code>'s or <code class="highlight"><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code>'s copy assignment.</p>
   <p>This operator shall be defined as deleted unless:</p>
   <ul>
    <li data-md="">
     <p><code class="highlight"><span class="n">T</span></code> is <em>cv</em> <code class="highlight"><span class="kt">void</span></code> and <code class="highlight"><span class="n">is_copy_assignable_v</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code> is <code class="highlight">true</code> and <code class="highlight"><span class="n">is_copy_constructible_v</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code> is <code class="highlight">true</code>; or</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">T</span></code> is not <em>cv</em> <code class="highlight"><span class="kt">void</span></code> and <code class="highlight"><span class="n">is_copy_assignable_v</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span></code> is <code class="highlight">true</code> and <code class="highlight"><span class="n">is_copy_constructible_v</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span></code> is <code class="highlight">true</code> and <code class="highlight"><span class="n">is_copy_assignable_v</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code> is <code class="highlight">true</code> and <code class="highlight"><span class="n">is_copy_constructible_v</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code> is <code class="highlight">true</code> and
(<code class="highlight"><span class="n">is_nothrow_move_constructible_v</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code> is <code class="highlight">true</code> or <code class="highlight"><span class="n">is_nothrow_move_constructible_v</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span></code> is <code class="highlight">true</code>).</p>
   </ul>
<pre class="language-c++ highlight"><span class="n">expected</span><span class="o">&amp;</span> <span class="n">operator</span><span class="o">=</span><span class="p">(</span><span class="n">expected</span><span class="o">&amp;&amp;</span> <span class="n">rhs</span><span class="p">)</span> <span class="n">noexcept</span><span class="p">(</span><span class="n">see</span> <span class="n">below</span><span class="p">);</span>
</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"><span class="k">operator</span><span class="o">=</span><span class="p">(</span><span class="n">expected</span><span class="o">&amp;&amp;</span><span class="p">)</span></code> effects</caption>
    <tbody>
     <tr>
      <td>
      <td><code class="highlight"><span class="kt">bool</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="p">)</span></code>
      <td><code class="highlight"><span class="o">!</span><span class="kt">bool</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="p">)</span></code>
     <tr>
      <td><code class="highlight"><span class="kt">bool</span><span class="p">(</span><span class="n">rhs</span><span class="p">)</span></code>
      <td>move assign <code class="highlight"><span class="o">*</span><span class="n">rhs</span></code> to <code class="highlight"><span class="n">val</span></code> if <code class="highlight"><span class="n">T</span></code> is not <em>cv</em> <code class="highlight"><span class="kt">void</span></code>
      <td>
       <ul>
        <li data-md="">
         <p>if <code class="highlight"><span class="n">T</span></code> is <em>cv</em> <code class="highlight"><span class="kt">void</span></code> destroys <code class="highlight"><span class="n">unex</span></code> by calling <code class="highlight"><span class="n">unexpect</span><span class="p">.</span><span class="o">~</span><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span><span class="p">()</span></code></p>
        <li data-md="">
         <p>otherwise if <code class="highlight"><span class="n">is_nothrow_move_constructible_v</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span></code> is <code class="highlight">true</code></p>
         <ul>
          <li data-md="">
           <p>destroys <code class="highlight"><span class="n">unex</span></code> by calling <code class="highlight"><span class="n">unexpect</span><span class="p">.</span><span class="o">~</span><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span><span class="p">()</span></code>,</p>
          <li data-md="">
           <p>initializes <code class="highlight"><span class="n">val</span></code> as if direct-non-list-initializing an object of type <code class="highlight"><span class="n">T</span></code> with <code class="highlight"><span class="o">*</span><span class="n">std</span><span class="o">::</span><span class="n">move</span><span class="p">(</span><span class="n">rhs</span><span class="p">)</span></code>;</p>
         </ul>
        <li data-md="">
         <p>otherwise</p>
         <ul>
          <li data-md="">
           <p>move constructs an <code class="highlight"><span class="n">unexpected_type</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span> <span class="n">tmp</span></code> from <code class="highlight"><span class="n">unexpected</span><span class="p">(</span><span class="k">this</span><span class="o">-></span><span class="n">error</span><span class="p">())</span></code> (which can’t throw as <code class="highlight"><span class="n">E</span></code> is nothrow-move-constructible),</p>
          <li data-md="">
           <p>destroys <code class="highlight"><span class="n">unex</span></code> by calling <code class="highlight"><span class="n">unexpect</span><span class="p">.</span><span class="o">~</span><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span><span class="p">()</span></code>,</p>
          <li data-md="">
           <p>initializes <code class="highlight"><span class="n">val</span></code> as if direct-non-list-initializing an object of type <code class="highlight"><span class="n">T</span></code> with <code class="highlight"><span class="o">*</span><span class="n">std</span><span class="o">::</span><span class="n">move</span><span class="p">(</span><span class="n">rhs</span><span class="p">)</span></code>. Either,</p>
          <li data-md="">
           <p>The constructor didn’t throw, set <code class="highlight"><span class="n">has_val</span></code> to <code class="highlight">true</code>, or</p>
          <li data-md="">
           <p>The constructor did throw, so move-construct the <code class="highlight"><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code> from <code class="highlight"><span class="n">tmp</span></code> back into the expected storage (which can’t throw as <code class="highlight"><span class="n">E</span></code> is nothrow-move-constructible), and rethrow the exception.</p>
         </ul>
       </ul>
     <tr>
      <td><code class="highlight"><span class="o">!</span><span class="kt">bool</span><span class="p">(</span><span class="n">rhs</span><span class="p">)</span></code>
      <td>
       <ul>
        <li data-md="">
         <p>if <code class="highlight"><span class="n">T</span></code> is <em>cv</em> <code class="highlight"><span class="kt">void</span></code></p>
         <ul>
          <li data-md="">
           <p>initializes <code class="highlight"><span class="n">unex</span></code> as if direct-non-list-initializing an object of type <code class="highlight"><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code> with <code class="highlight"><span class="n">unexpected</span><span class="p">(</span><span class="n">move</span><span class="p">(</span><span class="n">rhs</span><span class="p">).</span><span class="n">error</span><span class="p">())</span></code>. Either</p>
          <li data-md="">
           <p>the constructor didn’t throw, set <code class="highlight"><span class="n">has_val</span></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"><span class="n">is_nothrow_move_constructible_v</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code> is <code class="highlight">true</code></p>
         <ul>
          <li data-md="">
           <p>destroys <code class="highlight"><span class="n">val</span></code> by calling <code class="highlight"><span class="n">val</span><span class="p">.</span><span class="o">~</span><span class="n">T</span><span class="p">()</span></code>,</p>
          <li data-md="">
           <p>initializes <code class="highlight"><span class="n">unex</span></code> as if direct-non-list-initializing an object of type <code class="highlight"><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code> with <code class="highlight"><span class="n">unexpected</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">move</span><span class="p">(</span><span class="n">rhs</span><span class="p">.</span><span class="n">error</span><span class="p">()))</span></code>;</p>
         </ul>
        <li data-md="">
         <p>otherwise</p>
         <ul>
          <li data-md="">
           <p>move constructs a <code class="highlight"><span class="n">T</span> <span class="n">tmp</span></code> from <code class="highlight"><span class="o">*</span><span class="k">this</span></code> (which can’t throw as <code class="highlight"><span class="n">T</span></code> is nothrow-move-constructible),</p>
          <li data-md="">
           <p>destroys <code class="highlight"><span class="n">val</span></code> by calling <code class="highlight"><span class="n">val</span><span class="p">.</span><span class="o">~</span><span class="n">T</span><span class="p">()</span></code>,</p>
          <li data-md="">
           <p>initializes <code class="highlight"><span class="n">unex</span></code> as if direct-non-list-initializing an object of type <code class="highlight"><span class="n">unexpected_type</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code> with <code class="highlight"><span class="n">unexpected</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">move</span><span class="p">(</span><span class="n">rhs</span><span class="p">.</span><span class="n">error</span><span class="p">()))</span></code>. Either,</p>
          <li data-md="">
           <p>The constructor didn’t throw, so mark the expected as holding a <code class="highlight"><span class="n">unexpected_type</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code>, or</p>
          <li data-md="">
           <p>The constructor did throw, so move-construct the <code class="highlight"><span class="n">T</span></code> from <code class="highlight"><span class="n">tmp</span></code> back into the expected storage (which can’t throw as <code class="highlight"><span class="n">T</span></code> is nothrow-move-constructible), and rethrow the exception.</p>
         </ul>
       </ul>
      <td>move assign <code class="highlight"><span class="n">unexpected</span><span class="p">(</span><span class="n">rhs</span><span class="p">.</span><span class="n">error</span><span class="p">())</span></code> to <code class="highlight"><span class="n">unex</span></code>
   </table>
   <p><em>Returns</em>: <code class="highlight"><span class="o">*</span><span class="k">this</span></code>.</p>
   <p><em>Postconditions</em>: <code class="highlight"><span class="kt">bool</span><span class="p">(</span><span class="n">rhs</span><span class="p">)</span> <span class="o">==</span> <span class="kt">bool</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="p">)</span></code>.</p>
   <p><em>Remarks</em>: The expression inside noexcept is equivalent to: <code class="highlight"><span class="n">is_nothrow_move_assignable_v</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span></code> is <code class="highlight">true</code> and <code class="highlight"><span class="n">is_nothrow_move_constructible_v</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span></code> is <code class="highlight">true</code>.</p>
   <p>If any exception is thrown, <code class="highlight"><span class="kt">bool</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="p">)</span></code> and <code class="highlight"><span class="kt">bool</span><span class="p">(</span><span class="n">rhs</span><span class="p">)</span></code> remain
unchanged. If an exception is thrown during the call to <code class="highlight"><span class="n">T</span></code>'s copy constructor,
no effect. If an exception is thrown during the call to <code class="highlight"><span class="n">T</span></code>'s copy assignment,
the state of its contained value is as defined by the exception safety guarantee
of <code class="highlight"><span class="n">T</span></code>'s copy assignment. If an exception is thrown during the call to <code class="highlight"><span class="n">E</span></code>'s
copy assignment, the state of its contained <code class="highlight"><span class="n">unex</span></code> is as defined by
the exception safety guarantee of <code class="highlight"><span class="n">E</span></code>'s copy assignment.</p>
   <p>This operator shall be defined as deleted unless:</p>
   <ul>
    <li data-md="">
     <p><code class="highlight"><span class="n">T</span></code> is <em>cv</em> <code class="highlight"><span class="kt">void</span></code> and <code class="highlight"><span class="n">is_nothrow_move_constructible_v</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code> is <code class="highlight">true</code> and <code class="highlight"><span class="n">is_nothrow_move_assignable_v</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code> is <code class="highlight">true</code>; or</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">T</span></code> is not <em>cv</em> <code class="highlight"><span class="kt">void</span></code> and <code class="highlight"><span class="n">is_move_constructible_v</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span></code> is <code class="highlight">true</code> and <code class="highlight"><span class="n">is_move_assignable_v</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span></code> is <code class="highlight">true</code> and <code class="highlight"><span class="n">is_nothrow_move_constructible_v</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code> is <code class="highlight">true</code> and <code class="highlight"><span class="n">is_nothrow_move_assignable_v</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code> is <code class="highlight">true</code>.</p>
   </ul>
<pre class="language-c++ highlight"><span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">U</span> <span class="o">=</span> <span class="n">T</span><span class="o">></span>
    <span class="n">expected</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span> <span class="n">E</span><span class="o">>&amp;</span> <span class="n">operator</span><span class="o">=</span><span class="p">(</span><span class="n">U</span><span class="o">&amp;&amp;</span> <span class="n">v</span><span class="p">);</span>
</pre>
   <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"><span class="k">operator</span><span class="o">=</span><span class="p">(</span><span class="n">U</span><span class="o">&amp;&amp;</span><span class="p">)</span></code> effects</caption>
    <tbody>
     <tr>
      <td><code class="highlight"><span class="kt">bool</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="p">)</span></code>
      <td><code class="highlight"><span class="o">!</span><span class="kt">bool</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="p">)</span></code>
     <tr>
      <td>If <code class="highlight"><span class="kt">bool</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="p">)</span></code>, assigns <code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">forward</span><span class="o">&lt;</span><span class="n">U</span><span class="o">></span><span class="p">(</span><span class="n">v</span><span class="p">)</span></code> to <code class="highlight"><span class="n">val</span></code>
      <td>
       <p>if <code class="highlight"><span class="n">is_nothrow_constructible_v</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span> <span class="n">U</span><span class="o">></span></code> is <code class="highlight">true</code></p>
       <ul>
        <li data-md="">
         <p>destroys <code class="highlight"><span class="n">unex</span></code> by calling <code class="highlight"><span class="n">unexpect</span><span class="p">.</span><span class="o">~</span><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span><span class="p">()</span></code>,</p>
        <li data-md="">
         <p>initializes <code class="highlight"><span class="n">val</span></code> as if direct-non-list-initializing an object of type <code class="highlight"><span class="n">T</span></code> with <code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">forward</span><span class="o">&lt;</span><span class="n">U</span><span class="o">></span><span class="p">(</span><span class="n">v</span><span class="p">)</span></code> and</p>
        <li data-md="">
         <p>set <code class="highlight"><span class="n">has_val</span></code> to <code class="highlight">true</code>;</p>
       </ul>
       <p>otherwise</p>
       <ul>
        <li data-md="">
         <p>move constructs an <code class="highlight"><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span> <span class="n">tmp</span></code> from <code class="highlight"><span class="n">unexpected</span><span class="p">(</span><span class="k">this</span><span class="o">-></span><span class="n">error</span><span class="p">())</span></code> (which can’t throw as <code class="highlight"><span class="n">E</span></code> is nothrow-move-constructible),</p>
        <li data-md="">
         <p>destroys <code class="highlight"><span class="n">unex</span></code> by calling <code class="highlight"><span class="n">unexpect</span><span class="p">.</span><span class="o">~</span><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span><span class="p">()</span></code>,</p>
        <li data-md="">
         <p>initializes <code class="highlight"><span class="n">val</span></code> as if direct-non-list-initializing an object of type <code class="highlight"><span class="n">T</span></code> with <code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">forward</span><span class="o">&lt;</span><span class="n">U</span><span class="o">></span><span class="p">(</span><span class="n">v</span><span class="p">)</span></code>. Either,</p>
         <ul>
          <li data-md="">
           <p>the constructor didn’t throw, set <code class="highlight"><span class="n">has_val</span></code> to <code class="highlight">true</code>, that is set <code class="highlight"><span class="n">has_val</span></code> to <code class="highlight">true</code>, or</p>
          <li data-md="">
           <p>the constructor did throw, so move construct the <code class="highlight"><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code> from <code class="highlight"><span class="n">tmp</span></code> back into the expected storage (which can’t throw as <code class="highlight"><span class="n">E</span></code> is nothrow-move-constructible), and re-throw the exception.</p>
         </ul>
       </ul>
   </table>
   <p><em>Returns</em>: <code class="highlight"><span class="o">*</span><span class="k">this</span></code>.</p>
   <p><em>Postconditions</em>: <code class="highlight"><span class="kt">bool</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="p">)</span></code> .</p>
   <p><em>Remarks</em>: If any exception is thrown, <code class="highlight"><span class="kt">bool</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="p">)</span></code> remains
 unchanged. If an exception is thrown during the call to <code class="highlight"><span class="n">T</span></code>'s constructor, no
 effect. If an exception is thrown during the call to <code class="highlight"><span class="n">T</span></code>'s copy assignment, the
 state of its contained value is as defined by the exception safety guarantee of <code class="highlight"><span class="n">T</span></code>'s copy assignment.</p>
   <p>This function shall not participate in overload resolution unless:</p>
   <ul>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_void_v</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span></code> is <code class="highlight">false</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_same_v</span><span class="o">&lt;</span><span class="n">expected</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span><span class="n">E</span><span class="o">></span><span class="p">,</span> <span class="n">remove_cvref_t</span><span class="o">&lt;</span><span class="n">U</span><span class="o">>></span></code> is <code class="highlight">false</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">conjunction_v</span><span class="o">&lt;</span><span class="n">is_scalar</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span><span class="p">,</span> <span class="n">is_same</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span> <span class="n">decay_t</span><span class="o">&lt;</span><span class="n">U</span><span class="o">>>></span></code> is <code class="highlight">false</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_constructible_v</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span> <span class="n">U</span><span class="o">></span></code> is <code class="highlight">true</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_assignable_v</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&amp;</span><span class="p">,</span> <span class="n">U</span><span class="o">></span></code> is <code class="highlight">true</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_nothrow_move_constructible_v</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code> is <code class="highlight">true</code>.</p>
   </ul>
<pre class="language-c++ highlight"><span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">G</span> <span class="o">=</span> <span class="n">E</span><span class="o">></span>
    <span class="n">expected</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span> <span class="n">E</span><span class="o">>&amp;</span> <span class="n">operator</span><span class="o">=</span><span class="p">(</span><span class="k">const</span> <span class="n">unexpected</span><span class="o">&lt;</span><span class="n">G</span><span class="o">>&amp;</span> <span class="n">e</span><span class="p">);</span>
</pre>
   <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"><span class="k">operator</span><span class="o">=</span><span class="p">(</span><span class="k">const</span> <span class="n">unexpected</span><span class="o">&lt;</span><span class="n">G</span><span class="o">>&amp;</span><span class="p">)</span></code> effects</caption>
    <tbody>
     <tr>
      <td><code class="highlight"><span class="kt">bool</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="p">)</span></code>
      <td><code class="highlight"><span class="o">!</span><span class="kt">bool</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="p">)</span></code>
     <tr>
      <td>assigns <code class="highlight"><span class="n">unexpected</span><span class="p">(</span><span class="n">e</span><span class="p">.</span><span class="n">error</span><span class="p">())</span></code> to <code class="highlight"><span class="n">unex</span></code>
      <td>
       <ul>
        <li data-md="">
         <p>destroys <code class="highlight"><span class="n">val</span></code> by calling <code class="highlight"><span class="n">val</span><span class="p">.</span><span class="o">~</span><span class="n">T</span><span class="p">()</span></code> if <code class="highlight"><span class="n">T</span></code> is not <em>cv</em> <code class="highlight"><span class="kt">void</span></code>,</p>
        <li data-md="">
         <p>initializes <code class="highlight"><span class="n">unex</span></code> as if direct-non-list-initializing an object of type <code class="highlight"><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code> with <code class="highlight"><span class="n">unexpected</span><span class="p">(</span><span class="n">e</span><span class="p">.</span><span class="n">error</span><span class="p">())</span></code> and set <code class="highlight"><span class="n">has_val</span></code> to <code class="highlight">false</code>.</p>
       </ul>
   </table>
   <p><em>Returns</em>: <code class="highlight"><span class="o">*</span><span class="k">this</span></code>.</p>
   <p><em>Postconditions</em>: <code class="highlight"><span class="o">!</span><span class="kt">bool</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="p">)</span></code>.</p>
   <p><em>Remarks</em>: If any exception is thrown, <code class="highlight"><span class="kt">bool</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="p">)</span></code> remains unchanged.</p>
   <p>This signature shall not participate in overload resolution unless <code class="highlight"><span class="n">is_nothrow_copy_constructible_v</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code> is <code class="highlight">true</code> and <code class="highlight"><span class="n">is_copy_assignable_v</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code> is <code class="highlight">true</code>.</p>
<pre class="language-c++ highlight"><span class="n">expected</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span> <span class="n">E</span><span class="o">>&amp;</span> <span class="n">operator</span><span class="o">=</span><span class="p">(</span><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">G</span><span class="o">>&amp;&amp;</span> <span class="n">e</span><span class="p">);</span>
</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"><span class="k">operator</span><span class="o">=</span><span class="p">(</span><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">G</span><span class="o">>&amp;&amp;</span> <span class="n">e</span><span class="p">)</span></code> effects</caption>
    <tbody>
     <tr>
      <td><code class="highlight"><span class="kt">bool</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="p">)</span></code>
      <td><code class="highlight"><span class="o">!</span><span class="kt">bool</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="p">)</span></code>
     <tr>
      <td>
       <ul>
        <li data-md="">
         <p>destroys <code class="highlight"><span class="n">val</span></code> by calling <code class="highlight"><span class="n">val</span><span class="p">.</span><span class="o">~</span><span class="n">T</span><span class="p">()</span></code> if <code class="highlight"><span class="n">T</span></code> is not <em>cv</em> <code class="highlight"><span class="kt">void</span></code>,</p>
        <li data-md="">
         <p>initializes <code class="highlight"><span class="n">unex</span></code> as if direct-non-list-initializing an object of type <code class="highlight"><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code> with <code class="highlight"><span class="n">unexpected</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">move</span><span class="p">(</span><span class="n">e</span><span class="p">.</span><span class="n">error</span><span class="p">()))</span></code> and set <code class="highlight"><span class="n">has_val</span></code> to <code class="highlight">false</code>.</p>
       </ul>
      <td>move assign <code class="highlight"><span class="n">unexpected</span><span class="p">(</span><span class="n">e</span><span class="p">.</span><span class="n">error</span><span class="p">())</span></code> to <code class="highlight"><span class="n">unex</span></code>
   </table>
   <p><em>Effects</em>:</p>
   <p><em>Returns</em>: <code class="highlight"><span class="o">*</span><span class="k">this</span></code>.</p>
   <p><em>Postconditions</em>: <code class="highlight"><span class="o">!</span><span class="kt">bool</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="p">)</span></code>.</p>
   <p><em>Remarks</em>: If any exception is thrown, <code class="highlight"><span class="kt">bool</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="p">)</span></code> remains unchanged.</p>
   <p>This signature shall not participate in overload resolution unless <code class="highlight"><span class="n">is_nothrow_move_constructible_v</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code> is <code class="highlight">true</code> and <code class="highlight"><span class="n">is_move_assignable_v</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code> is <code class="highlight">true</code>.</p>
<pre class="language-c++ highlight"><span class="kt">void</span> <span class="n">expected</span><span class="o">&lt;</span><span class="kt">void</span><span class="p">,</span> <span class="n">E</span><span class="o">>::</span><span class="n">emplace</span><span class="p">();</span>
</pre>
   <p><em>Effects</em>:</p>
   <p>If <code class="highlight"><span class="o">!</span><span class="kt">bool</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="p">)</span></code></p>
   <ul>
    <li data-md="">
     <p>destroys <code class="highlight"><span class="n">unex</span></code> by calling <code class="highlight"><span class="n">unexpect</span><span class="p">.</span><span class="o">~</span><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span><span class="p">()</span></code>,</p>
    <li data-md="">
     <p>set <code class="highlight"><span class="n">has_val</span></code> to <code class="highlight">true</code></p>
   </ul>
   <p><em>Postconditions</em>: <code class="highlight"><span class="kt">bool</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="p">)</span></code> .</p>
   <p><em>Throws</em>: Nothing</p>
<pre class="language-c++ highlight"><span class="n">template</span><span class="o">&lt;</span><span class="n">class</span><span class="p">...</span> <span class="n">Args</span><span class="o">></span>
    <span class="n">T</span><span class="o">&amp;</span> <span class="n">emplace</span><span class="p">(</span><span class="n">Args</span><span class="o">&amp;&amp;</span><span class="p">...</span> <span class="n">args</span><span class="p">);</span>
</pre>
   <p><em>Effects</em>:</p>
   <p>If <code class="highlight"><span class="kt">bool</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="p">)</span></code>, assigns <code class="highlight"><span class="n">val</span></code> as if
constructing an object of type <code class="highlight"><span class="n">T</span></code> with the arguments <code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">forward</span><span class="o">&lt;</span><span class="n">Args</span><span class="o">></span><span class="p">(</span><span class="n">args</span><span class="p">)...</span></code></p>
   <p>otherwise if <code class="highlight"><span class="n">is_nothrow_constructible_v</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span> <span class="n">Args</span><span class="p">...</span><span class="o">></span></code> is <code class="highlight">true</code></p>
   <ul>
    <li data-md="">
     <p>destroys <code class="highlight"><span class="n">unex</span></code> by calling <code class="highlight"><span class="n">unexpect</span><span class="p">.</span><span class="o">~</span><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span><span class="p">()</span></code>,</p>
    <li data-md="">
     <p>initializes <code class="highlight"><span class="n">val</span></code> as if direct-non-list-initializing an object of type <code class="highlight"><span class="n">T</span></code> with <code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">forward</span><span class="o">&lt;</span><span class="n">Args</span><span class="o">></span><span class="p">(</span><span class="n">args</span><span class="p">)...</span></code> and</p>
    <li data-md="">
     <p>set <code class="highlight"><span class="n">has_val</span></code> to <code class="highlight">true</code>;</p>
   </ul>
   <p>otherwise if <code class="highlight"><span class="n">is_nothrow_move_constructible_v</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span></code> is <code class="highlight">true</code></p>
   <ul>
    <li data-md="">
     <p>constructs a <code class="highlight"><span class="n">T</span> <span class="n">tmp</span></code> from <code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">forward</span><span class="o">&lt;</span><span class="n">Args</span><span class="o">></span><span class="p">(</span><span class="n">args</span><span class="p">)...</span></code> (which can throw),</p>
    <li data-md="">
     <p>destroys <code class="highlight"><span class="n">unex</span></code> by calling <code class="highlight"><span class="n">unexpect</span><span class="p">.</span><span class="o">~</span><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span><span class="p">()</span></code>,</p>
    <li data-md="">
     <p>initializes <code class="highlight"><span class="n">val</span></code> as if direct-non-list-initializing an object of type <code class="highlight"><span class="n">T</span></code> with <code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">move</span><span class="p">(</span><span class="n">tmp</span><span class="p">)</span></code> (which cannot throw) and</p>
    <li data-md="">
     <p>set <code class="highlight"><span class="n">has_val</span></code> to <code class="highlight">true</code>;</p>
   </ul>
   <p>otherwise</p>
   <ul>
    <li data-md="">
     <p>move constructs an <code class="highlight"><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span> <span class="n">tmp</span></code> from <code class="highlight"><span class="n">unexpected</span><span class="p">(</span><span class="k">this</span><span class="o">-></span><span class="n">error</span><span class="p">())</span></code> ,</p>
    <li data-md="">
     <p>destroys <code class="highlight"><span class="n">unex</span></code> by calling <code class="highlight"><span class="n">unexpect</span><span class="p">.</span><span class="o">~</span><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span><span class="p">()</span></code>,</p>
    <li data-md="">
     <p>initializes <code class="highlight"><span class="n">val</span></code> as if direct-non-list-initializing an object of type <code class="highlight"><span class="n">T</span></code> with <code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">forward</span><span class="o">&lt;</span><span class="n">Args</span><span class="o">></span><span class="p">(</span><span class="n">args</span><span class="p">)...</span></code>. Either,</p>
     <ul>
      <li data-md="">
       <p>the constructor didn’t throw, set <code class="highlight"><span class="n">has_val</span></code> to <code class="highlight">true</code>, or</p>
      <li data-md="">
       <p>the constructor did throw, so move-construct the <code class="highlight"><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code> from <code class="highlight"><span class="n">tmp</span></code> back into the expected storage (which can’t throw as <code class="highlight"><span class="n">E</span></code> is nothrow-move-constructible), and re-throw the exception.</p>
     </ul>
   </ul>
   <p><em>Postconditions</em>: <code class="highlight"><span class="kt">bool</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="p">)</span></code> .</p>
   <p><em>Returns:</em> A reference to the new contained value <code class="highlight"><span class="n">val</span></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"><span class="n">T</span></code>'s assignment, nothing
changes.</p>
   <p>This signature shall not participate in overload resolution unless: <code class="highlight"><span class="n">T</span></code> is not <em>cv</em> <code class="highlight"><span class="kt">void</span></code> and <code class="highlight"><span class="n">is_nothrow_constructible_v</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span> <span class="n">Args</span><span class="p">...</span><span class="o">></span></code> is <code class="highlight">true</code>.</p>
<pre class="language-c++ highlight"><span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">U</span><span class="p">,</span> <span class="n">class</span><span class="p">...</span> <span class="n">Args</span><span class="o">></span>
    <span class="n">T</span><span class="o">&amp;</span> <span class="n">emplace</span><span class="p">(</span><span class="n">initializer_list</span><span class="o">&lt;</span><span class="n">U</span><span class="o">></span> <span class="n">il</span><span class="p">,</span> <span class="n">Args</span><span class="o">&amp;&amp;</span><span class="p">...</span> <span class="n">args</span><span class="p">);</span>
</pre>
   <p><em>Effects</em>:</p>
   <p>If <code class="highlight"><span class="kt">bool</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="p">)</span></code>, assigns <code class="highlight"><span class="n">val</span></code> as if
constructing an object of type <code class="highlight"><span class="n">T</span></code> with the arguments <code class="highlight"><span class="n">il</span><span class="p">,</span> <span class="n">std</span><span class="o">::</span><span class="n">forward</span><span class="o">&lt;</span><span class="n">Args</span><span class="o">></span><span class="p">(</span><span class="n">args</span><span class="p">)...</span></code></p>
   <p>otherwise if <code class="highlight"><span class="n">is_nothrow_constructible_v</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span> <span class="n">initializer_list</span><span class="o">&lt;</span><span class="n">U</span><span class="o">>&amp;</span><span class="p">,</span> <span class="n">Args</span><span class="p">...</span><span class="o">></span></code> is <code class="highlight">true</code></p>
   <ul>
    <li data-md="">
     <p>destroys <code class="highlight"><span class="n">unex</span></code> by calling <code class="highlight"><span class="n">unexpect</span><span class="p">.</span><span class="o">~</span><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span><span class="p">()</span></code>,</p>
    <li data-md="">
     <p>initializes <code class="highlight"><span class="n">val</span></code> as if direct-non-list-initializing an object of type <code class="highlight"><span class="n">T</span></code> with <code class="highlight"><span class="n">il</span><span class="p">,</span> <span class="n">std</span><span class="o">::</span><span class="n">forward</span><span class="o">&lt;</span><span class="n">Args</span><span class="o">></span><span class="p">(</span><span class="n">args</span><span class="p">)...</span></code> and</p>
    <li data-md="">
     <p>set <code class="highlight"><span class="n">has_val</span></code> to <code class="highlight">true</code>;</p>
   </ul>
   <p>otherwise if <code class="highlight"><span class="n">is_nothrow_move_constructible_v</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span></code> is <code class="highlight">true</code></p>
   <ul>
    <li data-md="">
     <p>constructs a <code class="highlight"><span class="n">T</span> <span class="n">tmp</span></code> from <code class="highlight"><span class="n">il</span><span class="p">,</span> <span class="n">std</span><span class="o">::</span><span class="n">forward</span><span class="o">&lt;</span><span class="n">Args</span><span class="o">></span><span class="p">(</span><span class="n">args</span><span class="p">)...</span></code> (which can throw),</p>
    <li data-md="">
     <p>destroys <code class="highlight"><span class="n">unex</span></code> by calling <code class="highlight"><span class="n">unexpect</span><span class="p">.</span><span class="o">~</span><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span><span class="p">()</span></code>,</p>
    <li data-md="">
     <p>initializes <code class="highlight"><span class="n">val</span></code> as if direct-non-list-initializing an object of type <code class="highlight"><span class="n">T</span></code> with <code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">move</span><span class="p">(</span><span class="n">tmp</span><span class="p">)</span></code> (which cannot throw) and</p>
    <li data-md="">
     <p>set <code class="highlight"><span class="n">has_val</span></code> to <code class="highlight">true</code>;</p>
   </ul>
   <p>otherwise</p>
   <ul>
    <li data-md="">
     <p>move constructs an <code class="highlight"><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span> <span class="n">tmp</span></code> from <code class="highlight"><span class="n">unexpected</span><span class="p">(</span><span class="k">this</span><span class="o">-></span><span class="n">error</span><span class="p">())</span></code> ,</p>
    <li data-md="">
     <p>destroys <code class="highlight"><span class="n">unex</span></code> by calling <code class="highlight"><span class="n">unexpect</span><span class="p">.</span><span class="o">~</span><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span><span class="p">()</span></code>,</p>
    <li data-md="">
     <p>initializes <code class="highlight"><span class="n">val</span></code> as if direct-non-list-initializing an object of type <code class="highlight"><span class="n">T</span></code> with <code class="highlight"><span class="n">il</span><span class="p">,</span> <span class="n">std</span><span class="o">::</span><span class="n">forward</span><span class="o">&lt;</span><span class="n">Args</span><span class="o">></span><span class="p">(</span><span class="n">args</span><span class="p">)...</span></code>. Either,</p>
     <ul>
      <li data-md="">
       <p>the constructor didn’t throw, set <code class="highlight"><span class="n">has_val</span></code> to <code class="highlight">true</code>, or</p>
      <li data-md="">
       <p>the constructor did throw, so move-construct the <code class="highlight"><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code> from <code class="highlight"><span class="n">tmp</span></code> back into the expected storage (which can’t throw as <code class="highlight"><span class="n">E</span></code> is nothrow-move-constructible), and re-throw the exception.</p>
     </ul>
   </ul>
   <p><em>Postconditions</em>: <code class="highlight"><span class="kt">bool</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="p">)</span></code> .</p>
   <p><em>Returns:</em> A reference to the new contained value <code class="highlight"><span class="n">val</span></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"><span class="n">T</span></code>'s assignment nothing
changes.</p>
   <p>The function shall not participate in overload resolution unless: <code class="highlight"><span class="n">T</span></code> is not <em>cv</em> <code class="highlight"><span class="kt">void</span></code> and <code class="highlight"><span class="n">is_nothrow_constructible_v</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span> <span class="n">initializer_list</span><span class="o">&lt;</span><span class="n">U</span><span class="o">>&amp;</span><span class="p">,</span> <span class="n">Args</span><span class="p">...</span><span class="o">></span></code> is <code class="highlight">true</code>.</p>
   <h3 class="heading settled" data-level="1.9" id="expected.object.swap"><span class="secno">1.9. </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"><span class="kt">void</span> <span class="nf">swap</span><span class="p">(</span><span class="n">expected</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span> <span class="n">E</span><span class="o">>&amp;</span> <span class="n">rhs</span><span class="p">)</span> <span class="n">noexcept</span><span class="p">(</span><span class="n">see</span> <span class="n">below</span><span class="p">);</span>
</pre>
   <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"><span class="n">swap</span><span class="p">(</span><span class="n">expected</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span> <span class="n">E</span><span class="o">>&amp;</span><span class="p">)</span></code> effects</caption>
    <tbody>
     <tr>
      <td>
      <td><code class="highlight"><span class="kt">bool</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="p">)</span></code>
      <td><code class="highlight"><span class="o">!</span><span class="kt">bool</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="p">)</span></code>
     <tr>
      <td><code class="highlight"><span class="kt">bool</span><span class="p">(</span><span class="n">rhs</span><span class="p">)</span></code>
      <td>if <code class="highlight"><span class="n">T</span></code> is not <em>cv</em> <code class="highlight"><span class="kt">void</span></code> calls <code class="highlight"><span class="k">using</span> <span class="n">std</span><span class="o">::</span><span class="n">swap</span><span class="p">;</span> <span class="n">swap</span><span class="p">(</span><span class="n">val</span><span class="p">,</span> <span class="n">rhs</span><span class="p">.</span><span class="n">val</span><span class="p">)</span></code>
      <td>calls <code class="highlight"><span class="n">rhs</span><span class="p">.</span><span class="n">swap</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="p">)</span></code>
     <tr>
      <td><code class="highlight"><span class="o">!</span><span class="kt">bool</span><span class="p">(</span><span class="n">rhs</span><span class="p">)</span></code>
      <td>
       <ul>
        <li data-md="">
         <p>if <code class="highlight"><span class="n">T</span></code> is <em>cv</em> <code class="highlight"><span class="kt">void</span></code></p>
         <ul>
          <li data-md="">
           <p>initializes <code class="highlight"><span class="n">unex</span></code> as if direct-non-list-initializing an object of type <code class="highlight"><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code> with <code class="highlight"><span class="n">unexpected</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">move</span><span class="p">(</span><span class="n">rhs</span><span class="p">))</span></code>. Either</p>
          <li data-md="">
           <p>the constructor didn’t throw, set <code class="highlight"><span class="n">has_val</span></code> to <code class="highlight">false</code>, destroys <code class="highlight"><span class="n">rhs</span><span class="p">.</span><span class="n">unexpect</span></code> by calling <code class="highlight"><span class="n">rhs</span><span class="p">.</span><span class="n">unexpect</span><span class="p">.</span><span class="o">~</span><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span><span class="p">()</span></code> set <code class="highlight"><span class="n">rhs</span><span class="p">.</span><span class="n">has_val</span></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"><span class="n">is_nothrow_move_constructible_v</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code> is <code class="highlight">true</code>,</p>
         <ul>
          <li data-md="">
           <p>the <code class="highlight"><span class="n">unex</span></code> of <code class="highlight"><span class="n">rhs</span></code> is moved to a temporary variable <code class="highlight"><span class="n">tmp</span></code> of type <code class="highlight"><span class="n">unexpected_type</span></code>,</p>
          <li data-md="">
           <p>followed by destruction of <code class="highlight"><span class="n">unex</span></code> as if by <code class="highlight"><span class="n">rhs</span><span class="p">.</span><span class="n">unexpect</span><span class="p">.</span><span class="o">~</span><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span><span class="p">()</span></code>,</p>
          <li data-md="">
           <p><code class="highlight"><span class="n">rhs</span><span class="p">.</span><span class="n">val</span></code> is direct-initialized from <code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">move</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="p">)</span></code>. Either</p>
           <ul>
            <li data-md="">
             <p>the constructor didn’t throw</p>
             <ul>
              <li data-md="">
               <p>destroy <code class="highlight"><span class="n">val</span></code> as if by <code class="highlight"><span class="k">this</span><span class="o">-></span><span class="n">val</span><span class="p">.</span><span class="o">~</span><span class="n">T</span><span class="p">()</span></code>,</p>
              <li data-md="">
               <p>the <code class="highlight"><span class="n">unex</span></code> of <code class="highlight"><span class="k">this</span></code> is direct-initialized from <code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">move</span><span class="p">(</span><span class="n">tmp</span><span class="p">)</span></code>, after this, <code class="highlight"><span class="k">this</span></code> does not contain a value; and <code class="highlight"><span class="kt">bool</span><span class="p">(</span><span class="n">rhs</span><span class="p">)</span></code>.</p>
             </ul>
            <li data-md="">
             <p>the constructor did throw, so move-construct the <code class="highlight"><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code> from <code class="highlight"><span class="n">tmp</span></code> back into the expected storage (which can’t throw as <code class="highlight"><span class="n">E</span></code> is nothrow-move-constructible), and re-throw the exception.</p>
           </ul>
         </ul>
        <li data-md="">
         <p>otherwise if <code class="highlight"><span class="n">is_nothrow_move_constructible_v</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span></code> is <code class="highlight">true</code>,</p>
         <ul>
          <li data-md="">
           <p><code class="highlight"><span class="n">val</span></code> is moved to a temporary variable <code class="highlight"><span class="n">tmp</span></code> of type <code class="highlight"><span class="n">T</span></code>,</p>
          <li data-md="">
           <p>followed by destruction of <code class="highlight"><span class="n">val</span></code> as if by <code class="highlight"><span class="n">val</span><span class="p">.</span><span class="o">~</span><span class="n">T</span><span class="p">()</span></code>,</p>
          <li data-md="">
           <p>the <code class="highlight"><span class="n">unex</span></code> is direct-initialized from <code class="highlight"><span class="n">unexpected</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">move</span><span class="p">(</span><span class="n">other</span><span class="p">.</span><span class="n">error</span><span class="p">()))</span></code>. Either</p>
           <ul>
            <li data-md="">
             <p>the constructor didn’t throw</p>
             <ul>
              <li data-md="">
               <p>destroy <code class="highlight"><span class="n">rhs</span><span class="p">.</span><span class="n">unexpect</span></code> as if by <code class="highlight"><span class="n">rhs</span><span class="p">.</span><span class="n">unexpect</span><span class="p">.</span><span class="o">~</span><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span><span class="p">()</span></code>,</p>
              <li data-md="">
               <p><code class="highlight"><span class="n">rhs</span><span class="p">.</span><span class="n">val</span></code> is direct-initialized from <code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">move</span><span class="p">(</span><span class="n">tmp</span><span class="p">)</span></code>, after this, <code class="highlight"><span class="k">this</span></code> does not contain a value; and <code class="highlight"><span class="kt">bool</span><span class="p">(</span><span class="n">rhs</span><span class="p">)</span></code>.</p>
             </ul>
            <li data-md="">
             <p>the constructor did throw, so move-construct the <code class="highlight"><span class="n">T</span></code> from <code class="highlight"><span class="n">tmp</span></code> back into the expected storage (which can’t throw as <code class="highlight"><span class="n">T</span></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"><span class="k">using</span> <span class="n">std</span><span class="o">::</span><span class="n">swap</span><span class="p">;</span> <span class="n">swap</span><span class="p">(</span><span class="n">unexpect</span><span class="p">,</span> <span class="n">rhs</span><span class="p">.</span><span class="n">unexpect</span><span class="p">)</span></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"><span class="n">is_nothrow_move_constructible_v</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span></code> is <code class="highlight">true</code> and <code class="highlight"><span class="n">is_nothrow_swappable_v</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span></code> is <code class="highlight">true</code> and <code class="highlight"><span class="n">is_nothrow_move_constructible_v</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code> is <code class="highlight">true</code> and <code class="highlight"><span class="n">is_nothrow_swappable_v</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code> is <code class="highlight">true</code>.</p>
   <p>The function shall not participate in overload resolution unless:</p>
   <ul>
    <li data-md="">
     <p>Lvalues of type <code class="highlight"><span class="n">T</span></code> are <code class="highlight"><span class="n">Swappable</span></code>; and</p>
    <li data-md="">
     <p>Lvalues of type <code class="highlight"><span class="n">E</span></code> are <code class="highlight"><span class="n">Swappable</span></code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_void_v</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span></code> is <code class="highlight">true</code> or <code class="highlight"><span class="n">is_void_v</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span></code> is <code class="highlight">false</code> and either:</p>
     <ul>
      <li data-md="">
       <p><code class="highlight"><span class="n">is_move_constructible_v</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span></code> is <code class="highlight">true</code>; or</p>
      <li data-md="">
       <p><code class="highlight"><span class="n">is_move_constructible_v</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code> is <code class="highlight">true</code>.</p>
     </ul>
   </ul>
   <h3 class="heading settled" data-level="1.10" id="expected.object.observe"><span class="secno">1.10. </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"><span class="n">constexpr</span> <span class="k">const</span> <span class="n">T</span><span class="o">*</span> <span class="n">operator</span><span class="o">-></span><span class="p">()</span> <span class="k">const</span><span class="p">;</span>
<span class="n">T</span><span class="o">*</span> <span class="n">operator</span><span class="o">-></span><span class="p">();</span>
</pre>
   <p><em>Requires</em>: <code class="highlight"><span class="kt">bool</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="p">)</span></code> .</p>
   <p><em>Returns</em>: <code class="highlight"><span class="n">addressof</span><span class="p">(</span><span class="n">val</span><span class="p">)</span></code>.</p>
   <p><em>Remarks</em>: Unless <code class="highlight"><span class="n">T</span></code> is a user-defined type with overloaded unary <code class="highlight"><span class="k">operator</span><span class="o">&amp;</span></code>,
the first operator shall be a constexpr function.
The operator shall not participate in overload resolution unless: <code class="highlight"><span class="n">T</span></code> is not <em>cv</em> <code class="highlight"><span class="kt">void</span></code>.</p>
<pre class="language-c++ highlight"><span class="n">constexpr</span> <span class="k">const</span> <span class="n">T</span><span class="o">&amp;</span> <span class="n">operator</span><span class="o">*</span><span class="p">()</span> <span class="k">const</span><span class="o">&amp;</span><span class="p">;</span>
<span class="n">T</span><span class="o">&amp;</span> <span class="n">operator</span><span class="o">*</span><span class="p">()</span> <span class="o">&amp;</span><span class="p">;</span>
</pre>
   <p><em>Requires</em>: <code class="highlight"><span class="kt">bool</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="p">)</span></code> .</p>
   <p><em>Returns</em>: <code class="highlight"><span class="n">val</span></code>.</p>
   <p><em>Remarks</em>: The first operator shall be a constexpr function.
The operator shall not participate in overload resolution unless: <code class="highlight"><span class="n">T</span></code> is not <em>cv</em> <code class="highlight"><span class="kt">void</span></code>.</p>
<pre class="language-c++ highlight"><span class="n">constexpr</span> <span class="n">T</span><span class="o">&amp;&amp;</span> <span class="n">operator</span><span class="o">*</span><span class="p">()</span> <span class="o">&amp;&amp;</span><span class="p">;</span>
<span class="n">constexpr</span> <span class="k">const</span> <span class="n">T</span><span class="o">&amp;&amp;</span> <span class="n">operator</span><span class="o">*</span><span class="p">()</span> <span class="k">const</span><span class="o">&amp;&amp;</span><span class="p">;</span>
</pre>
   <p><em>Requires</em>: <code class="highlight"><span class="kt">bool</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="p">)</span></code> .</p>
   <p><em>Returns</em>: <code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">move</span><span class="p">(</span><span class="n">val</span><span class="p">)</span></code>.</p>
   <p><em>Remarks</em>: This operator shall be a constexpr function.
The operator shall not participate in overload resolution unless: <code class="highlight"><span class="n">T</span></code> is not <em>cv</em> <code class="highlight"><span class="kt">void</span></code>.</p>
<pre class="language-c++ highlight"><span class="n">constexpr</span> <span class="n">explicit</span> <span class="n">operator</span> <span class="nf">bool</span><span class="p">()</span> <span class="n">noexcept</span><span class="p">;</span>
</pre>
   <p><em>Returns</em>: <code class="highlight"><span class="n">has_val</span></code>.</p>
   <p><em>Remarks</em>: This operator shall be a constexpr function.</p>
<pre class="language-c++ highlight"><span class="n">constexpr</span> <span class="kt">bool</span> <span class="nf">has_value</span><span class="p">()</span> <span class="k">const</span> <span class="n">noexcept</span><span class="p">;</span>
</pre>
   <p><em>Returns</em>: <code class="highlight"><span class="n">has_val</span></code>.</p>
   <p><em>Remarks</em>: This function shall be a constexpr function.</p>
<pre class="language-c++ highlight"><span class="n">constexpr</span> <span class="kt">void</span> <span class="n">expected</span><span class="o">&lt;</span><span class="kt">void</span><span class="p">,</span> <span class="n">E</span><span class="o">>::</span><span class="n">value</span><span class="p">()</span> <span class="k">const</span><span class="p">;</span>
</pre>
   <p><em>Throws</em>: <code class="highlight"><span class="n">bad_expected_access</span><span class="p">(</span><span class="n">error</span><span class="p">())</span></code> if <code class="highlight"><span class="o">!</span><span class="kt">bool</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="p">)</span></code>.</p>
<pre class="language-c++ highlight"><span class="n">constexpr</span> <span class="k">const</span> <span class="n">T</span><span class="o">&amp;</span> <span class="n">expected</span><span class="o">::</span><span class="n">value</span><span class="p">()</span> <span class="k">const</span><span class="o">&amp;</span><span class="p">;</span>
<span class="n">constexpr</span> <span class="n">T</span><span class="o">&amp;</span> <span class="n">expected</span><span class="o">::</span><span class="n">value</span><span class="p">()</span> <span class="o">&amp;</span><span class="p">;</span>
</pre>
   <p><em>Returns</em>: <code class="highlight"><span class="n">val</span></code>, if <code class="highlight"><span class="kt">bool</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="p">)</span></code> .</p>
   <p><em>Throws</em>: <code class="highlight"><span class="n">bad_expected_access</span><span class="p">(</span><span class="n">error</span><span class="p">())</span></code> if <code class="highlight"><span class="o">!</span><span class="kt">bool</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="p">)</span></code>.</p>
   <p><em>Remarks</em>: These functions shall be constexpr functions.
The operator shall not participate in overload resolution unless: <code class="highlight"><span class="n">T</span></code> is not <em>cv</em> <code class="highlight"><span class="kt">void</span></code>.</p>
<pre class="language-c++ highlight"><span class="n">constexpr</span> <span class="n">T</span><span class="o">&amp;&amp;</span> <span class="n">expected</span><span class="o">::</span><span class="n">value</span><span class="p">()</span> <span class="o">&amp;&amp;</span><span class="p">;</span>
<span class="n">constexpr</span> <span class="k">const</span> <span class="n">T</span><span class="o">&amp;&amp;</span> <span class="n">expected</span><span class="o">::</span><span class="n">value</span><span class="p">()</span> <span class="k">const</span><span class="o">&amp;&amp;</span><span class="p">;</span>
</pre>
   <p><em>Returns</em>: <code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">move</span><span class="p">(</span><span class="n">val</span><span class="p">)</span></code>, if <code class="highlight"><span class="kt">bool</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="p">)</span></code> .</p>
   <p><em>Throws</em>: <code class="highlight"><span class="n">bad_expected_access</span><span class="p">(</span><span class="n">error</span><span class="p">())</span></code> if <code class="highlight"><span class="o">!</span><span class="kt">bool</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="p">)</span></code>.</p>
   <p><em>Remarks</em>: These functions shall be constexpr functions.
The operator shall not participate in overload resolution unless: <code class="highlight"><span class="n">T</span></code> is not <em>cv</em> <code class="highlight"><span class="kt">void</span></code>.</p>
<pre class="language-c++ highlight"><span class="n">constexpr</span> <span class="k">const</span> <span class="n">E</span><span class="o">&amp;</span> <span class="n">error</span><span class="p">()</span> <span class="k">const</span><span class="o">&amp;</span><span class="p">;</span>
<span class="n">constexpr</span> <span class="n">E</span><span class="o">&amp;</span> <span class="n">error</span><span class="p">()</span> <span class="o">&amp;</span><span class="p">;</span>
</pre>
   <p><em>Requires</em>: <code class="highlight"><span class="o">!</span><span class="kt">bool</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="p">)</span></code>.</p>
   <p><em>Returns</em>: <code class="highlight"><span class="n">unexpect</span><span class="p">.</span><span class="n">value</span><span class="p">()</span></code>.</p>
   <p><em>Remarks</em>: The first function shall be a constexpr function.</p>
<pre class="language-c++ highlight"><span class="n">constexpr</span> <span class="n">E</span><span class="o">&amp;&amp;</span> <span class="n">error</span><span class="p">()</span> <span class="o">&amp;&amp;</span><span class="p">;</span>
<span class="n">constexpr</span> <span class="k">const</span> <span class="n">E</span><span class="o">&amp;&amp;</span> <span class="n">error</span><span class="p">()</span> <span class="k">const</span><span class="o">&amp;&amp;</span><span class="p">;</span>
</pre>
   <p><em>Requires</em>: <code class="highlight"><span class="o">!</span><span class="kt">bool</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="p">)</span></code>.</p>
   <p><em>Returns</em>: <code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">move</span><span class="p">(</span><span class="n">unexpect</span><span class="p">.</span><span class="n">value</span><span class="p">())</span></code>.</p>
   <p><em>Remarks</em>: The first function shall be a constexpr function.</p>
<pre class="language-c++ highlight"><span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">U</span><span class="o">></span>
    <span class="n">constexpr</span> <span class="n">T</span> <span class="n">value_or</span><span class="p">(</span><span class="n">U</span><span class="o">&amp;&amp;</span> <span class="n">v</span><span class="p">)</span> <span class="k">const</span><span class="o">&amp;</span><span class="p">;</span>
</pre>
   <p><em>Returns</em>: <code class="highlight"><span class="kt">bool</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="p">)</span> <span class="o">?</span> <span class="o">**</span><span class="k">this</span> <span class="o">:</span> <span class="k">static_cast</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">forward</span><span class="o">&lt;</span><span class="n">U</span><span class="o">></span><span class="p">(</span><span class="n">v</span><span class="p">));</span></code>.</p>
   <p><em>Remarks</em>: If <code class="highlight"><span class="n">is_copy_constructible_v</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span></code> is <code class="highlight">true</code>and <code class="highlight"><span class="n">is_convertible_v</span><span class="o">&lt;</span><span class="n">U</span><span class="p">,</span> <span class="n">T</span><span class="o">></span></code> is <code class="highlight">false</code> the program is ill-formed.</p>
<pre class="language-c++ highlight"><span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">U</span><span class="o">></span>
    <span class="n">constexpr</span> <span class="n">T</span> <span class="n">value_or</span><span class="p">(</span><span class="n">U</span><span class="o">&amp;&amp;</span> <span class="n">v</span><span class="p">)</span> <span class="o">&amp;&amp;</span><span class="p">;</span>
</pre>
   <p><em>Returns</em>: <code class="highlight"><span class="kt">bool</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="p">)</span> <span class="o">?</span> <span class="n">std</span><span class="o">::</span><span class="n">move</span><span class="p">(</span><span class="o">**</span><span class="k">this</span><span class="p">)</span> <span class="o">:</span> <span class="k">static_cast</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">forward</span><span class="o">&lt;</span><span class="n">U</span><span class="o">></span><span class="p">(</span><span class="n">v</span><span class="p">));</span></code>.</p>
   <p><em>Remarks</em>: If <code class="highlight"><span class="n">is_move_constructible_v</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span></code> is <code class="highlight">true</code> and <code class="highlight"><span class="n">is_convertible_v</span><span class="o">&lt;</span><span class="n">U</span><span class="p">,</span> <span class="n">T</span><span class="o">></span></code> is <code class="highlight">false</code> the program is ill-formed.</p>
   <h3 class="heading settled" data-level="1.11" id="expected.equality_op"><span class="secno">1.11. </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"><span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">T1</span><span class="p">,</span> <span class="n">class</span> <span class="n">E1</span><span class="p">,</span> <span class="n">class</span> <span class="n">T2</span><span class="p">,</span> <span class="n">class</span> <span class="n">E2</span><span class="o">></span>
    <span class="n">friend</span> <span class="n">constexpr</span> <span class="kt">bool</span> <span class="n">operator</span><span class="o">==</span><span class="p">(</span><span class="k">const</span> <span class="n">expected</span><span class="o">&lt;</span><span class="n">T1</span><span class="p">,</span> <span class="n">E1</span><span class="o">>&amp;</span> <span class="n">x</span><span class="p">,</span> <span class="k">const</span> <span class="n">expected</span><span class="o">&lt;</span><span class="n">T2</span><span class="p">,</span> <span class="n">E2</span><span class="o">>&amp;</span> <span class="n">y</span><span class="p">);</span>
</pre>
   <p><em>Requires</em>: The expressions <code class="highlight"><span class="o">*</span><span class="n">x</span> <span class="o">==</span> <span class="o">*</span><span class="n">y</span></code> and <code class="highlight"><span class="n">unexpected</span><span class="p">(</span><span class="n">x</span><span class="p">.</span><span class="n">error</span><span class="p">())</span> <span class="o">==</span> <span class="n">unexpected</span><span class="p">(</span><span class="n">y</span><span class="p">.</span><span class="n">error</span><span class="p">())</span></code> shall be well-formed and its result
shall be convertible to <code class="highlight"><span class="kt">bool</span></code>.</p>
   <p><em>Returns</em>: If <code class="highlight"><span class="kt">bool</span><span class="p">(</span><span class="n">x</span><span class="p">)</span> <span class="o">!=</span> <span class="kt">bool</span><span class="p">(</span><span class="n">y</span><span class="p">)</span></code>, <code class="highlight">false</code>; otherwise if <code class="highlight"><span class="kt">bool</span><span class="p">(</span><span class="n">x</span><span class="p">)</span> <span class="o">==</span> false</code>, <code class="highlight"><span class="n">x</span><span class="p">.</span><span class="n">error</span><span class="p">()</span> <span class="o">==</span> <span class="n">y</span><span class="p">.</span><span class="n">error</span><span class="p">()</span></code>; otherwise <code class="highlight">true</code> if <code class="highlight"><span class="n">T1</span></code> and <code class="highlight"><span class="n">T2</span></code> are <em>cv</em> <code class="highlight"><span class="kt">void</span></code> or <code class="highlight"><span class="o">*</span><span class="n">x</span> <span class="o">==</span> <span class="o">*</span><span class="n">y</span></code> otherwise.</p>
   <p><em>Remarks</em>: Specializations of this function template, for which <code class="highlight"><span class="n">T1</span></code> and <code class="highlight"><span class="n">T2</span></code> are <em>cv</em> <code class="highlight"><span class="kt">void</span></code> or <code class="highlight"><span class="o">*</span><span class="n">x</span> <span class="o">==</span> <span class="o">*</span><span class="n">y</span></code> and <code class="highlight"><span class="n">x</span><span class="p">.</span><span class="n">error</span><span class="p">()</span> <span class="o">==</span> <span class="n">y</span><span class="p">.</span><span class="n">error</span><span class="p">()</span></code> are core constant expression, shall be <code class="highlight"><span class="k">constexpr</span></code> functions.</p>
<pre class="language-c++ highlight"><span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">T1</span><span class="p">,</span> <span class="n">class</span> <span class="n">E1</span><span class="p">,</span> <span class="n">class</span> <span class="n">T2</span><span class="p">,</span> <span class="n">class</span> <span class="n">E2</span><span class="o">></span>
    <span class="n">constexpr</span> <span class="kt">bool</span> <span class="n">operator</span><span class="o">!=</span><span class="p">(</span><span class="k">const</span> <span class="n">expected</span><span class="o">&lt;</span><span class="n">T1</span><span class="p">,</span> <span class="n">E1</span><span class="o">>&amp;</span> <span class="n">x</span><span class="p">,</span> <span class="k">const</span> <span class="n">expected</span><span class="o">&lt;</span><span class="n">T2</span><span class="p">,</span> <span class="n">E2</span><span class="o">>&amp;</span> <span class="n">y</span><span class="p">);</span>
</pre>
   <p><em>Requires</em>: The expressions <code class="highlight"><span class="o">*</span><span class="n">x</span> <span class="o">!=</span> <span class="o">*</span><span class="n">y</span></code> and <code class="highlight"><span class="n">x</span><span class="p">.</span><span class="n">error</span><span class="p">()</span> <span class="o">!=</span> <span class="n">y</span><span class="p">.</span><span class="n">error</span><span class="p">()</span></code> shall be
well-formed and its result shall be convertible to <code class="highlight"><span class="kt">bool</span></code>.</p>
   <p><em>Returns</em>: If <code class="highlight"><span class="kt">bool</span><span class="p">(</span><span class="n">x</span><span class="p">)</span> <span class="o">!=</span> <span class="kt">bool</span><span class="p">(</span><span class="n">y</span><span class="p">)</span></code>, <code class="highlight">true</code>; otherwise if <code class="highlight"><span class="kt">bool</span><span class="p">(</span><span class="n">x</span><span class="p">)</span> <span class="o">==</span> false</code>, <code class="highlight"><span class="n">x</span><span class="p">.</span><span class="n">error</span><span class="p">()</span> <span class="o">!=</span> <span class="n">y</span><span class="p">.</span><span class="n">error</span><span class="p">()</span></code>; otherwise <code class="highlight">true</code> if <code class="highlight"><span class="n">T1</span></code> and <code class="highlight"><span class="n">T2</span></code> are <em>cv</em> <code class="highlight"><span class="kt">void</span></code> or <code class="highlight"><span class="o">*</span><span class="n">x</span> <span class="o">!=</span> <span class="o">*</span><span class="n">y</span></code>.</p>
   <p><em>Remarks</em>: Specializations of this function template, for which <code class="highlight"><span class="n">T1</span></code> and <code class="highlight"><span class="n">T2</span></code> are <em>cv</em> <code class="highlight"><span class="kt">void</span></code> or <code class="highlight"><span class="o">*</span><span class="n">x</span> <span class="o">!=</span> <span class="o">*</span><span class="n">y</span></code> and <code class="highlight"><span class="n">x</span><span class="p">.</span><span class="n">error</span><span class="p">()</span> <span class="o">!=</span> <span class="n">y</span><span class="p">.</span><span class="n">error</span><span class="p">()</span></code> are core
constant expression, shall be constexpr functions.</p>
   <h3 class="heading settled" data-level="1.12" id="expected.comparison_T"><span class="secno">1.12. </span><span class="content">�.�.4.7 Comparison with <code class="highlight"><span class="n">T</span></code> [<em>expected.comparison_T</em>]</span><a class="self-link" href="#expected.comparison_T"></a></h3>
<pre class="language-c++ highlight"><span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">T1</span><span class="p">,</span> <span class="n">class</span> <span class="n">E1</span><span class="p">,</span> <span class="n">class</span> <span class="n">T2</span><span class="o">></span> <span class="n">constexpr</span> <span class="kt">bool</span> <span class="n">operator</span><span class="o">==</span><span class="p">(</span><span class="k">const</span> <span class="n">expected</span><span class="o">&lt;</span><span class="n">T1</span><span class="p">,</span> <span class="n">E1</span><span class="o">>&amp;</span> <span class="n">x</span><span class="p">,</span> <span class="k">const</span> <span class="n">T2</span><span class="o">&amp;</span> <span class="n">v</span><span class="p">);</span>
<span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">T1</span><span class="p">,</span> <span class="n">class</span> <span class="n">E1</span><span class="p">,</span> <span class="n">class</span> <span class="n">T2</span><span class="o">></span> <span class="n">constexpr</span> <span class="kt">bool</span> <span class="n">operator</span><span class="o">==</span><span class="p">(</span><span class="k">const</span> <span class="n">T2</span><span class="o">&amp;</span> <span class="n">v</span><span class="p">,</span> <span class="k">const</span> <span class="n">expected</span><span class="o">&lt;</span><span class="n">T1</span><span class="p">,</span> <span class="n">E1</span><span class="o">>&amp;</span> <span class="n">x</span><span class="p">);</span>
</pre>
   <p><em>Requires</em>: <code class="highlight"><span class="n">T1</span></code> and <code class="highlight"><span class="n">T2</span></code> are not <em>cv</em> <code class="highlight"><span class="kt">void</span></code> and the expression <code class="highlight"><span class="o">*</span><span class="n">x</span> <span class="o">==</span> <span class="n">v</span></code> shall be well-formed
and its result shall be convertible to <code class="highlight"><span class="kt">bool</span></code>. [ <em>Note:</em> <code class="highlight"><span class="n">T1</span></code> need not be <em>EqualityComparable</em>. - <em>end note</em>]</p>
   <p><em>Returns</em>: <code class="highlight"><span class="kt">bool</span><span class="p">(</span><span class="n">x</span><span class="p">)</span> <span class="o">?</span> <span class="o">*</span><span class="n">x</span> <span class="o">==</span> <span class="nl">v</span> <span class="p">:</span> false<span class="p">;</span></code>.</p>
<pre class="language-c++ highlight"><span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">T1</span><span class="p">,</span> <span class="n">class</span> <span class="n">E1</span><span class="p">,</span> <span class="n">class</span> <span class="n">T2</span><span class="o">></span> <span class="n">constexpr</span> <span class="kt">bool</span> <span class="n">operator</span><span class="o">!=</span><span class="p">(</span><span class="k">const</span> <span class="n">expected</span><span class="o">&lt;</span><span class="n">T1</span><span class="p">,</span> <span class="n">E1</span><span class="o">>&amp;</span> <span class="n">x</span><span class="p">,</span> <span class="k">const</span> <span class="n">T2</span><span class="o">&amp;</span> <span class="n">v</span><span class="p">);</span>
<span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">T1</span><span class="p">,</span> <span class="n">class</span> <span class="n">E1</span><span class="p">,</span> <span class="n">class</span> <span class="n">T2</span><span class="o">></span> <span class="n">constexpr</span> <span class="kt">bool</span> <span class="n">operator</span><span class="o">!=</span><span class="p">(</span><span class="k">const</span> <span class="n">T2</span><span class="o">&amp;</span> <span class="n">v</span><span class="p">,</span> <span class="k">const</span> <span class="n">expected</span><span class="o">&lt;</span><span class="n">T1</span><span class="p">,</span> <span class="n">E1</span><span class="o">>&amp;</span> <span class="n">x</span><span class="p">);</span>
</pre>
   <p><em>Requires</em>: <code class="highlight"><span class="n">T1</span></code> and <code class="highlight"><span class="n">T2</span></code> are not <em>cv</em> <code class="highlight"><span class="kt">void</span></code> and the expression <code class="highlight"><span class="o">*</span><span class="n">x</span> <span class="o">==</span> <span class="n">v</span></code> shall be well-formed
and its result shall be convertible to <code class="highlight"><span class="kt">bool</span></code>. [ <em>Note:</em> <code class="highlight"><span class="n">T1</span></code> need not be <em>EqualityComparable</em>. - <em>end note</em>]</p>
   <p><em>Returns</em>: <code class="highlight"><span class="kt">bool</span><span class="p">(</span><span class="n">x</span><span class="p">)</span> <span class="o">?</span> <span class="o">*</span><span class="n">x</span> <span class="o">!=</span> <span class="nl">v</span> <span class="p">:</span> false<span class="p">;</span></code>.</p>
   <h3 class="heading settled" data-level="1.13" id="expected.comparison_unexpected_E"><span class="secno">1.13. </span><span class="content">�.�.4.8 Comparison with <code class="highlight"><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code> [<em>expected.comparison_unexpected_E</em>]</span><a class="self-link" href="#expected.comparison_unexpected_E"></a></h3>
<pre class="language-c++ highlight"><span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">T1</span><span class="p">,</span> <span class="n">class</span> <span class="n">E1</span><span class="p">,</span> <span class="n">class</span> <span class="n">E2</span><span class="o">></span> <span class="n">constexpr</span> <span class="kt">bool</span> <span class="n">operator</span><span class="o">==</span><span class="p">(</span><span class="k">const</span> <span class="n">expected</span><span class="o">&lt;</span><span class="n">T1</span><span class="p">,</span> <span class="n">E1</span><span class="o">>&amp;</span> <span class="n">x</span><span class="p">,</span> <span class="k">const</span> <span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E2</span><span class="o">>&amp;</span> <span class="n">e</span><span class="p">);</span>
<span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">T1</span><span class="p">,</span> <span class="n">class</span> <span class="n">E1</span><span class="p">,</span> <span class="n">class</span> <span class="n">E2</span><span class="o">></span> <span class="n">constexpr</span> <span class="kt">bool</span> <span class="n">operator</span><span class="o">==</span><span class="p">(</span><span class="k">const</span> <span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E2</span><span class="o">>&amp;</span> <span class="n">e</span><span class="p">,</span> <span class="k">const</span> <span class="n">expected</span><span class="o">&lt;</span><span class="n">T1</span><span class="p">,</span> <span class="n">E1</span><span class="o">>&amp;</span> <span class="n">x</span><span class="p">);</span>
</pre>
   <p><em>Requires</em>: The expression <code class="highlight"><span class="n">unexpected</span><span class="p">(</span><span class="n">x</span><span class="p">.</span><span class="n">error</span><span class="p">())</span> <span class="o">==</span> <span class="n">e</span></code> shall be well-formed and
its result shall be convertible to <code class="highlight"><span class="kt">bool</span></code>.</p>
   <p><em>Returns</em>: <code class="highlight"><span class="kt">bool</span><span class="p">(</span><span class="n">x</span><span class="p">)</span> <span class="o">?</span> false <span class="o">:</span> <span class="n">unexpected</span><span class="p">(</span><span class="n">x</span><span class="p">.</span><span class="n">error</span><span class="p">())</span> <span class="o">==</span> <span class="n">e</span><span class="p">;</span></code>.</p>
<pre class="language-c++ highlight"><span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">T1</span><span class="p">,</span> <span class="n">class</span> <span class="n">E1</span><span class="p">,</span> <span class="n">class</span> <span class="n">E2</span><span class="o">></span> <span class="n">constexpr</span> <span class="kt">bool</span> <span class="n">operator</span><span class="o">!=</span><span class="p">(</span><span class="k">const</span> <span class="n">expected</span><span class="o">&lt;</span><span class="n">T1</span><span class="p">,</span> <span class="n">E1</span><span class="o">>&amp;</span> <span class="n">x</span><span class="p">,</span> <span class="k">const</span> <span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E2</span><span class="o">>&amp;</span> <span class="n">e</span><span class="p">);</span>
<span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">T1</span><span class="p">,</span> <span class="n">class</span> <span class="n">E1</span><span class="p">,</span> <span class="n">class</span> <span class="n">E2</span><span class="o">></span> <span class="n">constexpr</span> <span class="kt">bool</span> <span class="n">operator</span><span class="o">!=</span><span class="p">(</span><span class="k">const</span> <span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E2</span><span class="o">>&amp;</span> <span class="n">e</span><span class="p">,</span> <span class="k">const</span> <span class="n">expected</span><span class="o">&lt;</span><span class="n">T1</span><span class="p">,</span> <span class="n">E1</span><span class="o">>&amp;</span> <span class="n">x</span><span class="p">);</span>
</pre>
   <p><em>Requires</em>: The expression <code class="highlight"><span class="n">unexpected</span><span class="p">(</span><span class="n">x</span><span class="p">.</span><span class="n">error</span><span class="p">())</span> <span class="o">!=</span> <span class="n">e</span></code> shall be well-formed and
its result shall be convertible to <code class="highlight"><span class="kt">bool</span></code>. <em>Returns</em>: <code class="highlight"><span class="kt">bool</span><span class="p">(</span><span class="n">x</span><span class="p">)</span> <span class="o">?</span> true <span class="o">:</span> <span class="n">unexpected</span><span class="p">(</span><span class="n">x</span><span class="p">.</span><span class="n">error</span><span class="p">())</span> <span class="o">!=</span> <span class="n">e</span><span class="p">;</span></code>.</p>
   <h3 class="heading settled" data-level="1.14" id="expected.specalg"><span class="secno">1.14. </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"><span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">T1</span><span class="p">,</span> <span class="n">class</span> <span class="n">E1</span><span class="o">></span>
<span class="kt">void</span> <span class="n">swap</span><span class="p">(</span><span class="n">expected</span><span class="o">&lt;</span><span class="n">T1</span><span class="p">,</span> <span class="n">E1</span><span class="o">>&amp;</span> <span class="n">x</span><span class="p">,</span> <span class="n">expected</span><span class="o">&lt;</span><span class="n">T1</span><span class="p">,</span> <span class="n">E1</span><span class="o">>&amp;</span> <span class="n">y</span><span class="p">)</span> <span class="n">noexcept</span><span class="p">(</span><span class="n">noexcept</span><span class="p">(</span><span class="n">x</span><span class="p">.</span><span class="n">swap</span><span class="p">(</span><span class="n">y</span><span class="p">)));</span>
</pre>
   <p><em>Effects</em>: Calls <code class="highlight"><span class="n">x</span><span class="p">.</span><span class="n">swap</span><span class="p">(</span><span class="n">y</span><span class="p">)</span></code>.</p>
   <p><em>Remarks</em>: This function shall not participate in overload resolution unless:</p>
   <ul>
    <li data-md="">
     <p><code class="highlight"><span class="n">T1</span></code> is <em>cv</em> <code class="highlight"><span class="kt">void</span></code> or <code class="highlight"><span class="n">is_move_constructible_v</span><span class="o">&lt;</span><span class="n">T1</span><span class="o">></span></code> is <code class="highlight">true</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_swappable_v</span><span class="o">&lt;</span><span class="n">T1</span><span class="o">></span></code> is <code class="highlight">true</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_move_constructible_v</span><span class="o">&lt;</span><span class="n">E1</span><span class="o">></span></code> is <code class="highlight">true</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_swappable_v</span><span class="o">&lt;</span><span class="n">E1</span><span class="o">></span></code> is <code class="highlight">true</code>.</p>
   </ul>
   <h3 class="heading settled" data-level="1.15" id="expected.unexpected"><span class="secno">1.15. </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="1.16" id="expected.unexpected.general"><span class="secno">1.16. </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"><span class="n">unexpected</span></code> that
represents unexpected objects.</p>
   <h3 class="heading settled" data-level="1.17" id="expected.unexpected.object"><span class="secno">1.17. </span><span class="content">�.�.5.2 Class template <code class="highlight"><span class="n">unexpected</span></code> [<em>expected.unexpected.object</em>]</span><a class="self-link" href="#expected.unexpected.object"></a></h3>
<pre class="language-c++ highlight"><span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">E</span><span class="o">></span>
<span class="n">class</span> <span class="n">unexpected</span> <span class="p">{</span>
<span class="nl">public</span><span class="p">:</span>
    <span class="n">constexpr</span> <span class="n">unexpected</span><span class="p">(</span><span class="k">const</span> <span class="n">unexpected</span><span class="o">&amp;</span><span class="p">)</span> <span class="o">=</span> <span class="k">default</span><span class="p">;</span>
    <span class="n">constexpr</span> <span class="nf">unexpected</span><span class="p">(</span><span class="n">unexpected</span><span class="o">&amp;&amp;</span><span class="p">)</span> <span class="o">=</span> <span class="k">default</span><span class="p">;</span>
    <span class="n">template</span><span class="o">&lt;</span><span class="n">class</span><span class="p">...</span> <span class="n">Args</span><span class="o">></span>
        <span class="n">constexpr</span> <span class="n">explicit</span> <span class="n">unexpected</span><span class="p">(</span><span class="n">in_place_t</span><span class="p">,</span> <span class="n">Args</span><span class="o">&amp;&amp;</span><span class="p">...);</span>
    <span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">U</span><span class="p">,</span> <span class="n">class</span><span class="p">...</span> <span class="n">Args</span><span class="o">></span>
        <span class="n">constexpr</span> <span class="n">explicit</span> <span class="n">unexpected</span><span class="p">(</span><span class="n">in_place_t</span><span class="p">,</span> <span class="n">initializer_list</span><span class="o">&lt;</span><span class="n">U</span><span class="o">></span><span class="p">,</span> <span class="n">Args</span><span class="o">&amp;&amp;</span><span class="p">...);</span>
    <span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">Err</span> <span class="o">=</span> <span class="n">E</span><span class="o">></span>
        <span class="n">constexpr</span> <span class="n">explicit</span> <span class="n">unexpected</span><span class="p">(</span><span class="n">Err</span><span class="o">&amp;&amp;</span><span class="p">);</span>
    <span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">Err</span><span class="o">></span>
        <span class="n">constexpr</span> <span class="n">EXPLICIT</span> <span class="n">unexpected</span><span class="p">(</span><span class="k">const</span> <span class="n">unexpected</span><span class="o">&lt;</span><span class="n">Err</span><span class="o">>&amp;</span><span class="p">);</span>
    <span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">Err</span><span class="o">></span>
        <span class="n">constexpr</span> <span class="n">EXPLICIT</span> <span class="n">unexpected</span><span class="p">(</span><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">Err</span><span class="o">>&amp;&amp;</span><span class="p">);</span>

    <span class="n">constexpr</span> <span class="n">unexpected</span><span class="o">&amp;</span> <span class="n">operator</span><span class="o">=</span><span class="p">(</span><span class="k">const</span> <span class="n">unexpected</span><span class="o">&amp;</span><span class="p">)</span> <span class="o">=</span> <span class="k">default</span><span class="p">;</span>
    <span class="n">constexpr</span> <span class="n">unexpected</span><span class="o">&amp;</span> <span class="n">operator</span><span class="o">=</span><span class="p">(</span><span class="n">unexpected</span><span class="o">&amp;&amp;</span><span class="p">)</span> <span class="o">=</span> <span class="k">default</span><span class="p">;</span>
    <span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">Err</span> <span class="o">=</span> <span class="n">E</span><span class="o">></span>
    <span class="n">constexpr</span> <span class="n">unexpected</span><span class="o">&amp;</span> <span class="n">operator</span><span class="o">=</span><span class="p">(</span><span class="k">const</span> <span class="n">unexpected</span><span class="o">&lt;</span><span class="n">Err</span><span class="o">>&amp;</span><span class="p">);</span>
    <span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">Err</span> <span class="o">=</span> <span class="n">E</span><span class="o">></span>
    <span class="n">constexpr</span> <span class="n">unexpected</span><span class="o">&amp;</span> <span class="n">operator</span><span class="o">=</span><span class="p">(</span><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">Err</span><span class="o">>&amp;&amp;</span><span class="p">);</span>

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

    <span class="kt">void</span> <span class="nf">swap</span><span class="p">(</span><span class="n">unexpected</span><span class="o">&amp;</span> <span class="n">other</span><span class="p">)</span> <span class="n">noexcept</span><span class="p">(</span><span class="n">see</span> <span class="n">bellow</span><span class="p">);</span>

    <span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">E1</span><span class="p">,</span> <span class="n">class</span> <span class="n">E2</span><span class="o">></span>
        <span class="n">friend</span> <span class="n">constexpr</span> <span class="kt">bool</span>
        <span class="n">operator</span><span class="o">==</span><span class="p">(</span><span class="k">const</span> <span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E1</span><span class="o">>&amp;</span><span class="p">,</span> <span class="k">const</span> <span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E2</span><span class="o">>&amp;</span><span class="p">);</span>
    <span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">E1</span><span class="p">,</span> <span class="n">class</span> <span class="n">E2</span><span class="o">></span>
        <span class="n">constexpr</span> <span class="kt">bool</span>
        <span class="n">operator</span><span class="o">!=</span><span class="p">(</span><span class="k">const</span> <span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E1</span><span class="o">>&amp;</span><span class="p">,</span> <span class="k">const</span> <span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E2</span><span class="o">>&amp;</span><span class="p">);</span>

    <span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">E1</span><span class="o">></span>
    <span class="n">friend</span> <span class="kt">void</span> <span class="n">swap</span><span class="p">(</span><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E1</span><span class="o">>&amp;</span> <span class="n">x</span><span class="p">,</span> <span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E1</span><span class="o">>&amp;</span> <span class="n">y</span><span class="p">)</span> <span class="n">noexcept</span><span class="p">(</span><span class="n">noexcept</span><span class="p">(</span><span class="n">x</span><span class="p">.</span><span class="n">swap</span><span class="p">(</span><span class="n">y</span><span class="p">)));</span>


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

<span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">E</span><span class="o">></span> <span class="n">unexpected</span><span class="p">(</span><span class="n">E</span><span class="p">)</span> <span class="o">-></span> <span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span><span class="p">;</span>
</pre>
   <p>A program that instantiates the definition of <code class="highlight"><span class="n">unexpected</span></code> for a non-object
type, an array type, a specialization of <code class="highlight"><span class="n">unexpected</span></code> or an cv-qualified type is
ill-formed.</p>
   <p>�.�.5.2.1 Constructors [<em>expected.unexpected.ctor</em>] {#expected.unexpected.ctor}</p>
<pre class="language-c++ highlight"><span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">Err</span><span class="o">></span>
    <span class="n">constexpr</span> <span class="n">explicit</span> <span class="n">unexpected</span><span class="p">(</span><span class="n">Err</span><span class="o">&amp;&amp;</span> <span class="n">e</span><span class="p">);</span>
</pre>
   <p><em>Effects</em>: Initializes <code class="highlight"><span class="n">val</span></code> as if direct-non-list-initializing an
object of type <code class="highlight"><span class="n">E</span></code> with the expression <code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">forward</span><span class="o">&lt;</span><span class="n">Err</span><span class="o">></span><span class="p">(</span><span class="n">e</span><span class="p">)</span></code>.</p>
   <p><em>Throws</em>: Any exception thrown by the selected constructor of <code class="highlight"><span class="n">E</span></code>.</p>
   <p><em>Remarks</em>: If E’s selected constructor is a constant subexpression, this
constructor shall be a constexpr constructor. This constructor shall not
participate in overload resolution unless:</p>
   <ul>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_constructible_v</span><span class="o">&lt;</span><span class="n">E</span><span class="p">,</span> <span class="n">Err</span><span class="o">></span></code> is <code class="highlight">true</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_same_v</span><span class="o">&lt;</span><span class="n">remove_cvref_t</span><span class="o">&lt;</span><span class="n">U</span><span class="o">></span><span class="p">,</span> <span class="n">in_place_t</span><span class="o">></span></code> is <code class="highlight">false</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_same_v</span><span class="o">&lt;</span><span class="n">remove_cvref_t</span><span class="o">&lt;</span><span class="n">U</span><span class="o">></span><span class="p">,</span> <span class="n">unexpected</span><span class="o">></span></code> is <code class="highlight">false</code>.</p>
   </ul>
<pre class="language-c++ highlight"><span class="n">template</span><span class="o">&lt;</span><span class="n">class</span><span class="p">...</span> <span class="n">Args</span><span class="o">></span>
    <span class="n">constexpr</span> <span class="n">explicit</span> <span class="n">unexpected</span><span class="p">(</span><span class="n">in_place_t</span><span class="p">,</span> <span class="n">Args</span><span class="o">&amp;&amp;</span><span class="p">...);</span>
</pre>
   <p><em>Effects</em>: Initializes <code class="highlight"><span class="n">val</span></code> as if direct-non-list-initializing an
object of type <code class="highlight"><span class="n">E</span></code> with the arguments <code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">forward</span><span class="o">&lt;</span><span class="n">Args</span><span class="o">></span><span class="p">(</span><span class="n">args</span><span class="p">)...</span></code>.</p>
   <p><em>Throws</em>: Any exception thrown by the selected constructor of <code class="highlight"><span class="n">E</span></code>.</p>
   <p><em>Remarks</em>:
If E’s selected constructor is a constant subexpression, this constructor shall be a constexpr constructor.
This constructor shall not participate in overload resolution unless <code class="highlight"><span class="n">is_constructible_v</span><span class="o">&lt;</span><span class="n">E</span><span class="p">,</span> <span class="n">Args</span><span class="p">...</span><span class="o">></span></code> is <code class="highlight">true</code>.</p>
<pre class="language-c++ highlight"><span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">U</span><span class="p">,</span> <span class="n">class</span><span class="p">...</span> <span class="n">Args</span><span class="o">></span>
    <span class="n">constexpr</span> <span class="n">explicit</span> <span class="n">unexpected</span><span class="p">(</span><span class="n">in_place_t</span><span class="p">,</span> <span class="n">initializer_list</span><span class="o">&lt;</span><span class="n">U</span><span class="o">></span><span class="p">,</span> <span class="n">Args</span><span class="o">&amp;&amp;</span><span class="p">...);</span>
</pre>
   <p><em>Effects</em>: Initializes <code class="highlight"><span class="n">val</span></code> as if direct-non-list-initializing an
object of type <code class="highlight"><span class="n">E</span></code> with the arguments <code class="highlight"><span class="n">il</span><span class="p">,</span> <span class="n">std</span><span class="o">::</span><span class="n">forward</span><span class="o">&lt;</span><span class="n">Args</span><span class="o">></span><span class="p">(</span><span class="n">args</span><span class="p">)...</span></code>.</p>
   <p><em>Throws</em>: Any exception thrown by the selected constructor of <code class="highlight"><span class="n">E</span></code>.</p>
   <p><em>Remarks</em>:
If E’s selected constructor is a constant subexpression, this constructor shall be a constexpr constructor.
This constructor shall not participate in overload resolution unless <code class="highlight"><span class="n">is_constructible_v</span><span class="o">&lt;</span><span class="n">E</span><span class="p">,</span> <span class="n">initializer_list</span><span class="o">&lt;</span><span class="n">U</span><span class="o">>&amp;</span><span class="p">,</span> <span class="n">Args</span><span class="p">...</span><span class="o">></span></code> is <code class="highlight">true</code>.</p>
<pre class="language-c++ highlight"><span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">Err</span><span class="o">></span>
<span class="n">constexpr</span> <span class="n">EXPLICIT</span> <span class="n">unexpected</span><span class="p">(</span><span class="k">const</span> <span class="n">unexpected</span><span class="o">&lt;</span><span class="n">Err</span><span class="o">>&amp;</span> <span class="n">e</span><span class="p">);</span>
</pre>
   <p><em>Effects</em>: Initializes <code class="highlight"><span class="n">val</span></code> as if direct-non-list-initializing an
object of type <code class="highlight"><span class="n">E</span></code> with the expression <code class="highlight"><span class="n">e</span><span class="p">.</span><span class="n">val</span></code>.</p>
   <p><em>Throws</em>: Any exception thrown by the selected constructor of <code class="highlight"><span class="n">E</span></code>.</p>
   <p><em>Remarks</em>: This constructor participates in overload resolution unless:</p>
   <ul>
    <li data-md="">
     <p><code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">is_constructible_v</span><span class="o">&lt;</span><span class="n">E</span><span class="p">,</span> <span class="n">Err</span><span class="o">></span></code> is <code class="highlight">true</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_constructible_v</span><span class="o">&lt;</span><span class="n">E</span><span class="p">,</span> <span class="n">unexpected</span><span class="o">&lt;</span><span class="n">Err</span><span class="o">>&amp;></span></code> is <code class="highlight">false</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_constructible_v</span><span class="o">&lt;</span><span class="n">E</span><span class="p">,</span> <span class="n">unexpected</span><span class="o">&lt;</span><span class="n">Err</span><span class="o">>></span></code> is <code class="highlight">false</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_constructible_v</span><span class="o">&lt;</span><span class="n">E</span><span class="p">,</span> <span class="k">const</span> <span class="n">unexpected</span><span class="o">&lt;</span><span class="n">Err</span><span class="o">>&amp;></span></code> is <code class="highlight">false</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_constructible_v</span><span class="o">&lt;</span><span class="n">E</span><span class="p">,</span> <span class="k">const</span> <span class="n">unexpected</span><span class="o">&lt;</span><span class="n">Err</span><span class="o">>></span></code> is <code class="highlight">false</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_convertible_v</span><span class="o">&lt;</span><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">Err</span><span class="o">>&amp;</span><span class="p">,</span> <span class="n">E</span><span class="o">></span></code> is <code class="highlight">false</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_convertible_v</span><span class="o">&lt;</span><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">Err</span><span class="o">></span><span class="p">,</span> <span class="n">E</span><span class="o">></span></code> is <code class="highlight">false</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_convertible_v</span><span class="o">&lt;</span><span class="k">const</span> <span class="n">unexpected</span><span class="o">&lt;</span><span class="n">Err</span><span class="o">>&amp;</span><span class="p">,</span> <span class="n">E</span><span class="o">></span></code> is <code class="highlight">false</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_convertible_v</span><span class="o">&lt;</span><span class="k">const</span> <span class="n">unexpected</span><span class="o">&lt;</span><span class="n">Err</span><span class="o">></span><span class="p">,</span> <span class="n">E</span><span class="o">></span></code> is <code class="highlight">false</code>.</p>
   </ul>
   <p>This constructor is <code class="highlight"><span class="k">explicit</span></code> if and only if <code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">is_convertible_v</span><span class="o">&lt;</span><span class="n">Err</span><span class="p">,</span> <span class="n">E</span><span class="o">></span></code> is <code class="highlight">false</code>.</p>
<pre class="language-c++ highlight"><span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">Err</span><span class="o">></span>
<span class="n">constexpr</span> <span class="n">EXPLICIT</span> <span class="n">unexpected</span><span class="p">(</span><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">Err</span><span class="o">>&amp;&amp;</span> <span class="n">e</span><span class="p">);</span>
</pre>
   <p><em>Effects</em>: Initializes <code class="highlight"><span class="n">val</span></code> as if direct-non-list-initializing an
object of type <code class="highlight"><span class="n">E</span></code> with the expression <code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">move</span><span class="p">(</span><span class="n">e</span><span class="p">.</span><span class="n">val</span><span class="p">)</span></code>.</p>
   <p><em>Throws</em>: Any exception thrown by the selected constructor of <code class="highlight"><span class="n">E</span></code>.</p>
   <p><em>Remarks</em>: This constructor participates in overload resolution unless:</p>
   <ul>
    <li data-md="">
     <p><code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">is_constructible_v</span><span class="o">&lt;</span><span class="n">E</span><span class="p">,</span> <span class="n">Err</span><span class="o">></span></code> is <code class="highlight">true</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_constructible_v</span><span class="o">&lt;</span><span class="n">E</span><span class="p">,</span> <span class="n">unexpected</span><span class="o">&lt;</span><span class="n">Err</span><span class="o">>&amp;></span></code> is <code class="highlight">false</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_constructible_v</span><span class="o">&lt;</span><span class="n">E</span><span class="p">,</span> <span class="n">unexpected</span><span class="o">&lt;</span><span class="n">Err</span><span class="o">>></span></code> is <code class="highlight">false</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_constructible_v</span><span class="o">&lt;</span><span class="n">E</span><span class="p">,</span> <span class="k">const</span> <span class="n">unexpected</span><span class="o">&lt;</span><span class="n">Err</span><span class="o">>&amp;></span></code> is <code class="highlight">false</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_constructible_v</span><span class="o">&lt;</span><span class="n">E</span><span class="p">,</span> <span class="k">const</span> <span class="n">unexpected</span><span class="o">&lt;</span><span class="n">Err</span><span class="o">>></span></code> is <code class="highlight">false</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_convertible_v</span><span class="o">&lt;</span><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">Err</span><span class="o">>&amp;</span><span class="p">,</span> <span class="n">E</span><span class="o">></span></code> is <code class="highlight">false</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_convertible_v</span><span class="o">&lt;</span><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">Err</span><span class="o">></span><span class="p">,</span> <span class="n">E</span><span class="o">></span></code> is <code class="highlight">false</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_convertible_v</span><span class="o">&lt;</span><span class="k">const</span> <span class="n">unexpected</span><span class="o">&lt;</span><span class="n">Err</span><span class="o">>&amp;</span><span class="p">,</span> <span class="n">E</span><span class="o">></span></code> is <code class="highlight">false</code>; and</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">is_convertible_v</span><span class="o">&lt;</span><span class="k">const</span> <span class="n">unexpected</span><span class="o">&lt;</span><span class="n">Err</span><span class="o">></span><span class="p">,</span> <span class="n">E</span><span class="o">></span></code> is <code class="highlight">false</code>.</p>
   </ul>
   <p>This constructor is <code class="highlight"><span class="k">explicit</span></code> if and only if <code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">is_convertible_v</span><span class="o">&lt;</span><span class="n">Err</span><span class="p">,</span> <span class="n">E</span><span class="o">></span></code> is <code class="highlight">false</code></p>
   <p>�.�.5.2.2 Assignment [<em>expected.unexpected.assign</em>] {#expected.unexpected.assign}</p>
   <p>�.�.5.2.3 Observers [<em>expected.unexpected.observe</em>] {#expected.unexpected.observe}</p>
<pre class="language-c++ highlight"><span class="n">constexpr</span> <span class="k">const</span> <span class="n">E</span><span class="o">&amp;</span> <span class="n">value</span><span class="p">()</span> <span class="k">const</span><span class="o">&amp;</span><span class="p">;</span>
<span class="n">constexpr</span> <span class="n">E</span><span class="o">&amp;</span> <span class="n">value</span><span class="p">()</span> <span class="o">&amp;</span><span class="p">;</span>
</pre>
   <p><em>Returns</em>: <code class="highlight"><span class="n">val</span></code>.</p>
<pre class="language-c++ highlight"><span class="n">constexpr</span> <span class="n">E</span><span class="o">&amp;&amp;</span> <span class="n">value</span><span class="p">()</span> <span class="o">&amp;&amp;</span><span class="p">;</span>
<span class="n">constexpr</span> <span class="k">const</span> <span class="n">E</span><span class="o">&amp;&amp;</span> <span class="n">value</span><span class="p">()</span> <span class="k">const</span><span class="o">&amp;&amp;</span><span class="p">;</span>
</pre>
   <p><em>Returns</em>: <code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">move</span><span class="p">(</span><span class="n">val</span><span class="p">)</span></code>.</p>
   <p>�.�.5.2.4 Swap [<em>expected.unexpected.ctor</em>] {#expected.unexpected.swap}</p>
<pre class="language-c++ highlight">    <span class="kt">void</span> <span class="nf">swap</span><span class="p">(</span><span class="n">unexpected</span><span class="o">&amp;</span> <span class="n">other</span><span class="p">)</span> <span class="n">noexcept</span><span class="p">(</span><span class="n">see</span> <span class="n">bellow</span><span class="p">);</span>
</pre>
   <p><em>Requires</em>: <code class="highlight"><span class="n">is_swappable_v</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code> is <code class="highlight">true</code></p>
   <p><em>Effects</em>: Equivalent to <code class="highlight"><span class="k">using</span> <span class="n">std</span><span class="o">::</span><span class="n">swap</span><span class="p">;</span> <span class="n">swap</span><span class="p">(</span><span class="n">val</span><span class="p">,</span> <span class="n">other</span><span class="p">.</span><span class="n">val</span><span class="p">);</span></code>.</p>
   <p><em>Throws</em>:</p>
   <p><em>Remarks</em>: The expression inside <code class="highlight"><span class="k">noexcept</span></code> is equivalent to: <code class="highlight"><span class="n">is_nothrow_swappable_v</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code> is <code class="highlight">true</code>.</p>
   <h3 class="heading settled" data-level="1.18" id="expected.unexpected.equality_op"><span class="secno">1.18. </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"><span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">E1</span><span class="p">,</span> <span class="n">class</span> <span class="n">E2</span><span class="o">></span>
    <span class="n">friend</span> <span class="n">constexpr</span> <span class="kt">bool</span> <span class="n">operator</span><span class="o">==</span><span class="p">(</span><span class="k">const</span> <span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E1</span><span class="o">>&amp;</span> <span class="n">x</span><span class="p">,</span> <span class="k">const</span> <span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E2</span><span class="o">>&amp;</span> <span class="n">y</span><span class="p">);</span>
</pre>
   <p><em>Returns</em>: <code class="highlight"><span class="n">x</span><span class="p">.</span><span class="n">value</span><span class="p">()</span> <span class="o">==</span> <span class="n">y</span><span class="p">.</span><span class="n">value</span><span class="p">()</span></code>.</p>
<pre class="language-c++ highlight"><span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">E1</span><span class="p">,</span> <span class="n">class</span> <span class="n">E2</span><span class="o">></span>
    <span class="n">friend</span> <span class="n">constexpr</span> <span class="kt">bool</span> <span class="n">operator</span><span class="o">!=</span><span class="p">(</span><span class="k">const</span> <span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E1</span><span class="o">>&amp;</span> <span class="n">x</span><span class="p">,</span> <span class="k">const</span> <span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E2</span><span class="o">>&amp;</span> <span class="n">y</span><span class="p">);</span>
</pre>
   <p><em>Returns</em>: <code class="highlight"><span class="n">x</span><span class="p">.</span><span class="n">value</span><span class="p">()</span> <span class="o">!=</span> <span class="n">y</span><span class="p">.</span><span class="n">value</span><span class="p">()</span></code>.</p>
   <p>�.�.5.2.5 Specialized algorithms [<em>expected.unexpected.specalg</em>] {#expected.unexpected.specalg}</p>
<pre class="language-c++ highlight"><span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">E1</span><span class="o">></span>
    <span class="n">friend</span> <span class="kt">void</span> <span class="n">swap</span><span class="p">(</span><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E1</span><span class="o">>&amp;</span> <span class="n">x</span><span class="p">,</span> <span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E1</span><span class="o">>&amp;</span> <span class="n">y</span><span class="p">)</span> <span class="n">noexcept</span><span class="p">(</span><span class="n">noexcept</span><span class="p">(</span><span class="n">x</span><span class="p">.</span><span class="n">swap</span><span class="p">(</span><span class="n">y</span><span class="p">)));</span>
</pre>
   <p><em>Effects</em>: Equivalent to <code class="highlight"><span class="n">x</span><span class="p">.</span><span class="n">swap</span><span class="p">(</span><span class="n">y</span><span class="p">)</span></code>.</p>
   <p><em>Remarks</em>: This function shall not participate in overload resolution unless <code class="highlight"><span class="n">is_swappable_v</span><span class="o">&lt;</span><span class="n">E1</span><span class="o">></span></code> is <code class="highlight">true</code>.</p>
   <h3 class="heading settled" data-level="1.19" id="expected.bad_expected_access"><span class="secno">1.19. </span><span class="content">�.�.6 Template Class <code class="highlight"><span class="n">bad_expected_access</span></code> [<em>expected.bad_expected_access</em>]</span><a class="self-link" href="#expected.bad_expected_access"></a></h3>
<pre class="language-c++ highlight"><span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">E</span><span class="o">></span>
<span class="n">class</span> <span class="nl">bad_expected_access</span> <span class="p">:</span> <span class="n">public</span> <span class="n">bad_expected_access</span><span class="o">&lt;</span><span class="kt">void</span><span class="o">></span> <span class="p">{</span>
<span class="nl">public</span><span class="p">:</span>
    <span class="n">explicit</span> <span class="n">bad_expected_access</span><span class="p">(</span><span class="n">E</span><span class="p">);</span>
    <span class="n">virtual</span> <span class="k">const</span> <span class="kt">char</span><span class="o">*</span> <span class="nf">what</span><span class="p">()</span> <span class="k">const</span> <span class="n">noexcept</span> <span class="n">override</span><span class="p">;</span>
    <span class="n">E</span><span class="o">&amp;</span> <span class="n">error</span><span class="p">()</span> <span class="o">&amp;</span><span class="p">;</span>
    <span class="k">const</span> <span class="n">E</span><span class="o">&amp;</span> <span class="n">error</span><span class="p">()</span> <span class="k">const</span><span class="o">&amp;</span><span class="p">;</span>
    <span class="n">E</span><span class="o">&amp;&amp;</span> <span class="n">error</span><span class="p">()</span> <span class="o">&amp;&amp;</span><span class="p">;</span>
    <span class="k">const</span> <span class="n">E</span><span class="o">&amp;&amp;</span>  <span class="n">error</span><span class="p">()</span> <span class="k">const</span><span class="o">&amp;&amp;</span><span class="p">;</span>
<span class="nl">private</span><span class="p">:</span>
    <span class="n">E</span> <span class="n">val</span><span class="p">;</span> <span class="c1">// exposition only</span>
<span class="c1"></span><span class="p">};</span>
</pre>
   <p class="issue" id="issue-4272f159"><a class="self-link" href="#issue-4272f159"></a> Wondering if we just need an <code class="highlight"><span class="k">const</span><span class="o">&amp;</span></code> overload as we do for <code class="highlight"><span class="n">system_error</span></code>.</p>
   <p>The template class <code class="highlight"><span class="n">bad_expected_access</span></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"><span class="n">expected</span></code> object that contains an <code class="highlight"><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code>.</p>
<pre class="language-c++ highlight"><span class="n">bad_expected_access</span><span class="o">::</span><span class="n">bad_expected_access</span><span class="p">(</span><span class="n">E</span> <span class="n">e</span><span class="p">);</span>
</pre>
   <p><em>Effects</em>: Initialize <code class="highlight"><span class="n">val</span></code> with <code class="highlight"><span class="n">e</span></code>.</p>
   <p><em>Postconditions</em>: <code class="highlight"><span class="n">what</span><span class="p">()</span></code> returns an implementation-defined NTBS.</p>
<pre class="language-c++ highlight"><span class="k">const</span> <span class="n">E</span><span class="o">&amp;</span> <span class="n">error</span><span class="p">()</span> <span class="k">const</span><span class="o">&amp;</span><span class="p">;</span>
<span class="n">E</span><span class="o">&amp;</span> <span class="n">error</span><span class="p">()</span> <span class="o">&amp;</span><span class="p">;</span>
</pre>
   <p><em>Returns</em>: <code class="highlight"><span class="n">val</span><span class="p">;</span></code></p>
<pre class="language-c++ highlight"><span class="n">E</span><span class="o">&amp;&amp;</span> <span class="n">error</span><span class="p">()</span> <span class="o">&amp;&amp;</span><span class="p">;</span>
<span class="k">const</span> <span class="n">E</span><span class="o">&amp;&amp;</span> <span class="n">error</span><span class="p">()</span> <span class="k">const</span><span class="o">&amp;&amp;</span><span class="p">;</span>
</pre>
   <p><em>Returns</em>: <code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">move</span><span class="p">(</span><span class="n">val</span><span class="p">);</span></code></p>
<pre class="language-c++ highlight"><span class="n">virtual</span> <span class="k">const</span> <span class="kt">char</span><span class="o">*</span> <span class="nf">what</span><span class="p">()</span> <span class="k">const</span> <span class="n">noexcept</span> <span class="n">override</span><span class="p">;</span>
</pre>
   <p><em>Returns</em>: An implementation-defined NTBS.</p>
   <h3 class="heading settled" data-level="1.20" id="expected.bad_expected_access_base"><span class="secno">1.20. </span><span class="content">�.�.7 Class <code class="highlight"><span class="n">bad_expected_access</span><span class="o">&lt;</span><span class="kt">void</span><span class="o">></span></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"><span class="n">template</span><span class="o">&lt;></span>
<span class="n">class</span> <span class="n">bad_expected_access</span><span class="o">&lt;</span><span class="kt">void</span><span class="o">></span> <span class="o">:</span> <span class="n">public</span> <span class="n">exception</span> <span class="p">{</span>
<span class="nl">public</span><span class="p">:</span>
    <span class="n">explicit</span> <span class="n">bad_expected_access</span><span class="p">();</span>
<span class="p">};</span>
</pre>
   <h3 class="heading settled" data-level="1.21" id="expected.unexpect"><span class="secno">1.21. </span><span class="content">�.�.8 <code class="highlight"><span class="n">unexpect</span></code> tag [<em>expected.unexpect</em>]</span><a class="self-link" href="#expected.unexpect"></a></h3>
<pre class="language-c++ highlight"><span class="k">struct</span> <span class="n">unexpect_t</span> <span class="p">{</span>
    <span class="n">explicit</span> <span class="n">unexpect_t</span><span class="p">()</span> <span class="o">=</span> <span class="k">default</span><span class="p">;</span>
<span class="p">};</span>
<span class="kr">inline</span> <span class="n">constexpr</span> <span class="n">unexpect_t</span> <span class="n">unexpect</span><span class="p">{};</span>
</pre>
   <h2 class="heading settled" data-level="2" id="qq"><span class="secno">2. </span><span class="content">Open Questions</span><a class="self-link" href="#qq"></a></h2>
   <p><code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">expected</span></code> is a vocabulary type with an opinionated design and a proven
record under varied forms in a multitude of codebases. Its current form has
undergone multiple revisions and received substantial feedback, falling roughly
in the following categories:</p>
   <ol>
    <li data-md="">
     <p><strong>Ergonomics</strong>: is this <em>the right way</em> to expose such functionality?</p>
    <li data-md="">
     <p><strong>Disappointment</strong>: should we expose this in the Standard, given C++'s
 existing error handling mechanisms?</p>
    <li data-md="">
     <p><strong>STL usage</strong>: should the Standard Template Library adopt this class, at
 which pace, and where?</p>
   </ol>
   <p>LEWG and EWG have nonetheless reached consensus that a class of this general
approach is probably desirable, and the only way to truly answer these questions
is to try it out in a TS and ask for explicit feedback from developers. The
authors hope that developers will provide new information which they’ll be able
to communicate to the Committee.</p>
   <p>Here are open questions, and questions which the Committee thinks are settled
and which new information can justify revisiting.</p>
   <h3 class="heading settled" data-level="2.1" id="ergo"><span class="secno">2.1. </span><span class="content">Ergonomics</span><a class="self-link" href="#ergo"></a></h3>
   <ol>
    <li data-md="">
     <p>Name:</p>
     <ul>
      <li data-md="">
       <p>Is <code class="highlight"><span class="n">expected</span></code> the right name?</p>
      <li data-md="">
       <p>Does it express intent both as a consumer and a producer?</p>
     </ul>
    <li data-md="">
     <p>Is <code class="highlight"><span class="n">E</span></code> a salient property of <code class="highlight"><span class="n">expected</span></code>?</p>
    <li data-md="">
     <p>Is <code class="highlight"><span class="n">expected</span><span class="o">&lt;</span><span class="kt">void</span><span class="p">,</span> <span class="n">E</span><span class="o">></span></code> clear on what it expresses as a return type?</p>
    <li data-md="">
     <p>Would it make sense for <code class="highlight"><span class="n">expected</span></code> to support containing <em>both</em> <code class="highlight"><span class="n">T</span></code> and <code class="highlight"><span class="n">E</span></code> (in some designs, either one of them being optional), or is this use case better handled by a separate proposal?</p>
    <li data-md="">
     <p>Is the order of parameters <code class="highlight"><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span> <span class="n">E</span><span class="o">></span></code> appropriate?</p>
    <li data-md="">
     <p>Is usage of <code class="highlight"><span class="n">expected</span></code> "viral" in a codebase, or can it be adopted incrementally?</p>
    <li data-md="">
     <ul>
      <li data-md="">
       <p>Missing <code class="highlight"><span class="n">expected</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span><span class="n">E</span><span class="o">>::</span><span class="n">emplace</span></code> for <code class="highlight"><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code>.</p>
      <li data-md="">
       <p>The in-place construction from a <code class="highlight"><span class="n">unexpected</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code> using the <code class="highlight"><span class="n">unexpet</span></code> tag doesn’t conveys the in-place nature of this constructor.</p>
      <li data-md="">
       <p>Do we need in-place using indexes, as variant?</p>
     </ul>
    <li data-md="">
     <p>Comparisons:</p>
     <ul>
      <li data-md="">
       <p>Are <code class="highlight"><span class="o">==</span></code> and <code class="highlight"><span class="o">!=</span></code> useful?</p>
      <li data-md="">
       <p>Should other comparisons be provided?</p>
      <li data-md="">
       <p>What usages of <code class="highlight"><span class="n">expected</span></code> mandate putting instances in a <code class="highlight"><span class="n">map</span></code>, or other such container?</p>
      <li data-md="">
       <p>Should <code class="highlight"><span class="n">hash</span></code> be provided?</p>
      <li data-md="">
       <p>What usages of <code class="highlight"><span class="n">expected</span></code> mandate putting instances in an <code class="highlight"><span class="n">unordered_map</span></code>, or other such container?</p>
      <li data-md="">
       <p>Should <code class="highlight"><span class="n">expected</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span> <span class="n">E</span><span class="o">></span></code> always be comparable if <code class="highlight"><span class="n">T</span></code> is comparable, even if <code class="highlight"><span class="n">E</span></code> is not comparable?</p>
     </ul>
    <li data-md="">
     <p>Error type <code class="highlight"><span class="n">E</span></code>:</p>
     <ul>
      <li data-md="">
       <p>Have <code class="highlight"><span class="n">expected</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span> <span class="kt">void</span><span class="o">></span></code> and <code class="highlight"><span class="n">unexpected</span><span class="o">&lt;</span><span class="kt">void</span><span class="o">></span></code> a sense?</p>
      <li data-md="">
       <p><code class="highlight"><span class="n">E</span></code> template parameter has no default. Should it?</p>
      <li data-md="">
       <p>Should <code class="highlight"><span class="n">expected</span></code> be specialized for particular <code class="highlight"><span class="n">E</span></code> types such as <code class="highlight"><span class="n">exception_ptr</span></code> and how?</p>
      <li data-md="">
       <p>Should <code class="highlight"><span class="n">expected</span></code> handle <code class="highlight"><span class="n">E</span></code> types with a built-in "success" value any differently and how?</p>
      <li data-md="">
       <p><code class="highlight"><span class="n">expected</span></code> is not implicitly constructible from an <code class="highlight"><span class="n">E</span></code>, even when unambiguous from <code class="highlight"><span class="n">T</span></code>, because as a vocabulary type it wants unexpected error construction to be verbose, and require hopping through an <code class="highlight"><span class="n">unexpected</span></code>. Is the verbosity extraneous? We could alleviate the verbosity by adding a <code class="highlight"><span class="p">.</span><span class="n">unexpected</span><span class="p">()</span></code> method to <code class="highlight"><span class="n">expected</span></code>, so that one doesn’t have to write <code class="highlight"><span class="n">unexpected</span><span class="p">(</span><span class="n">e</span><span class="p">.</span><span class="n">error</span><span class="p">())</span></code> when constructing a new <code class="highlight"><span class="n">expected</span></code> from an error.</p>
     </ul>
    <li data-md="">
     <p>Does usage of this class cause a meaningful performance impact compared to using error codes?</p>
    <li data-md="">
     <p>The accessor design offers a terse unchecked dereference operator (expected to be used alongside the implicit <code class="highlight"><span class="kt">bool</span></code> conversion), as well as <code class="highlight"><span class="n">value</span><span class="p">()</span></code> and <code class="highlight"><span class="n">error</span><span class="p">()</span></code> accessors which are checked. Is that a gotcha, or is it similar enough to classes such as <code class="highlight"><span class="n">optional</span></code> to be unsurprising?</p>
    <li data-md="">
     <p>Is <code class="highlight"><span class="n">bad_expected_access</span></code> the right thing to throw?</p>
    <li data-md="">
     <p>Should some members be <code class="highlight"><span class="n">nodiscard</span></code>?</p>
    <li data-md="">
     <p>Should constructors of <code class="highlight"><span class="n">expected</span></code> disallow <code class="highlight"><span class="n">T</span></code> which are specializations of <code class="highlight"><span class="n">expected</span></code>?</p>
    <li data-md="">
     <p>Similarly, can <code class="highlight"><span class="n">T</span></code> and <code class="highlight"><span class="n">E</span></code> be abominable functions?</p>
   </ol>
   <h3 class="heading settled" data-level="2.2" id="dis"><span class="secno">2.2. </span><span class="content">Disappointment</span><a class="self-link" href="#dis"></a></h3>
   <p>C++ already supports exceptions and error codes, <code class="highlight"><span class="n">expected</span></code> would be a third
kind of error handling.</p>
   <ol>
    <li data-md="">
     <p>where does <code class="highlight"><span class="n">expected</span></code> work better than either exceptions or error handling?</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">expected</span></code> was designed to be particularly well suited to APIs which require their immediate caller to consider an error scenario. Do it succeed in that purpose?</p>
    <li data-md="">
     <p>Do codebases successfully compose these three types of error handling?</p>
    <li data-md="">
     <p>Is debuggability any harder?</p>
    <li data-md="">
     <p>Is it easy to teach C++ as a whole with a third type of error handling?</p>
   </ol>
   <h3 class="heading settled" data-level="2.3" id="stl"><span class="secno">2.3. </span><span class="content">STL Usage</span><a class="self-link" href="#stl"></a></h3>
   <ol>
    <li data-md="">
     <p>Should <code class="highlight"><span class="n">expected</span></code> be used in the STL at the same time as it gets standardized?</p>
    <li data-md="">
     <p>Where, considering <code class="highlight"><span class="n">std2</span></code> may be a good place to change APIs?</p>
   </ol>
  </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-p0323r4">[P0323r4]
   <dd>Vicente Botet, JF Bastien. <a href="https://wg21.link/p0323r4">std::expected</a>. 26 November 2017. URL: <a href="https://wg21.link/p0323r4">https://wg21.link/p0323r4</a>
   <dt id="biblio-p0323r5">[P0323r5]
   <dd>Vicente Botet, JF Bastien. <a href="https://wg21.link/p0323r5">std::expected</a>. 8 February 2018. URL: <a href="https://wg21.link/p0323r5">https://wg21.link/p0323r5</a>
   <dt id="biblio-p0323r6">[P0323r6]
   <dd>Vicente Botet, JF Bastien. <a href="https://wg21.link/p0323r6">std::expected</a>. 2 April 2018. URL: <a href="https://wg21.link/p0323r6">https://wg21.link/p0323r6</a>
  </dl>
  <h2 class="no-num no-ref heading settled" id="issues-index"><span class="content">Issues Index</span><a class="self-link" href="#issues-index"></a></h2>
  <div style="counter-reset:issue">
   <div class="issue"> Wondering if we just need an <code class="highlight"><span class="k">const</span><span class="o">&amp;</span></code> overload as we do for <code class="highlight"><span class="n">system_error</span></code>.<a href="#issue-4272f159"> ↵ </a></div>
  </div>