<!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>p1054R0: A Unified Futures Proposal for C++</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 li { font-size:   85%;    }

	.toc > li             { margin: 1.5rem 0;    }
	.toc > li li          { margin: 0.3rem 0;    }
	.toc > li li li       { margin-left: 2rem;   }

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

	: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; }
	}
	@media screen and (min-width: 78em) {
		body:not(.toc-inline) :not(li) > .toc              { margin-left:  4rem; }
		body:not(.toc-inline) .toc .secno                  { margin-left: -4rem; }
		body:not(.toc-inline) .toc > li li li              { margin-left:  1rem; }
		body:not(.toc-inline) .toc > li li li .secno       { margin-left: -5rem; }
		body:not(.toc-inline) .toc > li li li li .secno    { margin-left: -6rem; }
		body:not(.toc-inline) .toc > li li li li li .secno { margin-left: -7rem; }
	}
	body.toc-sidebar #toc :not(li) > .toc              { margin-left:  4rem; }
	body.toc-sidebar #toc .toc .secno                  { margin-left: -4rem; }
	body.toc-sidebar #toc .toc > li li li              { margin-left:  1rem; }
	body.toc-sidebar #toc .toc > li li li .secno       { margin-left: -5rem; }
	body.toc-sidebar #toc .toc > li li li li .secno    { margin-left: -6rem; }
	body.toc-sidebar #toc .toc > li li li li li .secno { margin-left: -7rem; }

	.toc li {
		clear: both;
	}


/** 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 4ed3ee986a8d1722dd7c6bb819b1a2484c3cfb47" name="generator">
  <link href="wg21.link/P1054" rel="canonical">
  <meta content="69e96c4c8ea561e748a88007cf1afa44debbd270" 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-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-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-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>
<style>/* style-dfn-panel */

        .dfn-panel {
            position: absolute;
            z-index: 35;
            height: auto;
            width: -webkit-fit-content;
            width: fit-content;
            max-width: 300px;
            max-height: 500px;
            overflow: auto;
            padding: 0.5em 0.75em;
            font: small Helvetica Neue, sans-serif, Droid Sans Fallback;
            background: #DDDDDD;
            color: black;
            border: outset 0.2em;
        }
        .dfn-panel:not(.on) { display: none; }
        .dfn-panel * { margin: 0; padding: 0; text-indent: 0; }
        .dfn-panel > b { display: block; }
        .dfn-panel a { color: black; }
        .dfn-panel a:not(:hover) { text-decoration: none !important; border-bottom: none !important; }
        .dfn-panel > b + b { margin-top: 0.25em; }
        .dfn-panel ul { padding: 0; }
        .dfn-panel li { list-style: inside; }
        .dfn-panel.activated {
            display: inline-block;
            position: fixed;
            left: .5em;
            bottom: 2em;
            margin: 0 auto;
            max-width: calc(100vw - 1.5em - .4em - .5em);
            max-height: 30vh;
        }

        .dfn-paneled { cursor: pointer; }
        </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>
 <body class="h-entry">
  <div class="head">
   <p data-fill-with="logo"></p>
   <h1 class="p-name no-ref" id="title">p1054R0<br>A Unified Futures Proposal for C++</h1>
   <h2 class="no-num no-toc no-ref heading settled" id="subtitle"><span class="content">Draft Proposal, <time class="dt-updated" datetime="2018-05-07">7 May 2018</time></span></h2>
   <div data-fill-with="spec-metadata">
    <dl>
     <dt>This version:
     <dd><a class="u-url" href="wg21.link/P1054">wg21.link/P1054</a>
     <dt>Authors:
     <dd>
      <dd class="editor p-author h-card vcard"><a class="p-name fn u-email email" href="mailto:lwh@fb.com">Lee Howes</a> (<span class="p-org org">Facebook</span>)
     <dd>
      <dd class="editor p-author h-card vcard"><a class="p-name fn u-email email" href="mailto:brycelelbach@gmail.com">Bryce Adelstein Lelbach</a> (<span class="p-org org">NVIDIA</span>)
     <dd>
      <dd class="editor p-author h-card vcard"><a class="p-name fn u-email email" href="mailto:dshollm@sandia.gov">David S. Hollman</a> (<span class="p-org org">Sandia National Labs</span>)
     <dd>
      <dd class="editor p-author h-card vcard"><a class="p-name fn u-email email" href="mailto:griwes@griwes.info">Michał Dominiak</a> (<span class="p-org org">Nokia</span>)
     <dt>Audience:
     <dd>SG1
     <dt>Project:
     <dd>ISO JTC1/SC22/WG21: Programming Language C++
     <dt>Source:
     <dd><a href="https://github.com/executors/futures/blob/master/futures.bs">github.com/executors/futures/blob/master/futures.bs</a>
    </dl>
   </div>
   <div data-fill-with="warning"></div>
   <hr title="Separator for header">
  </div>
  <nav data-fill-with="table-of-contents" id="toc">
   <h2 class="no-num no-toc no-ref" id="contents">Table of Contents</h2>
   <ol class="toc" role="directory">
    <li>
     <a href="#intro"><span class="secno">1</span> <span class="content">Introduction</span></a>
     <ol class="toc">
      <li><a href="#intro_execution_model"><span class="secno">1.1</span> <span class="content">The Future/Promise Execution Model</span></a>
      <li><a href="#intro_executors"><span class="secno">1.2</span> <span class="content">Interactions with Executors</span></a>
      <li><a href="#intro_exception_model"><span class="secno">1.3</span> <span class="content">The Exception Handling Model</span></a>
      <li><a href="#intro_cancellation"><span class="secno">1.4</span> <span class="content">The Future Cancellation Model</span></a>
      <li><a href="#intro_semi_future_via"><span class="secno">1.5</span> <span class="content"><code class="highlight"><span class="n">SemiFuture</span></code> and <code class="highlight"><span class="p">.</span><span class="n">via</span></code> For Composition</span></a>
      <li><a href="#intro_rvalue_ref"><span class="secno">1.6</span> <span class="content">Consuming Interfaces Are Rvalue Reference Qualified</span></a>
      <li><a href="#intro_blocking"><span class="secno">1.7</span> <span class="content">Blocking Interfaces (<code class="highlight"><span class="p">.</span><span class="n">get</span></code> and <code class="highlight"><span class="p">.</span><span class="n">wait</span></code>)</span></a>
      <li><a href="#intro_future_work"><span class="secno">1.8</span> <span class="content">Future Work</span></a>
      <li><a href="#intro_prior_work"><span class="secno">1.9</span> <span class="content">Prior Work</span></a>
     </ol>
    <li>
     <a href="#wording"><span class="secno">2</span> <span class="content">Proposed New Wording</span></a>
     <ol class="toc">
      <li><a href="#wording_execution_model"><span class="secno">2.1</span> <span class="content">The Future/Promise Execution Model</span></a>
      <li><a href="#wording_future_continuation"><span class="secno">2.2</span> <span class="content"><code class="highlight"><span class="n">FutureContinuation</span></code> Requirements</span></a>
      <li>
       <a href="#wording_promise"><span class="secno">2.3</span> <span class="content"><code class="highlight"><span class="n">Promise</span></code> Requirements</span></a>
       <ol class="toc">
        <li><a href="#wording_promise_contracts"><span class="secno">2.3.1</span> <span class="content">Promise Contract Executor Properties</span></a>
       </ol>
      <li><a href="#wording_semi_future"><span class="secno">2.4</span> <span class="content"><code class="highlight"><span class="n">SemiFuture</span></code> Requirements</span></a>
      <li><a href="#wording_continuable_future"><span class="secno">2.5</span> <span class="content"><code class="highlight"><span class="n">ContinuableFuture</span></code> Requirements</span></a>
      <li><a href="#wording_shared_future"><span class="secno">2.6</span> <span class="content"><code class="highlight"><span class="n">SharedFuture</span></code> Requirements</span></a>
      <li><a href="#wording_erasing_promise"><span class="secno">2.7</span> <span class="content"><code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">execution</span><span class="o">::</span><span class="n">promise</span></code></span></a>
      <li><a href="#wording_erasing_semi_future"><span class="secno">2.8</span> <span class="content"><code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">execution</span><span class="o">::</span><span class="n">semi_future</span></code></span></a>
      <li><a href="#wording_erasing_continuable_future"><span class="secno">2.9</span> <span class="content"><code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">execution</span><span class="o">::</span><span class="n">continuable_future</span></code></span></a>
      <li><a href="#wording_erasing_shared_future"><span class="secno">2.10</span> <span class="content"><code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">execution</span><span class="o">::</span><span class="n">shared_future</span></code></span></a>
      <li><a href="#wording_make_promise_contract"><span class="secno">2.11</span> <span class="content"><code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">execution</span><span class="o">::</span><span class="n">make_promise_contract</span></code></span></a>
      <li><a href="#wording_blocking_functions"><span class="secno">2.12</span> <span class="content">Generic Future Blocking Functions</span></a>
      <li><a href="#wording_future_continuation_helper_functions"><span class="secno">2.13</span> <span class="content"><code class="highlight"><span class="n">FutureContinuation</span></code> Helper Functions</span></a>
      <li>
       <a href="#wording_p0443"><span class="secno">2.14</span> <span class="content">Proposed Modifications to Executors</span></a>
       <ol class="toc">
        <li><a href="#wording_p0443_future"><span class="secno">2.14.1</span> <span class="content"><code class="highlight"><span class="n">Future</span></code> Requirements</span></a>
        <li><a href="#wording_p0443_two_way_executor"><span class="secno">2.14.2</span> <span class="content"><code class="highlight"><span class="n">TwoWayExecutor</span></code> Requirements</span></a>
        <li><a href="#wording_p0443_then_executor"><span class="secno">2.14.3</span> <span class="content"><code class="highlight"><span class="n">ThenExecutor</span></code> Requirements</span></a>
        <li><a href="#wording_p0443_bulk_two_way_executor"><span class="secno">2.14.4</span> <span class="content"><code class="highlight"><span class="n">BulkTwoWayExecutor</span></code> Requirements</span></a>
        <li><a href="#wording_p0443_bulk_then_executor"><span class="secno">2.14.5</span> <span class="content"><code class="highlight"><span class="n">BulkThenExecutor</span></code> Requirements</span></a>
        <li><a href="#wording_p0443_twoway_t"><span class="secno">2.14.6</span> <span class="content"><code class="highlight"><span class="n">twoway_t</span></code> Customization Points</span></a>
        <li><a href="#wording_p0443_single_t"><span class="secno">2.14.7</span> <span class="content"><code class="highlight"><span class="n">single_t</span></code> Customization Points</span></a>
        <li><a href="#wording_p0443_blocking_and_directionality_properties"><span class="secno">2.14.8</span> <span class="content">Properties To Indicate If Blocking And Directionality May Be Adapted</span></a>
        <li><a href="#wording_p0443_erasing_executor"><span class="secno">2.14.9</span> <span class="content">Class Template <code class="highlight"><span class="n">executor</span></code></span></a>
        <li><a href="#wording_p0443_erasing_executor_operations"><span class="secno">2.14.10</span> <span class="content"><code class="highlight"><span class="n">executor</span></code> Operations</span></a>
        <li><a href="#wording_p0443_static_thread_pool"><span class="secno">2.14.11</span> <span class="content"><code class="highlight"><span class="n">static_thread_pool</span></code> Executor Type</span></a>
       </ol>
     </ol>
    <li>
     <a href="#index"><span class="secno"></span> <span class="content">Index</span></a>
     <ol class="toc">
      <li><a href="#index-defined-here"><span class="secno"></span> <span class="content">Terms defined by this specification</span></a>
     </ol>
    <li>
     <a href="#references"><span class="secno"></span> <span class="content">References</span></a>
     <ol class="toc">
      <li><a href="#informative"><span class="secno"></span> <span class="content">Informative References</span></a>
     </ol>
   </ol>
  </nav>
  <main>
   <p>Contributors:</p>
   <table border="1">
    <tbody>
     <tr>
      <td>Marshall Cline
      <td>Carter   Edwards
      <td>Jay      Feldblum
     <tr>
      <td>Andrii   Grynenko
      <td>Jared    Hoberock
      <td>Hartmut  Kaiser
     <tr>
      <td>Chris    Kohlhoff
      <td>Chris    Mysen
      <td>Eric     Niebler
     <tr>
      <td>Sean     Parent
      <td>Cory     Perry
      <td>Felix    Petriconi
     <tr>
      <td>Kirk     Shoop
      <td>Mathias  Stearn
      <td>
   </table>
   <h2 class="heading settled" data-level="1" id="intro"><span class="secno">1. </span><span class="content">Introduction</span><a class="self-link" href="#intro"></a></h2>
   <p>This paper introduces a hierarchy of concepts for future types that are designed to:</p>
   <ul>
    <li data-md="">
     <p><em>Interoperate With Executors:</em> The concepts should require the functionality needed by <a href="https://wg21.link/P0443">executors</a>.</p>
    <li data-md="">
     <p><em>Compose With Each Other:</em> The concepts should require the types to be composable.</p>
    <li data-md="">
     <p><em>Stay Skinny:</em> The concepts should require absolutely nothing else so that it is not burdensome to write future types.</p>
   </ul>
   <p>There are five concepts introduces in this paper:</p>
   <ul>
    <li data-md="">
     <p><code class="highlight"><span class="n">FutureContinuation</span></code>, invocable objects that are called with the value or exception of a future as an argument.</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">SemiFuture</span></code>, which can be bound to an executor, an operation which produces a <code class="highlight"><span class="n">ContinuableFuture</span></code> (<code class="highlight"><span class="n">f</span> <span class="o">=</span> <span class="n">sf</span><span class="p">.</span><span class="n">via</span><span class="p">(</span><span class="n">exec</span><span class="p">)</span></code>).</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">ContinuableFuture</span></code>, which refines <code class="highlight"><span class="n">SemiFuture</span></code> and instances can have one <code class="highlight"><span class="n">FutureContinuation</span></code> attached to them (<code class="highlight"><span class="n">f</span><span class="p">.</span><span class="n">then</span><span class="p">(</span><span class="n">c</span><span class="p">)</span></code>), which is executed on the future’s associated executor when the future becomes ready.</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">SharedFuture</span></code>, which refines <code class="highlight"><span class="n">ContinuableFuture</span></code> and instances can have multiple <code class="highlight"><span class="n">FutureContinuation</span></code>s attached to them.</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">Promise</span></code>, each of which is associated with a future and make the future ready with either a value or an exception.</p>
   </ul>
   <p>Or, described another way:</p>
<pre class="highlight"><span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">T</span><span class="o">></span>
<span class="k">struct</span> <span class="n">FutureContinuation</span>
<span class="p">{</span>
  <span class="c1">// At least one of these two overloads exists:</span>
<span class="c1"></span>  <span class="k">auto</span> <span class="k">operator</span><span class="p">()(</span><span class="n">T</span> <span class="n">value</span><span class="p">);</span>
  <span class="k">auto</span> <span class="nf">operator</span><span class="p">()(</span><span class="n">exception_arg_t</span><span class="p">,</span> <span class="n">exception_ptr</span> <span class="n">exception</span><span class="p">);</span>
<span class="p">};</span>

<span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">T</span><span class="o">></span>
<span class="k">struct</span> <span class="n">SemiFuture</span>
<span class="p">{</span>
  <span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">Executor</span><span class="o">></span>
  <span class="n">ContinuableFuture</span><span class="o">&lt;</span><span class="n">Executor</span><span class="p">,</span> <span class="n">T</span><span class="o">></span> <span class="n">via</span><span class="p">(</span><span class="n">Executor</span><span class="o">&amp;&amp;</span> <span class="n">exec</span><span class="p">)</span> <span class="o">&amp;&amp;</span><span class="p">;</span>
<span class="p">};</span>

<span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">Executor</span><span class="p">,</span> <span class="k">typename</span> <span class="n">T</span><span class="o">></span>
<span class="k">struct</span> <span class="n">ContinuableFuture</span>
<span class="p">{</span>
  <span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">RExecutor</span><span class="o">></span>
  <span class="n">ContinuableFuture</span><span class="o">&lt;</span><span class="n">RExecutor</span><span class="p">,</span> <span class="n">T</span><span class="o">></span> <span class="n">via</span><span class="p">(</span><span class="n">RExecutor</span><span class="o">&amp;&amp;</span> <span class="n">exec</span><span class="p">)</span> <span class="o">&amp;&amp;</span><span class="p">;</span>

  <span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">Continuation</span><span class="o">></span>
  <span class="n">ContinuableFuture</span><span class="o">&lt;</span><span class="n">Executor</span><span class="p">,</span> <span class="k">auto</span><span class="o">></span> <span class="n">then</span><span class="p">(</span><span class="n">Continuation</span><span class="o">&amp;&amp;</span> <span class="n">c</span><span class="p">)</span> <span class="o">&amp;&amp;</span><span class="p">;</span>
<span class="p">};</span>

<span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">Executor</span><span class="p">,</span> <span class="k">typename</span> <span class="n">T</span><span class="o">></span>
<span class="k">struct</span> <span class="n">SharedFuture</span>
<span class="p">{</span>
  <span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">RExecutor</span><span class="o">></span>
  <span class="n">ContinuableFuture</span><span class="o">&lt;</span><span class="n">RExecutor</span><span class="p">,</span> <span class="k">auto</span><span class="o">></span> <span class="n">via</span><span class="p">(</span><span class="n">RExecutor</span><span class="o">&amp;&amp;</span> <span class="n">exec</span><span class="p">);</span>

  <span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">Continuation</span><span class="o">></span>
  <span class="n">SharedFuture</span><span class="o">&lt;</span><span class="n">Executor</span><span class="p">,</span> <span class="k">auto</span><span class="o">></span> <span class="n">then</span><span class="p">(</span><span class="n">Continuation</span><span class="o">&amp;&amp;</span> <span class="n">c</span><span class="p">);</span>
<span class="p">};</span>

<span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">T</span><span class="o">></span>
<span class="k">struct</span> <span class="n">Promise</span>
<span class="p">{</span>
  <span class="kt">void</span> <span class="n">set_value</span><span class="p">(</span><span class="n">T</span> <span class="n">value</span><span class="p">)</span> <span class="o">&amp;&amp;</span><span class="p">;</span>

  <span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">Error</span><span class="o">></span>
  <span class="kt">void</span> <span class="n">set_exception</span><span class="p">(</span><span class="n">Error</span> <span class="n">exception</span><span class="p">)</span> <span class="o">&amp;&amp;</span><span class="p">;</span>
  <span class="kt">bool</span> <span class="nf">valid</span><span class="p">()</span> <span class="k">const</span><span class="p">;</span>
<span class="p">};</span>
</pre>
   <p>In the following sections, we describe some of the key aspects of our proposed
design.</p>
   <h3 class="heading settled" data-level="1.1" id="intro_execution_model"><span class="secno">1.1. </span><span class="content">The Future/Promise Execution Model</span><a class="self-link" href="#intro_execution_model"></a></h3>
   <p>In the Concurrency TS v1, it is unspecified where a <code class="highlight"><span class="p">.</span><span class="n">then</span></code> continuation will be run.
There are a number of possible answers:</p>
   <ul>
    <li data-md="">
     <p>Consumer Side: The consumer execution agent always executes the continuation. <code class="highlight"><span class="p">.</span><span class="n">then</span></code> blocks until the producer execution agent signals readiness.</p>
    <li data-md="">
     <p>Producer Side: The producer execution agent always executes the continuation. <code class="highlight"><span class="p">.</span><span class="n">set_value</span></code> blocks until the consumer execution agent signals readiness.</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">inline_executor</span></code> Semantics: If the shared state is ready when the
continuation is set, the consumer thread executes the continuation. If the
shared state is not ready when the continuation is set, the producer thread
executes the continuation.</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">thread_executor</span></code> Semantics: A new <code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">thread</span></code> executes the
continuation.</p>
   </ul>
   <p>This is a source of trouble (<a data-link-type="biblio" href="#biblio-p0701r0">[P0701r0]</a> and <a data-link-type="biblio" href="#biblio-p0701r1">[P0701r1]</a>).
The first two answers are undesirable, as they would require blocking, which is
  not ideal for an asynchronous interface.
The third and fourth are likewise distasteful, as they can be vague or
inefficient (respectively).</p>
   <p>Executors, finally, give us at least a partial solution to this problem.
The question changes to "where do we enqueue work into the executor"?
The answer: work is always enqueued on the consumer side as if, but not
  necessarily, via <code class="highlight"><span class="n">then_execute</span></code>.
You can query executor properties to determine whether or not the executor’s
  APIs will block, which tells you whether or not continuation <a data-link-type="dfn" href="#attachment" id="ref-for-attachment">attachment</a> (consumer side) or future <a data-link-type="dfn" href="#fulfillment" id="ref-for-fulfillment">fulfillment</a> (producer side) potentially blocks
  pending execution (e.g. <code class="highlight"><span class="n">inline_executor</span></code> semantics).</p>
   <h3 class="heading settled" data-level="1.2" id="intro_executors"><span class="secno">1.2. </span><span class="content">Interactions with Executors</span><a class="self-link" href="#intro_executors"></a></h3>
   <p><a href="https://github.com/executors/executors">The executors proposal</a> defines a collection of executor types intended
for use managing the execution of tasks on resources.
There are three fundamental executor categories that cover directionality and
control of launch:</p>
   <ul>
    <li data-md="">
     <p>one-way</p>
    <li data-md="">
     <p>two-way</p>
    <li data-md="">
     <p>then</p>
   </ul>
   <p>The first two could be considered <em>immediately launched</em>. That is that once
handed to the executor, they may start immediately, assuming the internal
executor policies and resources allow it. This makes them very useful for
lazy-launch scenarios.</p>
   <p>Lazy launch scenarios are common in callback-based code, and in a wide range of
future library implementations such as <a href="https://github.com/STEllAR-GROUP/hpx">HPX</a> and <a href="https://github.com/facebook/folly/tree/master/folly/futures">folly</a>.
In these designs, a callback is executed on completion of some asynchronous
work, and that callback enqueues work into the executor.
This means that work is enqueued only after all dependencies are satisfied.</p>
   <p>Then-executors, on the other hand, are intended for explicitly deferred work.
Work can be handed to the executor dependent on prior work, before that prior
work is completed.
This design is fundamentally different, but offers scope for optimization by
the executor of chains of dependencies that it can batch, without running
additional code on completion of each.</p>
   <p>The current executor design is intentionally generic - it makes few requirements
on the future types it can use as input dependencies for the <code class="highlight"><span class="n">then_execute</span></code> and <code class="highlight"><span class="n">bulk_then_execute</span></code> operations.
We can assume that for a future returned by a previous call to <code class="highlight"><span class="n">then_execute</span></code> or <code class="highlight"><span class="n">bulk_then_execute</span></code>, the executor understands the implementation of the
future can can perform whatever dependence tracking and optimization necessary.
This then is an implementation detail.</p>
   <p>However, there will also be interactions where a task to run on one executor is dependent on one produced by another. For this to be practical, we need a standardised mechanism to tie the two executors together.
This amounts to a standard API for triggering deferred work.</p>
   <p>To solve this we provide two things:</p>
   <ul>
    <li data-md="">
     <p>A promise concept, that allows setting of value and/or exception.</p>
    <li data-md="">
     <p>A mechanism to retrieve from an executor a pair of a promise and a future, such that the future is a valid input dependence for a call to <code class="highlight"><span class="n">then_execute</span></code> or <code class="highlight"><span class="n">bulk_then_execute</span></code>.</p>
   </ul>
   <p>The promise is a write-only concept. This simplifies the definition and improves flexibility.</p>
   <p>The future is not a full future in the sense of future concepts. It is merely a token that completes when the promise is satisfied. This means that it is useful only for connecting to <code class="highlight"><span class="n">then_execute</span></code> or <code class="highlight"><span class="n">bulk_then_execute</span></code> on the executor that provided the result.</p>
   <h3 class="heading settled" data-level="1.3" id="intro_exception_model"><span class="secno">1.3. </span><span class="content">The Exception Handling Model</span><a class="self-link" href="#intro_exception_model"></a></h3>
   <p>Our proposal moves away from future continuations that take futures as an
  argument, the design used in the Concurrency TS v1.
Instead, continuations take the value type of the future.
This, however, requires a new exception handling model.
Both the executors proposal and this paper adopt the same model, where users
  can provide callable objects with both a value type and an optional tag
  disambiguated exception handling overload.</p>
   <p>In the example below, let <code class="highlight"><span class="n">f</span></code> and <code class="highlight"><span class="n">g</span></code> be <code class="highlight"><span class="n">ContinuableFuture</span></code>s and let <code class="highlight"><span class="n">c</span></code> be a <code class="highlight"><span class="n">FutureContinuation</span></code>.</p>
<pre class="highlight"><span class="n">g</span> <span class="o">=</span> <span class="n">f</span><span class="p">.</span><span class="n">then</span><span class="p">(</span><span class="n">c</span><span class="p">);</span>
</pre>
   <p>When <code class="highlight"><span class="n">f</span></code> is fulfilled:</p>
   <ul>
    <li data-md="">
     <p>If <code class="highlight"><span class="n">f</span></code> has a value <code class="highlight"><span class="n">val</span></code>:</p>
    <li data-md="">
     <p>If <code class="highlight"><span class="n">c</span><span class="p">(</span><span class="n">val</span><span class="p">)</span></code> is well-formed, it is called and the future <code class="highlight"><span class="n">g</span></code> is fulfilled with the result or any exception thrown from the evaluation.</p>
    <li data-md="">
     <p>Otherwise, the future <code class="highlight"><span class="n">g</span></code> is fulfilled with the value <code class="highlight"><span class="n">val</span></code> (this is known as <dfn data-dfn-type="dfn" data-noexport="" id="future-value-propagation">future value propagation<a class="self-link" href="#future-value-propagation"></a></dfn> - see <a data-link-type="biblio" href="#biblio-p0701r0">[P0701r0]</a> and <a data-link-type="biblio" href="#biblio-p0701r1">[P0701r1]</a>).</p>
    <li data-md="">
     <p>If <code class="highlight"><span class="n">f</span></code> fails with exception <code class="highlight"><span class="n">exc</span></code>:</p>
    <li data-md="">
     <p>If <code class="highlight"><span class="n">c</span><span class="p">(</span><span class="n">exception_arg</span><span class="p">,</span> <span class="n">exc</span><span class="p">)</span></code> is well-formed, it is called and the future <code class="highlight"><span class="n">g</span></code> is fulfilled with the result or any exception thrown from the evaluation.</p>
    <li data-md="">
     <p>Otherwise, the future <code class="highlight"><span class="n">g</span></code> is fulfilled with the exception <code class="highlight"><span class="n">exc</span></code> (this is known as <dfn data-dfn-type="dfn" data-noexport="" id="future-exception-propagation">future exception propagation<a class="self-link" href="#future-exception-propagation"></a></dfn> - see <a data-link-type="biblio" href="#biblio-p0701r0">[P0701r0]</a> and <a data-link-type="biblio" href="#biblio-p0701r1">[P0701r1]</a>).</p>
   </ul>
   <p>Note that if both overloads are defined, <code class="highlight"><span class="k">decltype</span><span class="p">(</span><span class="n">G</span><span class="p">(</span><span class="n">exception_arg</span><span class="p">,</span> <span class="n">err</span><span class="p">))</span></code> shall be convertible to <code class="highlight"><span class="k">decltype</span><span class="p">(</span><span class="n">G</span><span class="p">(</span><span class="n">val</span><span class="p">))</span></code>.</p>
   <p>This paper defines some helper types which can be used to build callable
  arguments that meet the <code class="highlight"><span class="n">FutureContinuation</span></code> arguments.
For example, <code class="highlight"><span class="n">on_value_or_error</span><span class="p">(</span><span class="n">f</span><span class="p">,</span> <span class="n">g</span><span class="p">)</span></code> takes two callables (a on-value
  continuation and on-error continuation) and returns a single <code class="highlight"><span class="n">FutureContinuation</span></code> object composed from the two.</p>
   <h3 class="heading settled" data-level="1.4" id="intro_cancellation"><span class="secno">1.4. </span><span class="content">The Future Cancellation Model</span><a class="self-link" href="#intro_cancellation"></a></h3>
   <p>This paper proposes a way to hook a <a data-link-type="dfn" href="#cancellation-notifier" id="ref-for-cancellation-notifier">cancellation notifier</a> into a future/promise pair, using <code class="highlight"><span class="n">cancellable_promise_contract_t</span></code>.
It allows for authors of future types to support cancellation if they want to, and to correctly hook into the cancellation mechanisms
of other futures they interoperate with - such as inside <code class="highlight"><span class="p">.</span><span class="n">via</span></code>, where the implementation can create a future/promise pair that will,
on cancellation, invoke a function that will cancel the current future.</p>
   <p>A sample implementation of <code class="highlight"><span class="p">.</span><span class="n">via</span></code> could be as follows:</p>
<pre class="highlight"><span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">Executor</span><span class="o">></span>
<span class="k">auto</span> <span class="n">via</span><span class="p">(</span><span class="n">Executor</span> <span class="o">&amp;&amp;</span> <span class="n">ex</span><span class="p">)</span> <span class="o">&amp;&amp;</span>
<span class="p">{</span>
    <span class="k">auto</span> <span class="n">cancel</span> <span class="o">=</span> <span class="p">[</span><span class="k">this</span><span class="p">]</span> <span class="p">{</span> <span class="n">handle_cancellation</span><span class="p">();</span> <span class="p">};</span>
    <span class="k">auto</span> <span class="p">[</span><span class="n">promise</span><span class="p">,</span> <span class="n">future</span><span class="p">]</span> <span class="o">=</span> <span class="n">execution</span><span class="o">::</span><span class="n">query</span><span class="p">(</span><span class="n">ex</span><span class="p">,</span> <span class="n">cancellable_promise_contract_t</span><span class="p">{</span> <span class="n">cancel</span> <span class="p">});</span>
    <span class="n">then</span><span class="p">([</span><span class="n">promise</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="n">promise</span><span class="p">)](</span><span class="k">auto</span> <span class="n">value</span><span class="p">)</span> <span class="p">{</span> <span class="n">promise</span><span class="p">.</span><span class="n">set_value</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">value</span><span class="p">));</span> <span class="p">});</span>
    <span class="k">return</span> <span class="n">future</span><span class="p">;</span>
<span class="p">}</span>
</pre>
   <p>We are currently not proposing a concrete cancellation API; we plan to do that in a future revision of the paper. At this time, there is
no guarantee that a future honors a <a data-link-type="dfn" href="#cancellation-notifier" id="ref-for-cancellation-notifier①">cancellation notifier</a>, and no requirements as to when it actually invokes it.</p>
   <h3 class="heading settled" data-level="1.5" id="intro_semi_future_via"><span class="secno">1.5. </span><span class="content"><code class="highlight"><span class="n">SemiFuture</span></code> and <code class="highlight"><span class="p">.</span><span class="n">via</span></code> For Composition</span><a class="self-link" href="#intro_semi_future_via"></a></h3>
   <p>The <code class="highlight"><span class="n">SemiFuture</span></code> concept and <code class="highlight"><span class="p">.</span><span class="n">via</span></code> mechanism (<a data-link-type="biblio" href="#biblio-p0783r0">[P0783r0]</a> and <a data-link-type="biblio" href="#biblio-p0904r0">[P0904r0]</a>)  gives
  us control of the transfer of execution ownership between executors and a way
  to convert between different future types.</p>
   <p>One problem that arises in the <a href="https://github.com/executors/executors">executor model</a> is how
  a <a data-link-type="dfn" href="#future" id="ref-for-future">future</a>-returning interface can dictate the executor that callers attach
  continuations to.</p>
   <p><code class="highlight"><span class="n">SemiFuture</span></code> and <code class="highlight"><span class="p">.</span><span class="n">via</span></code> is mechanism that allows the caller to control the
  executor that subsequent chaining operations use.
An interface may return a handle to its work, a future in the most abstract sense,
  that does not provide a means to chain more work.
This future will complete on whatever executor that interface was using.
This returned future satisfies the <code class="highlight"><span class="n">SemiFuture</span></code> concept, and the caller is hence
  aware that to make use of it they must attach an executor, using <code class="highlight"><span class="p">.</span><span class="n">via</span></code>, to
  transition from the interface’s executor to the caller’s executor.
From that point on, the caller can use the future as necessary, safely enqueuing
  work onto a known executor, and protecting the interface from misuse.</p>
   <p>Additionally, since <code class="highlight"><span class="n">ContinuableFuture</span></code> and <code class="highlight"><span class="n">SharedFuture</span></code>s are also <code class="highlight"><span class="n">SemiFuture</span></code>s, <code class="highlight"><span class="p">.</span><span class="n">via</span></code> provides a way to convert (if possible) from one future type
  (associated with a particular executor type) to another "foreign" future type
  (associated with another executor type).</p>
   <p>As a simple example:</p>
<pre class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">execution</span><span class="o">::</span><span class="n">semi_future</span><span class="o">&lt;</span><span class="n">DataType</span><span class="o">></span> <span class="n">async_api</span><span class="p">()</span> <span class="p">{</span>
  <span class="n">std</span><span class="o">::</span><span class="n">execution</span><span class="o">::</span><span class="n">continuable_future</span><span class="o">&lt;</span><span class="n">APIExecutor</span><span class="p">,</span> <span class="n">SerializedDataType</span><span class="o">></span> <span class="o">=</span>
    <span class="n">doAsyncWork</span><span class="p">();</span>
  <span class="k">return</span> <span class="n">std</span><span class="o">::</span><span class="n">move</span><span class="p">(</span><span class="n">f</span><span class="p">).</span><span class="n">then</span><span class="p">(</span>
    <span class="p">[](</span><span class="n">SerializedDataType</span><span class="o">&amp;&amp;</span> <span class="n">val</span><span class="p">){</span> <span class="k">return</span> <span class="n">deserialize</span><span class="p">(</span><span class="n">val</span><span class="p">);</span> <span class="p">});</span>
<span class="p">}</span>

<span class="kt">void</span> <span class="n">caller</span><span class="p">()</span> <span class="p">{</span>
  <span class="n">LocalExecutor</span> <span class="n">e</span><span class="p">;</span>
  <span class="k">auto</span> <span class="n">sf</span> <span class="o">=</span> <span class="n">async_api</span><span class="p">();</span>
  <span class="k">auto</span> <span class="n">f</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="n">sf</span><span class="p">).</span><span class="n">via</span><span class="p">(</span><span class="n">e</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">f</span><span class="p">).</span><span class="n">then</span><span class="p">([](</span><span class="n">DataType</span><span class="o">&amp;&amp;</span> <span class="n">data</span><span class="p">)</span> <span class="p">{</span>
    <span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">"Name: "</span> <span class="o">&lt;&lt;</span> <span class="n">data</span><span class="p">.</span><span class="n">name</span><span class="p">()</span> <span class="o">&lt;&lt;</span> <span class="s">"</span><span class="se">\n</span><span class="s">"</span><span class="p">;</span>
  <span class="p">});</span>
<span class="p">}</span>
</pre>
   <p>There is a strict separation of control here between <code class="highlight"><span class="n">caller</span></code> and <code class="highlight"><span class="n">async_api</span></code>.</p>
   <h3 class="heading settled" data-level="1.6" id="intro_rvalue_ref"><span class="secno">1.6. </span><span class="content">Consuming Interfaces Are Rvalue Reference Qualified</span><a class="self-link" href="#intro_rvalue_ref"></a></h3>
   <p>In a change to the model used in <code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">future</span></code>, where <code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">future</span><span class="o">::</span><span class="n">get</span><span class="p">()</span></code> is a
consuming operation but is l-value qualified, consuming operations in this
proposal are r-value qualified.</p>
   <p>For free functions this should be obvious. If we had a free function <code class="highlight"><span class="n">future_then</span></code> that takes a future and returns a value, we will likely r-value
qualify it:</p>
<pre class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">future</span><span class="o">&lt;</span><span class="n">T2</span><span class="o">></span> <span class="n">future_then</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">future</span><span class="o">&lt;</span><span class="n">T</span><span class="o">>&amp;&amp;</span> <span class="n">f</span><span class="p">,</span> <span class="n">continuation</span><span class="o">&amp;&amp;</span> <span class="n">c</span><span class="p">);</span>
</pre>
   <p>For consistent and safe use, the same should apply to the equivalent builtin
methods.</p>
   <p>In chaining code, this falls out cleanly:</p>
<pre class="highlight"><span class="k">auto</span> <span class="n">f2</span> <span class="o">=</span> <span class="n">do_async_thing</span><span class="p">().</span><span class="n">then</span><span class="p">([](</span><span class="n">T</span> <span class="n">val</span><span class="p">){</span><span class="k">return</span> <span class="n">val</span><span class="p">;}).</span><span class="n">then</span><span class="p">([](</span><span class="n">T2</span> <span class="n">val</span><span class="p">){</span><span class="k">return</span> <span class="n">val</span><span class="p">;});</span>
</pre>
   <p>Occasionally we must be explicit:</p>
<pre class="highlight"><span class="k">auto</span> <span class="n">f</span> <span class="o">=</span> <span class="n">do_async_thing</span><span class="p">();</span>
<span class="k">auto</span> <span class="n">f2</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="n">f</span><span class="p">).</span><span class="n">then</span><span class="p">([](</span><span class="n">T</span> <span class="n">val</span><span class="p">){</span><span class="k">return</span> <span class="n">val</span><span class="p">;}).</span><span class="n">then</span><span class="p">([](</span><span class="n">T2</span> <span class="n">val</span><span class="p">){</span><span class="k">return</span> <span class="n">val</span><span class="p">;});</span>
</pre>
   <p>but this is a minor inconvenience given that it allows the tooling to warn on
use-after-move and related misuses.</p>
   <h3 class="heading settled" data-level="1.7" id="intro_blocking"><span class="secno">1.7. </span><span class="content">Blocking Interfaces (<code class="highlight"><span class="p">.</span><span class="n">get</span></code> and <code class="highlight"><span class="p">.</span><span class="n">wait</span></code>)</span><a class="self-link" href="#intro_blocking"></a></h3>
   <p>The future concepts in this paper are intended to express the minimal requirements for executors interoperation and composition.
Executors do not require a blocking interface, and futures do not require a blocking interface to compose.
This paper proposes the addition of the free functions <code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">this_thread</span><span class="o">::</span><span class="n">future_wait</span></code> and <code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">this_thread</span><span class="o">::</span><span class="n">future_get</span></code>.
These functions will block on any <code class="highlight"><span class="n">SemiFuture</span></code> type, and are suitable for use within <code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">thread</span></code> execution agents.
Some individuals may feel that blocking interfaces are more fundamental for futures than continuation chaining interfaces - some may desire to not provide continuation chaining interfaces at all.
We believe that this is a perfectly valid design; however, such non-continuable futures are outside of the scope of this work.</p>
   <ul>
    <li data-md="">
     <p>If you want to write a future that only has blocking interfaces and doesn’t support continuations, that’s fine! But that type of future cannot interoperate with executors.</p>
    <li data-md="">
     <p>If you want to write a future that only doesn’t have blocking interfaces and does support continuations, that’s fine! That type of future can interoperate with executors, so you should conform to the proposed concepts.</p>
    <li data-md="">
     <p>If you want to write a future that has blocking interfaces and supports continuations, that’s fine! That type of future can interoperate with executors, so you should conform to the proposed concepts.</p>
   </ul>
   <p><a data-link-type="biblio" href="#biblio-p0701r0">[P0701r0]</a> and <a data-link-type="biblio" href="#biblio-p0701r1">[P0701r1]</a> discuss some of the challenges relating to future/promise synchronization that motivated the current design.</p>
   <h3 class="heading settled" data-level="1.8" id="intro_future_work"><span class="secno">1.8. </span><span class="content">Future Work</span><a class="self-link" href="#intro_future_work"></a></h3>
   <p>There is plenty of future work on futures to be done.
Here is a list of topics that are currently on our agenda:</p>
   <ul>
    <li data-md="">
     <p>Forward progress guarantees for futures and promises.</p>
    <li data-md="">
     <p>Requirements on synchronization for use of futures and promises from non-concurrent execution agents.</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">future</span></code>/<code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">promise</span></code> interoperability.</p>
    <li data-md="">
     <p>Future unwrapping, both <code class="highlight"><span class="n">future</span><span class="o">&lt;</span><span class="n">future</span><span class="o">&lt;</span><span class="n">T</span><span class="o">>></span></code> and more advanced forms.</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">when_all</span></code>/<code class="highlight"><span class="n">when_any</span></code>/<code class="highlight"><span class="n">when_n</span></code>.</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">async</span></code>.</p>
   </ul>
   <h3 class="heading settled" data-level="1.9" id="intro_prior_work"><span class="secno">1.9. </span><span class="content">Prior Work</span><a class="self-link" href="#intro_prior_work"></a></h3>
   <p>This work is unification of prior papers written individually by the authors:</p>
   <ul>
    <li data-md="">
     <p><a data-link-type="biblio" href="#biblio-p0701r0">[P0701r0]</a></p>
    <li data-md="">
     <p><a data-link-type="biblio" href="#biblio-p0701r1">[P0701r1]</a></p>
    <li data-md="">
     <p><a data-link-type="biblio" href="#biblio-p0783r0">[P0783r0]</a></p>
    <li data-md="">
     <p><a data-link-type="biblio" href="#biblio-p0904r0">[P0904r0]</a></p>
   </ul>
   <h2 class="heading settled" data-level="2" id="wording"><span class="secno">2. </span><span class="content">Proposed New Wording</span><a class="self-link" href="#wording"></a></h2>
   <p>The following wording is purely additive to <a href="https://github.com/executors/executors">the executors proposal</a>.</p>
   <h3 class="heading settled" data-level="2.1" id="wording_execution_model"><span class="secno">2.1. </span><span class="content">The Future/Promise Execution Model</span><a class="self-link" href="#wording_execution_model"></a></h3>
   <ol>
    <li data-md="">
     <p>A <dfn class="dfn-paneled" data-dfn-type="dfn" data-noexport="" id="future">future</dfn> is an object that executes, on a executor, <dfn class="dfn-paneled" data-dfn-type="dfn" data-noexport="" id="continuations">continuations</dfn> that are passed an <a data-link-type="dfn" href="#asynchronous-result" id="ref-for-asynchronous-result">asynchronous result</a> as a parameter.</p>
   </ol>
   <ul>
    <li data-md="">
     <p>A <dfn class="dfn-paneled" data-dfn-type="dfn" data-noexport="" id="uniquely-owned-future">uniquely owned future</dfn> moves from the <a data-link-type="dfn" href="#asynchronous-result" id="ref-for-asynchronous-result①">asynchronous result</a> and can have at most one <a data-link-type="dfn" href="#continuations" id="ref-for-continuations">continuation</a> attached.</p>
    <li data-md="">
     <p>A <dfn class="dfn-paneled" data-dfn-type="dfn" data-noexport="" id="non-uniquely-owned-future">non-uniquely owned future</dfn> copies from the <a data-link-type="dfn" href="#asynchronous-result" id="ref-for-asynchronous-result②">asynchronous result</a> and can have one or more <a data-link-type="dfn" href="#continuations" id="ref-for-continuations①">continuations</a> attached.</p>
   </ul>
   <ol start="2">
    <li data-md="">
     <p>A <dfn class="dfn-paneled" data-dfn-type="dfn" data-noexport="" id="promise">promise</dfn> is an object that produces an <a data-link-type="dfn" href="#asynchronous-result" id="ref-for-asynchronous-result③">asynchronous result</a> and is associated with a <a data-link-type="dfn" href="#future" id="ref-for-future①">future</a>. [ <em>Note:</em> Although a <a data-link-type="dfn" href="#promise" id="ref-for-promise">promise</a> is associated with one <a data-link-type="dfn" href="#future" id="ref-for-future②">future</a>,
multiple <a data-link-type="dfn" href="#shared-future" id="ref-for-shared-future">shared future</a> objects may refer to the same underlying <a data-link-type="dfn" href="#shared-future" id="ref-for-shared-future①">shared future</a>. - <em>end note</em> ]</p>
    <li data-md="">
     <p>The <dfn class="dfn-paneled" data-dfn-type="dfn" data-noexport="" id="status">status</dfn> of a <a data-link-type="dfn" href="#future" id="ref-for-future③">future</a>:</p>
   </ol>
   <ul>
    <li data-md="">
     <p>Is either <dfn class="dfn-paneled" data-dfn-type="dfn" data-noexport="" id="ready">ready</dfn>, <dfn class="dfn-paneled" data-dfn-type="dfn" data-noexport="" id="not-ready">not ready</dfn>, or <dfn class="dfn-paneled" data-dfn-type="dfn" data-noexport="" id="invalid">invalid</dfn>.</p>
    <li data-md="">
     <p>Shall be <a data-link-type="dfn" href="#ready" id="ref-for-ready">ready</a> if and only if the <a data-link-type="dfn" href="#future" id="ref-for-future④">future</a> holds a value or an exception ready for retrieval.</p>
   </ul>
   <ol start="4">
    <li data-md="">
     <p>An <dfn class="dfn-paneled" data-dfn-type="dfn" data-noexport="" id="asynchronous-result">asynchronous result</dfn> is either a value or an exception. The result is created by the <a data-link-type="dfn" href="#promise" id="ref-for-promise①">promise</a> and accessed by the <a data-link-type="dfn" href="#future" id="ref-for-future⑤">future</a>.</p>
    <li data-md="">
     <p>A <a data-link-type="dfn" href="#future" id="ref-for-future⑥">future</a> may optionally have a <dfn class="dfn-paneled" data-dfn-type="dfn" data-noexport="" id="cancellation-notifier">cancellation notifier</dfn>, which is a nullary <a href="eel.is/c++draft/func.def">callable object</a>.</p>
    <li data-md="">
     <p>When a <a data-link-type="dfn" href="#future" id="ref-for-future⑦">future</a> is <dfn class="dfn-paneled" data-dfn-type="dfn" data-lt="cancellation|cancel|cancels|cancelled" data-noexport="" id="cancellation">cancelled</dfn>:</p>
   </ol>
   <ul>
    <li data-md="">
     <p>If the <a data-link-type="dfn" href="#future" id="ref-for-future⑧">future</a> has a <a data-link-type="dfn" href="#cancellation-notifier" id="ref-for-cancellation-notifier②">cancellation notifier</a>, it is called in the calling thread.</p>
    <li data-md="">
     <p>Then, the <a data-link-type="dfn" href="#future" id="ref-for-future⑨">future’s</a> status is set to <a data-link-type="dfn" href="#invalid" id="ref-for-invalid">invalid</a>.</p>
   </ul>
   <ol start="7">
    <li data-md="">
     <p>When a <a data-link-type="dfn" href="#continuations" id="ref-for-continuations②">continuation</a> is <dfn class="dfn-paneled" data-dfn-type="dfn" data-lt="attachment|attach|attaches|attached" data-noexport="" id="attachment">attached</dfn> to a <a data-link-type="dfn" href="#future" id="ref-for-future①⓪">future</a>:</p>
   </ol>
   <ul>
    <li data-md="">
     <p>First, the <a data-link-type="dfn" href="#status" id="ref-for-status">status</a> of its <a data-link-type="dfn" href="#future" id="ref-for-future①①">future</a> is checked.</p>
    <li data-md="">
     <p>Then,</p>
     <ul>
      <li data-md="">
       <p>If the <a data-link-type="dfn" href="#status" id="ref-for-status①">status</a> is <a data-link-type="dfn" href="#ready" id="ref-for-ready①">ready</a> or <a data-link-type="dfn" href="#not-ready" id="ref-for-not-ready">not ready</a>:</p>
       <ul>
        <li data-md="">
         <p>The <a data-link-type="dfn" href="#continuations" id="ref-for-continuations③">continuation</a> is enqueued for execution pending readiness of <a data-link-type="dfn" href="#future" id="ref-for-future①②">future</a> on the <a data-link-type="dfn" href="#future" id="ref-for-future①③">future’s</a> executor, with the <a data-link-type="dfn" href="#asynchronous-result" id="ref-for-asynchronous-result④">asynchronous result</a> as its parameter.</p>
        <li data-md="">
         <p>Finally, if the <a data-link-type="dfn" href="#future" id="ref-for-future①④">future</a> is a <a data-link-type="dfn" href="#uniquely-owned-future" id="ref-for-uniquely-owned-future">uniquely owned future</a>, the status is set to <a data-link-type="dfn" href="#invalid" id="ref-for-invalid①">invalid</a>.</p>
       </ul>
      <li data-md="">
       <p>If the <a data-link-type="dfn" href="#status" id="ref-for-status②">status</a> is <a data-link-type="dfn" href="#invalid" id="ref-for-invalid②">invalid</a>, the behavior is unspecified.</p>
     </ul>
   </ul>
   <ol start="8">
    <li data-md="">
     <p>When a <a data-link-type="dfn" href="#promise" id="ref-for-promise②">promise</a> <dfn class="dfn-paneled" data-dfn-type="dfn" data-lt="fulfillment|fulfill|fulfills|fulfilled" data-noexport="" id="fulfillment">fulfills</dfn> its associated <a data-link-type="dfn" href="#future" id="ref-for-future①⑤">future</a> with a value or error, if the lifetime of the <a data-link-type="dfn" href="#future" id="ref-for-future①⑥">future</a> has not ended:</p>
   </ol>
   <ul>
    <li data-md="">
     <p>First, the <a data-link-type="dfn" href="#status" id="ref-for-status③">status</a> of its <a data-link-type="dfn" href="#future" id="ref-for-future①⑦">future</a> is checked.</p>
    <li data-md="">
     <p>Then,</p>
     <ul>
      <li data-md="">
       <p>If the <a data-link-type="dfn" href="#status" id="ref-for-status④">status</a> is <a data-link-type="dfn" href="#not-ready" id="ref-for-not-ready①">not ready</a>:</p>
       <ul>
        <li data-md="">
         <p>The <a data-link-type="dfn" href="#status" id="ref-for-status⑤">status</a> is set to <a data-link-type="dfn" href="#ready" id="ref-for-ready②">ready</a></p>
        <li data-md="">
         <p>Finally, any execution agents that are blocking until the <a data-link-type="dfn" href="#status" id="ref-for-status⑥">status</a> is <a data-link-type="dfn" href="#ready" id="ref-for-ready③">ready</a> are unblocked.</p>
       </ul>
      <li data-md="">
       <p>If the <a data-link-type="dfn" href="#status" id="ref-for-status⑦">status</a> is <a data-link-type="dfn" href="#ready" id="ref-for-ready④">ready</a> or <a data-link-type="dfn" href="#invalid" id="ref-for-invalid③">invalid</a>, the behavior is unspecified.</p>
     </ul>
     <p>If the lifetime of the <a data-link-type="dfn" href="#future" id="ref-for-future①⑧">future</a> has ended, <a data-link-type="dfn" href="#fulfillment" id="ref-for-fulfillment①">fulfillment</a> has no effect.</p>
   </ul>
   <ol start="9">
    <li data-md="">
     <p><a data-link-type="dfn" href="#fulfillment" id="ref-for-fulfillment②">Fulfillment</a> of a <a data-link-type="dfn" href="#future" id="ref-for-future①⑨">future</a> <a href="http://eel.is/c++draft/intro.races#def:synchronize_with">synchronizes with</a> execution of <a data-link-type="dfn" href="#continuations" id="ref-for-continuations④">continuations</a> that were enqueued for execution by that <a data-link-type="dfn" href="#future" id="ref-for-future②⓪">future</a>.</p>
    <li data-md="">
     <p>The lifetime of the <a data-link-type="dfn" href="#continuations" id="ref-for-continuations⑤">continuations</a> and the <a data-link-type="dfn" href="#asynchronous-result" id="ref-for-asynchronous-result⑤">asynchronous result</a> passed to the <a data-link-type="dfn" href="#continuations" id="ref-for-continuations⑥">continuations</a> shall last until execution of the <a data-link-type="dfn" href="#continuations" id="ref-for-continuations⑦">continuations</a> completes.
  [ <em>Note:</em> The <a data-link-type="dfn" href="#future" id="ref-for-future②①">future</a> may move (if it is a <a data-link-type="dfn" href="#uniquely-owned-future" id="ref-for-uniquely-owned-future①">uniquely owned future</a>) or copy (if it is a <a data-link-type="dfn" href="#non-uniquely-owned-future" id="ref-for-non-uniquely-owned-future">non-uniquely owned future</a>) from the result into a new object to ensure this behavior. - <em>End Note</em> ]
  [ <em>Note:</em> The <a data-link-type="dfn" href="#future" id="ref-for-future②②">future</a> may move from <a data-link-type="dfn" href="#continuations" id="ref-for-continuations⑧">continuations</a> into new object to ensure this behavior. - <em>End Note</em> ]</p>
    <li data-md="">
     <p>The lifetime of the <a data-link-type="dfn" href="#continuations" id="ref-for-continuations⑨">continuations</a> and the <a data-link-type="dfn" href="#asynchronous-result" id="ref-for-asynchronous-result⑥">asynchronous result</a> passed to the <a data-link-type="dfn" href="#continuations" id="ref-for-continuations①⓪">continuations</a> shall last until execution of the <a data-link-type="dfn" href="#continuations" id="ref-for-continuations①①">continuations</a> completes.
  [ <em>Note:</em> The <a data-link-type="dfn" href="#promise" id="ref-for-promise③">promise</a> may move or copy (if the result is <code class="highlight"><span class="n">CopyConstructible</span></code>) from the result into a new object to ensure this behavior. - <em>End Note</em> ]
  [ <em>Note:</em> The <a data-link-type="dfn" href="#promise" id="ref-for-promise④">promise</a> may move from continuations into new object to ensure this behavior. - <em>End Note</em> ]</p>
    <li data-md="">
     <p>Upon destruction of a <a data-link-type="dfn" href="#promise" id="ref-for-promise⑤">promise</a>:</p>
   </ol>
   <ul>
    <li data-md="">
     <p>First, the <a data-link-type="dfn" href="#promise" id="ref-for-promise⑥">promise</a> checks the <a data-link-type="dfn" href="#status" id="ref-for-status⑧">status</a> of its <a data-link-type="dfn" href="#future" id="ref-for-future②③">future</a>.</p>
    <li data-md="">
     <p>Then, if the <a data-link-type="dfn" href="#status" id="ref-for-status⑨">status</a> is <a data-link-type="dfn" href="#not-ready" id="ref-for-not-ready②">not ready</a>, the <a data-link-type="dfn" href="#promise" id="ref-for-promise⑦">promise</a> shall be <a data-link-type="dfn" href="#fulfillment" id="ref-for-fulfillment③">fulfilled</a>.</p>
   </ul>
   <ol start="13">
    <li data-md="">
     <p>Setting the <a data-link-type="dfn" href="#status" id="ref-for-status①⓪">status</a> of a <a data-link-type="dfn" href="#future" id="ref-for-future②④">future</a> <a href="http://eel.is/c++draft/intro.races#def:synchronize_with">synchronizes with</a> operations that check the <a data-link-type="dfn" href="#future" id="ref-for-future②⑤">future</a>'s status.</p>
    <li data-md="">
     <p>Operations that modify the set of continuations stored in a <a data-link-type="dfn" href="#future" id="ref-for-future②⑥">future</a> <a href="http://eel.is/c++draft/intro.races#def:synchronize_with">synchronize with</a> each other.</p>
    <li data-md="">
     <p>Successful <a data-link-type="dfn" href="#fulfillment" id="ref-for-fulfillment④">fulfillment</a> of a <a data-link-type="dfn" href="#future" id="ref-for-future②⑦">future</a> <a href="http://eel.is/c++draft/intro.races#def:synchronize_with">synchronizes with</a> <a data-link-type="dfn" href="#attachment" id="ref-for-attachment①">attachment</a> of <a data-link-type="dfn" href="#continuations" id="ref-for-continuations①②">continuations</a> to that future.</p>
    <li data-md="">
     <p>Successful <a data-link-type="dfn" href="#attachment" id="ref-for-attachment②">attachment</a> of a <a data-link-type="dfn" href="#continuations" id="ref-for-continuations①③">continuation</a> to a <a data-link-type="dfn" href="#future" id="ref-for-future②⑧">future</a> <a href="http://eel.is/c++draft/intro.races#def:synchronize_with">synchronizes with</a> <a data-link-type="dfn" href="#fulfillment" id="ref-for-fulfillment⑤">fulfillment</a> of the promise associated with that <a data-link-type="dfn" href="#future" id="ref-for-future②⑨">future</a>.</p>
    <li data-md="">
     <p>If a <a data-link-type="dfn" href="#future" id="ref-for-future③⓪">future</a> has a <a data-link-type="dfn" href="#cancellation-notifier" id="ref-for-cancellation-notifier③">cancellation notifier</a>, successful <a data-link-type="dfn" href="#fulfillment" id="ref-for-fulfillment⑥">fulfillment</a> of it’s associated <a data-link-type="dfn" href="#promise" id="ref-for-promise⑧">promise</a> <a href="http://eel.is/c++draft/intro.races#def:synchronize_with">synchronizes with</a> <a data-link-type="dfn" href="#cancellation" id="ref-for-cancellation">cancellation</a> of the <a data-link-type="dfn" href="#future" id="ref-for-future③①">future</a>.</p>
   </ol>
   <h3 class="heading settled" data-level="2.2" id="wording_future_continuation"><span class="secno">2.2. </span><span class="content"><code class="highlight"><span class="n">FutureContinuation</span></code> Requirements</span><a class="self-link" href="#wording_future_continuation"></a></h3>
<pre class="highlight"><span class="k">namespace</span> <span class="n">std</span><span class="o">::</span><span class="n">execution</span> <span class="p">{</span>

<span class="k">struct</span> <span class="n">exception_arg_t</span> <span class="p">{</span> <span class="k">explicit</span> <span class="n">exception_arg_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="k">constexpr</span> <span class="n">exception_arg_t</span> <span class="n">exception_arg</span><span class="p">{};</span>

<span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">F</span><span class="p">,</span> <span class="k">typename</span> <span class="n">T</span><span class="o">></span>
  <span class="k">struct</span> <span class="n">is_future_value_continuation</span><span class="p">;</span>

<span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">F</span><span class="p">,</span> <span class="k">typename</span> <span class="n">T</span><span class="o">></span>
  <span class="kr">inline</span> <span class="k">constexpr</span> <span class="kt">bool</span> <span class="n">is_future_value_continuation_v</span>
    <span class="o">=</span> <span class="n">is_future_value_continuation</span><span class="o">&lt;</span><span class="n">F</span><span class="p">,</span> <span class="n">T</span><span class="o">>::</span><span class="n">value</span><span class="p">;</span>

<span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">F</span><span class="o">></span>
  <span class="k">struct</span> <span class="n">is_future_exception_continuation</span><span class="p">;</span>

<span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">F</span><span class="o">></span>
  <span class="kr">inline</span> <span class="k">constexpr</span> <span class="kt">bool</span> <span class="n">is_future_exception_continuation_v</span>
    <span class="o">=</span> <span class="n">is_future_exception_continuation</span><span class="o">&lt;</span><span class="n">F</span><span class="o">>::</span><span class="n">value</span><span class="p">;</span>

<span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">F</span><span class="p">,</span> <span class="k">typename</span> <span class="n">T</span><span class="o">></span>
  <span class="k">struct</span> <span class="n">is_future_continuation</span><span class="p">;</span>

<span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">F</span><span class="p">,</span> <span class="k">typename</span> <span class="n">T</span><span class="o">></span>
  <span class="kr">inline</span> <span class="k">constexpr</span> <span class="kt">bool</span> <span class="n">is_future_continuation_v</span>
    <span class="o">=</span> <span class="n">is_future_continuation</span><span class="o">&lt;</span><span class="n">F</span><span class="p">,</span> <span class="n">T</span><span class="o">>::</span><span class="n">value</span><span class="p">;</span>

<span class="p">}</span>
</pre>
   <ol>
    <li data-md="">
     <p>A <dfn class="dfn-paneled" data-dfn-type="dfn" data-noexport="" id="future-continuation">future continuation</dfn> is a <a href="eel.is/c++draft/func.def">callable object</a> that consumes the value of a <a data-link-type="dfn" href="#future" id="ref-for-future③②">future</a>.</p>
    <li data-md="">
     <p>The struct <code class="highlight"><span class="n">exception_arg_t</span></code> is an empty structure type used as a unique type to disambiguate <code class="highlight"><span class="n">FutureContinuation</span></code> overloads that are called when a <a data-link-type="dfn" href="#future" id="ref-for-future③③">future</a> holds an exception from <code class="highlight"><span class="n">FutureContinuation</span></code> overloads that are called when a <a data-link-type="dfn" href="#future" id="ref-for-future③④">future</a> holds a value.</p>
    <li data-md="">
     <p>This sub-clause contains templates that may be used to determine at compile time whether a type meets the requirements of <a data-link-type="dfn" href="#future-continuation" id="ref-for-future-continuation">future continuations</a> for a particular <a data-link-type="dfn" href="#future" id="ref-for-future③⑤">future</a> value type. Each of these templates is a <a href="http://eel.is/c++draft/meta.rqmts#def:BinaryTypeTraith"><code class="highlight"><span class="n">BinaryTypeTrait</span></code></a> with a base characteristic of <code class="highlight"><span class="n">true_type</span></code> if the corresponding condition is true, and <code class="highlight"><span class="n">false_type</span></code> otherwise.</p>
    <li data-md="">
     <p>A <code class="highlight"><span class="n">FutureContinuation</span></code> type shall meet the <code class="highlight"><span class="n">MoveConstructible</span></code> requirements and the requirements described in the Tables below.</p>
   </ol>
   <center>
    <p><strong>Type Property Queries</strong></p>
    <table border="1">
     <tbody>
      <tr>
       <th>Template
       <th>Condition
       <th>Preconditions
      <tr>
       <td>
<pre class="highlight"><span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">F</span><span class="p">,</span> <span class="k">typename</span> <span class="n">T</span><span class="o">></span>
<span class="k">struct</span> <span class="n">is_future_value_continuation</span><span class="p">;</span>
</pre>
       <td><code class="highlight"><span class="n">is_move_constructible_v</span><span class="o">&lt;</span><span class="n">F</span><span class="o">></span> <span class="o">&amp;&amp;</span> <span class="n">is_invocable_v</span><span class="o">&lt;</span><span class="n">F</span><span class="p">,</span> <span class="n">T</span><span class="o">></span></code>
       <td><code class="highlight"><span class="n">T</span></code> is a complete type.
      <tr>
       <td>
<pre class="highlight"><span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">F</span><span class="o">></span>
<span class="k">struct</span> <span class="n">is_future_exception_continuation</span><span class="p">;</span>
</pre>
       <td><code class="highlight"><span class="n">is_move_constructible_v</span><span class="o">&lt;</span><span class="n">F</span><span class="o">></span> <span class="o">&amp;&amp;</span> <span class="n">is_invocable_v</span><span class="o">&lt;</span><span class="n">F</span><span class="p">,</span> <span class="n">exception_arg_t</span><span class="p">,</span> <span class="n">exception_ptr</span><span class="o">></span></code>
       <td><code class="highlight"><span class="n">T</span></code> is a complete type.
      <tr>
       <td>
<pre class="highlight"><span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">F</span><span class="p">,</span> <span class="k">typename</span> <span class="n">T</span><span class="o">></span>
<span class="k">struct</span> <span class="n">is_future_continuation</span><span class="p">;</span>
</pre>
       <td><code class="highlight"><span class="n">is_future_value_continuation_v</span><span class="o">&lt;</span><span class="n">F</span><span class="p">,</span> <span class="n">T</span><span class="o">></span> <span class="o">||</span> <span class="n">is_future_exception_continuation_v</span><span class="o">&lt;</span><span class="n">F</span><span class="o">></span></code>
       <td><code class="highlight"><span class="n">T</span></code> is a complete type.
    </table>
   </center>
   <h3 class="heading settled" data-level="2.3" id="wording_promise"><span class="secno">2.3. </span><span class="content"><code class="highlight"><span class="n">Promise</span></code> Requirements</span><a class="self-link" href="#wording_promise"></a></h3>
   <p>#. A <code class="highlight"><span class="n">Promise</span></code> type for value type <code class="highlight"><span class="n">T</span></code> and error type <code class="highlight"><span class="n">E</span></code> shall meet the <code class="highlight"><span class="n">MoveConstructible</span></code> requirements, the <code class="highlight"><span class="n">MoveAssignable</span></code> requirements, and the requirements described in the Tables below.</p>
   <p>Descriptive Variable Definitions</p>
   <table border="1">
    <tbody>
     <tr>
      <th>Variable
      <th>Definition
     <tr>
      <td><code class="highlight"><span class="n">T</span></code>
      <td>
        Either: 
       <ul>
        <li data-md="">
         <p>Any (possibly cv-qualified) object type that is not an array, or</p>
        <li data-md="">
         <p>(possibly cv-qualified) <code class="highlight"><span class="kt">void</span></code>.</p>
       </ul>
     <tr>
      <td>t
      <td>a value of a type contextually convertible to <code class="highlight"><span class="n">T</span></code>
     <tr>
      <td><code class="highlight"><span class="n">e</span></code>
      <td>a value of type contextually convertible to <code class="highlight"><span class="n">exception_ptr</span></code>
     <tr>
      <td><code class="highlight"><span class="n">P</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span></code>
      <td>A <a data-link-type="dfn" href="#promise" id="ref-for-promise⑨">promise</a> type for value type <code class="highlight"><span class="n">T</span></code>
     <tr>
      <td><code class="highlight"><span class="n">p</span></code>
      <td>An rvalue of type <code class="highlight"><span class="n">P</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span></code>
   </table>
   <p><br></p>
   <table>
    <tbody>
     <tr>
      <th>Expression
      <th>Return Type
      <th>Operational semantics
     <tr>
      <td><code class="highlight"><span class="n">promise_value_t</span><span class="o">&lt;</span><span class="n">P</span><span class="o">&lt;</span><span class="n">T</span><span class="o">>></span></code>
      <td><code class="highlight"><span class="n">T</span></code>
      <td>
     <tr>
      <td><code class="highlight"><span class="n">p</span><span class="p">.</span><span class="n">set_value</span><span class="p">(</span><span class="n">t</span><span class="p">)</span></code>
      <td><code class="highlight"><span class="kt">void</span></code>
      <td>
       <ul>
        <li data-md="">
         <p><em>Requires:</em> <code class="highlight"><span class="o">!</span><span class="n">is_void_v</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span></code></p>
        <li data-md="">
         <p><em>Effects:</em> Completes the promise and associated future with <code class="highlight"><span class="n">t</span></code>.</p>
       </ul>
     <tr>
      <td><code class="highlight"><span class="n">p</span><span class="p">.</span><span class="n">set_value</span><span class="p">()</span></code>
      <td><code class="highlight"><span class="kt">void</span></code>
      <td>
       <ul>
        <li data-md="">
         <p><em>Requires:</em> <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></p>
        <li data-md="">
         <p><em>Effects:</em> Completes the promise and associated future.</p>
       </ul>
     <tr>
      <td><code class="highlight"><span class="n">p</span><span class="p">.</span><span class="n">set_exception</span><span class="p">(</span><span class="n">e</span><span class="p">)</span></code>
      <td><code class="highlight"><span class="kt">void</span></code>
      <td>Completes the promise and associated future with the error <code class="highlight"><span class="n">e</span></code>.
     <tr>
      <td> <code class="highlight"><span class="n">p</span><span class="p">.</span><span class="n">valid</span><span class="p">()</span></code> 
      <td>Contextually convertible to <code class="highlight"><span class="kt">bool</span></code>.
      <td><code class="highlight">true</code> if the promise has an associated future that is incomplete, <code class="highlight">false</code> otherwise.
   </table>
   <h4 class="heading settled" data-level="2.3.1" id="wording_promise_contracts"><span class="secno">2.3.1. </span><span class="content">Promise Contract Executor Properties</span><a class="self-link" href="#wording_promise_contracts"></a></h4>
<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="o">></span>
<span class="k">struct</span> <span class="n">promise_contract_t</span>
<span class="p">{</span>
  <span class="k">static</span> <span class="n">constexpr</span> <span class="kt">bool</span> <span class="n">is_requirable</span> <span class="o">=</span> false<span class="p">;</span>
  <span class="k">static</span> <span class="n">constexpr</span> <span class="kt">bool</span> <span class="n">is_preferable</span> <span class="o">=</span> false<span class="p">;</span>

  <span class="n">using</span> <span class="n">polymorphic_query_result_type</span>
    <span class="o">=</span> <span class="n">std</span><span class="o">::</span><span class="n">pair</span><span class="o">&lt;</span><span class="n">std</span><span class="o">::</span><span class="n">execution</span><span class="o">::</span><span class="n">promise</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">execution</span><span class="o">::</span><span class="n">semi_future</span><span class="o">&lt;</span><span class="n">T</span><span class="o">>></span><span class="p">;</span>
<span class="p">};</span>

<span class="n">template</span> <span class="o">&lt;</span><span class="kr">typename</span> <span class="n">T</span><span class="o">></span>
<span class="kr">inline</span> <span class="n">constexpr</span> <span class="n">promise_contract</span> <span class="o">=</span> <span class="n">promise_contract_t</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span><span class="p">{};</span>
</pre>
   <p>The <code class="highlight"><span class="n">promise_contract_t</span></code> property can be used only with query.</p>
   <p>The result of a query of the <code class="highlight"><span class="n">promise_contract_t</span></code> property applied to a <code class="highlight"><span class="n">ThenExecutor</span></code> or <code class="highlight"><span class="n">BulkThenExecutor</span></code> is a <code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">pair</span></code> consisting of a <code class="highlight"><span class="n">Promise</span></code> and an implementation-defined token type that will be interpreted as a valid
input future by calls to <code class="highlight"><span class="n">then_execute</span></code> or <code class="highlight"><span class="n">bulk_then_execute</span></code> and that is
satisfied by calling <code class="highlight"><span class="n">set_value</span></code> or <code class="highlight"><span class="n">set_exception</span></code> on the promise.</p>
   <p>The value returned from <code class="highlight"><span class="n">execution</span><span class="o">::</span><span class="n">query</span><span class="p">(</span><span class="n">e</span><span class="p">,</span> <span class="n">promise_contract_t</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span><span class="p">)</span></code>, where <code class="highlight"><span class="n">e</span></code> is an executor and <code class="highlight"><span class="n">T</span></code> is a type, should be unique for any given call.
When <code class="highlight"><span class="n">e</span></code> is a <code class="highlight"><span class="n">ThenExecutor</span></code> or <code class="highlight"><span class="n">BulkThenExecutor</span></code> the result of the query is a <code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">pair</span></code> where first value is an instance of a type matching the <code class="highlight"><span class="n">Promise</span></code> requirements and the second is a token type that <code class="highlight"><span class="n">e</span></code> will interpret as a valid
future parameter to calls to <code class="highlight"><span class="n">then_execute</span></code> or <code class="highlight"><span class="n">bulk_then_execute</span></code>.</p>
<pre class="highlight"><span class="k">template</span> <span class="o">&lt;</span><span class="n">T</span><span class="p">,</span> <span class="n">C</span><span class="o">></span>
<span class="k">struct</span> <span class="n">cancellable_promise_contract_t</span>
<span class="p">{</span>
  <span class="k">static</span> <span class="k">constexpr</span> <span class="kt">bool</span> <span class="n">is_requirable</span> <span class="o">=</span> false<span class="p">;</span>
  <span class="k">static</span> <span class="k">constexpr</span> <span class="kt">bool</span> <span class="n">is_preferable</span> <span class="o">=</span> false<span class="p">;</span>

  <span class="k">using</span> <span class="n">polymorphic_query_result_type</span>
    <span class="o">=</span> <span class="n">std</span><span class="o">::</span><span class="n">pair</span><span class="o">&lt;</span><span class="n">std</span><span class="o">::</span><span class="n">execution</span><span class="o">::</span><span class="n">promise</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">execution</span><span class="o">::</span><span class="n">semi_future</span><span class="o">&lt;</span><span class="n">T</span><span class="o">>></span><span class="p">;</span>

  <span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">Executor</span><span class="o">></span>
  <span class="k">static</span> <span class="k">constexpr</span> <span class="k">decltype</span><span class="p">(</span><span class="k">auto</span><span class="p">)</span> <span class="n">static_query_v</span>
    <span class="o">=</span> <span class="n">Executor</span><span class="o">::</span><span class="n">query</span><span class="p">(</span><span class="n">promise_contract_t</span><span class="p">());</span>

  <span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">Executor</span><span class="o">></span>
    <span class="k">friend</span> <span class="n">std</span><span class="o">::</span><span class="n">pair</span><span class="o">&lt;</span><span class="n">std</span><span class="o">::</span><span class="n">execution</span><span class="o">::</span><span class="n">promise</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">execution</span><span class="o">::</span><span class="n">semi_future</span><span class="o">&lt;</span><span class="n">T</span><span class="o">>></span>
      <span class="n">query</span><span class="p">(</span><span class="k">const</span> <span class="n">Executor</span><span class="o">&amp;</span> <span class="n">ex</span><span class="p">,</span> <span class="k">const</span> <span class="n">cancellable_promise_contract_t</span><span class="o">&amp;</span><span class="p">);</span>

  <span class="n">CancellationNotifier</span> <span class="n">cancellation_notifier</span><span class="p">;</span>
<span class="p">};</span>
</pre>
   <p>The <code class="highlight"><span class="n">cancellable_promise_contract_t</span></code> property can be used only with query. <code class="highlight"><span class="n">cancellable_promise_contract_t</span></code> differs from <code class="highlight"><span class="n">promise_contract_t</span></code> in that the
query carries a cancellation callback, <code class="highlight"><span class="n">cancellation_notifier</span></code>, that will be
called as <code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">invoke</span><span class="p">(</span><span class="n">cancellation_notifier</span><span class="p">)</span></code> by the <code class="highlight"><span class="n">ThenExecutor</span></code> on
cancellation of the task dependent on the future resulting from the <code class="highlight"><span class="n">cancellable_promise_contract_t</span></code> query.</p>
   <p>The result of a query of the <code class="highlight"><span class="n">cancellable_promise_contract_t</span></code> property applied
to a <code class="highlight"><span class="n">ThenExecutor</span></code> or <code class="highlight"><span class="n">BulkThenExecutor</span></code> is a <code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">pair</span></code> consisting of a <code class="highlight"><span class="n">Promise</span></code> and an implementation-defined token type that will be interpreted as
a valid input future by calls to <code class="highlight"><span class="n">then_execute</span></code> or <code class="highlight"><span class="n">bulk_then_execute</span></code>, that
is satisfied by calling <code class="highlight"><span class="n">set_value</span></code> or <code class="highlight"><span class="n">set_exception</span></code> on the promise and that
supports cancellation by the executor.</p>
   <p>The value returned from <code class="highlight"><span class="n">execution</span><span class="o">::</span><span class="n">query</span><span class="p">(</span><span class="n">e</span><span class="p">,</span> <span class="n">cancellable_promise_contract_t</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span><span class="p">{</span><span class="n">cancellation_notifier</span><span class="p">})</span></code>,
where <code class="highlight"><span class="n">e</span></code> is an executor and <code class="highlight"><span class="n">T</span></code> is a type, should be unique for any given call.
When <code class="highlight"><span class="n">e</span></code> is a <code class="highlight"><span class="n">ThenExecutor</span></code> or <code class="highlight"><span class="n">BulkThenExecutor</span></code> the result of the query is a <code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">pair</span></code> where first value is an instance of a type matching the <code class="highlight"><span class="n">Promise</span></code> requirements and the second is a token type that <code class="highlight"><span class="n">e</span></code> will interpret as a valid
future parameter to calls to <code class="highlight"><span class="n">then_execute</span></code> or <code class="highlight"><span class="n">bulk_then_execute</span></code>.</p>
<pre class="highlight"><span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">Executor</span><span class="o">></span>
  <span class="k">friend</span> <span class="n">std</span><span class="o">::</span><span class="n">pair</span><span class="o">&lt;</span><span class="n">std</span><span class="o">::</span><span class="n">execution</span><span class="o">::</span><span class="n">promise</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">execution</span><span class="o">::</span><span class="n">semi_future</span><span class="o">&lt;</span><span class="n">T</span><span class="o">>></span>
    <span class="n">query</span><span class="p">(</span><span class="k">const</span> <span class="n">Executor</span><span class="o">&amp;</span> <span class="n">ex</span><span class="p">,</span> <span class="k">const</span> <span class="n">cancellable_promise_contract_t</span><span class="o">&amp;</span><span class="p">);</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Returns:</em> A <code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">pair</span></code> where the first value is a <code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">execution</span><span class="o">::</span><span class="n">promise</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span></code> and the
  second is a <code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">execution</span><span class="o">::</span><span class="n">semi_future</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span></code> such that the future was retrieved
  from the promise.</p>
    <li data-md="">
     <p><em>Remarks:</em> This function shall not participate in overload resolution unless <code class="highlight"><span class="n">executor_future_t</span><span class="o">&lt;</span><span class="n">Executor</span><span class="p">,</span> <span class="n">T</span><span class="o">></span></code> is <code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">execution</span><span class="o">::</span><span class="n">semi_future</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span></code>.</p>
   </ul>
   <h3 class="heading settled" data-level="2.4" id="wording_semi_future"><span class="secno">2.4. </span><span class="content"><code class="highlight"><span class="n">SemiFuture</span></code> Requirements</span><a class="self-link" href="#wording_semi_future"></a></h3>
   <ol>
    <li data-md="">
     <p>A <dfn data-dfn-type="dfn" data-noexport="" id="semi-future">semi future<a class="self-link" href="#semi-future"></a></dfn> is an object that can be bound to an executor to produce a <a data-link-type="dfn" href="#future" id="ref-for-future③⑥">future</a>.</p>
    <li data-md="">
     <p>A <code class="highlight"><span class="n">SemiFuture</span></code> type for type <code class="highlight"><span class="n">T</span></code> shall meet the <code class="highlight"><span class="n">MoveConstructible</span></code> requirements, the <code class="highlight"><span class="n">MoveAssignable</span></code> requirements, and the requirements described in the Tables below.</p>
   </ol>
   <center>
    <p><strong>Descriptive Variable Definitions</strong></p>
    <table border="1">
     <tbody>
      <tr>
       <th>Variable
       <th>Definition
      <tr>
       <td><code class="highlight"><span class="n">T</span></code>
       <td>
         Either: 
        <ul>
         <li data-md="">
          <p>Any (possibly cv-qualified) object type that is not an array, or</p>
         <li data-md="">
          <p>(possibly cv-qualified) <code class="highlight"><span class="kt">void</span></code>.</p>
        </ul>
      <tr>
       <td><code class="highlight"><span class="n">SF</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span></code>
       <td>A <code class="highlight"><span class="n">SemiFuture</span></code> type for value type <code class="highlight"><span class="n">T</span></code>.
      <tr>
       <td><code class="highlight"><span class="n">sf</span></code>
       <td>An rvalue of type <code class="highlight"><span class="n">SF</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span></code>.
      <tr>
       <td><code class="highlight"><span class="n">E</span></code>
       <td>
         An executor type, either: 
        <ul>
         <li data-md="">
          <p>A <code class="highlight"><span class="n">ThenExecutor</span></code> such that <code class="highlight"><span class="n">execution</span><span class="o">::</span><span class="n">can_query_v</span><span class="o">&lt;</span><span class="n">E</span><span class="p">,</span> <span class="n">promise_contract_t</span><span class="o">&lt;</span><span class="n">T</span><span class="o">>></span> <span class="o">==</span> true</code>, or</p>
         <li data-md="">
          <p>A <code class="highlight"><span class="n">OneWayExecutor</span></code> otherwise.</p>
        </ul>
      <tr>
       <td><code class="highlight"><span class="n">e</span></code>
       <td>A value of type <code class="highlight"><span class="n">E</span></code>.
      <tr>
       <td><code class="highlight"><span class="n">CF</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>
       <td>
         A <code class="highlight"><span class="n">ContinuableFuture</span></code> type for value type <code class="highlight"><span class="n">T</span></code> and executor type <code class="highlight"><span class="n">E</span></code>, either: 
        <ul>
         <li data-md="">
          <p><code class="highlight"><span class="k">decltype</span><span class="p">(</span><span class="n">execution</span><span class="o">::</span><span class="n">query</span><span class="p">(</span><span class="n">e</span><span class="p">,</span> <span class="n">promise_contract_t</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span><span class="p">()).</span><span class="n">second</span><span class="p">)</span></code> if <code class="highlight"><span class="n">E</span></code> is a <code class="highlight"><span class="n">ThenExecutor</span></code> and <code class="highlight"><span class="n">execution</span><span class="o">::</span><span class="n">can_query_v</span><span class="o">&lt;</span><span class="n">E</span><span class="p">,</span> <span class="n">promise_contract_t</span><span class="o">&lt;</span><span class="n">T</span><span class="o">>></span> <span class="o">==</span> true</code>, or</p>
         <li data-md="">
          <p><code class="highlight"><span class="n">continuable_future</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> otherwise.</p>
        </ul>
    </table>
    <p><b><code class="highlight"><span class="n">SemiFuture</span></code> Requirements</b></p>
    <table border="1">
     <tbody>
      <tr>
       <th>Expression
       <th>Return Type
       <th>Operational Semantics
      <tr>
       <td><code class="highlight"><span class="n">future_value_t</span><span class="o">&lt;</span><span class="n">SF</span><span class="o">&lt;</span><span class="n">T</span><span class="o">>></span></code>
       <td><code class="highlight"><span class="n">T</span></code>
       <td>
      <tr>
       <td><code class="highlight"><span class="n">future_exception_t</span><span class="o">&lt;</span><span class="n">SF</span><span class="o">&lt;</span><span class="n">T</span><span class="o">>></span></code>
       <td>Implicitly convertible to <code class="highlight"><span class="n">exception_ptr</span></code>.
       <td>
      <tr>
       <td><code class="highlight"><span class="n">sf</span><span class="p">.</span><span class="n">via</span><span class="p">(</span><span class="n">e</span><span class="p">)</span></code>
       <td><em>implementation-defined</em>
       <td>
         <strong>Returns:</strong> A <code class="highlight"><span class="n">ContinuableFuture</span></code> for value type <code class="highlight"><span class="n">T</span></code> that is bound to the executor <code class="highlight"><span class="n">e</span></code> and will be made ready with the value or exception of <code class="highlight"><span class="n">sf</span></code> when <code class="highlight"><span class="n">sf</span></code> is made ready. 
        <p><strong>Throws:</strong> If <code class="highlight"><span class="o">!</span><span class="n">execution</span><span class="o">::</span><span class="n">query</span><span class="p">(</span><span class="n">e</span><span class="p">,</span> <span class="n">promise_contract_t</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span><span class="p">).</span><span class="n">second</span></code>, throws any exception thrown by <code class="highlight"><span class="o">!</span><span class="n">execution</span><span class="o">::</span><span class="n">query</span><span class="p">(</span><span class="n">e</span><span class="p">,</span> <span class="n">oneway_t</span><span class="p">)</span></code>.</p>
    </table>
   </center>
   <h3 class="heading settled" data-level="2.5" id="wording_continuable_future"><span class="secno">2.5. </span><span class="content"><code class="highlight"><span class="n">ContinuableFuture</span></code> Requirements</span><a class="self-link" href="#wording_continuable_future"></a></h3>
   <ol>
    <li data-md="">
     <p>A <dfn data-dfn-type="dfn" data-noexport="" id="continuable-future">continuable future<a class="self-link" href="#continuable-future"></a></dfn> is a <a data-link-type="dfn" href="#future" id="ref-for-future③⑦">future</a> that is bound to an executor and can have continuations attached to it.</p>
    <li data-md="">
     <p>A <code class="highlight"><span class="n">ContinuableFuture</span></code> shall meet the <code class="highlight"><span class="n">SemiFuture</span></code> requirements and the requirements described in the Tables below.</p>
   </ol>
   <center>
    <p><strong>Descriptive Variable Definitions</strong></p>
    <table border="1">
     <tbody>
      <tr>
       <th>Variable
       <th>Definition
      <tr>
       <td><code class="highlight"><span class="n">E</span></code>
       <td>An executor type.
      <tr>
       <td><code class="highlight"><span class="n">e</span></code>
       <td>A value of type <code class="highlight"><span class="n">E</span></code>.
      <tr>
       <td><code class="highlight"><span class="n">T</span></code>
       <td>
         Either: 
        <ul>
         <li data-md="">
          <p>Any (possibly cv-qualified) object type that is not an array, or</p>
         <li data-md="">
          <p>(possibly cv-qualified) <code class="highlight"><span class="kt">void</span></code>.</p>
        </ul>
      <tr>
       <td><code class="highlight"><span class="n">CF</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>
       <td>A <code class="highlight"><span class="n">ContinuableFuture</span></code> type for value type <code class="highlight"><span class="n">T</span></code> and executor type <code class="highlight"><span class="n">E</span></code>.
      <tr>
       <td><code class="highlight"><span class="n">cf</span></code>
       <td>A value of type <code class="highlight"><span class="n">CF</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>.
      <tr>
       <td><code class="highlight"><span class="n">rcf</span></code>
       <td>An rvalue of type <code class="highlight"><span class="n">CF</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>.
      <tr>
       <td><code class="highlight"><span class="n">val</span></code>
       <td>The value contained within the successfully completed future <code class="highlight"><span class="n">rcf</span></code>.
      <tr>
       <td><code class="highlight"><span class="n">ex</span></code>
       <td>The exception contained within the exceptionally completed future <code class="highlight"><span class="n">rcf</span></code>.
      <tr>
       <td><code class="highlight"><span class="n">G</span></code>
       <td>Any type such that <code class="highlight"><span class="n">is_future_continuation_v</span><span class="o">&lt;</span><span class="n">G</span><span class="p">,</span> <span class="n">T</span><span class="o">></span> <span class="o">==</span> true</code>.
      <tr>
       <td><code class="highlight"><span class="n">g</span></code>
       <td>An object of type <code class="highlight"><span class="n">G</span></code>.
      <tr>
       <td><code class="highlight"><span class="n">R</span></code> 
       <td>
         Either: 
        <ul>
         <li data-md="">
          <p>If <code class="highlight"><span class="n">is_same_v</span><span class="o">&lt;</span><span class="n">remove_cv_t</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span><span class="p">,</span> <span class="kt">void</span><span class="o">></span> <span class="o">==</span> true</code> and <code class="highlight"><span class="n">invoke</span><span class="p">(</span><span class="n">g</span><span class="p">)</span></code> is well formed, <code class="highlight"><span class="k">decltype</span><span class="p">(</span><span class="n">g</span><span class="p">())</span></code>.</p>
         <li data-md="">
          <p>If <code class="highlight"><span class="n">is_same_v</span><span class="o">&lt;</span><span class="n">remove_cv_t</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span><span class="p">,</span> <span class="kt">void</span><span class="o">></span> <span class="o">!=</span> true</code> and <code class="highlight"><span class="n">invoke</span><span class="p">(</span><span class="n">g</span><span class="p">,</span> <span class="n">val</span><span class="p">)</span></code> is well formed, <code class="highlight"><span class="k">decltype</span><span class="p">(</span><span class="n">g</span><span class="p">(</span><span class="n">val</span><span class="p">))</span></code>.</p>
         <li data-md="">
          <p>Otherwise, <code class="highlight"><span class="n">T</span></code>.</p>
        </ul>
      <tr>
       <td><code class="highlight"><span class="n">SF</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span></code>
       <td>A <code class="highlight"><span class="n">SemiFuture</span></code> type for value type <code class="highlight"><span class="n">T</span></code>.
      <tr>
       <td><code class="highlight"><span class="n">NORMAL</span></code>
       <td>
         Either: 
        <ul>
         <li data-md="">
          <p>If <code class="highlight"><span class="n">is_same_v</span><span class="o">&lt;</span><span class="n">remove_cv_t</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span><span class="p">,</span> <span class="kt">void</span><span class="o">></span> <span class="o">==</span> true</code>, <code class="highlight"><span class="n">DECAY_COPY</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">G</span><span class="o">></span><span class="p">(</span><span class="n">g</span><span class="p">))()</span></code>, and</p>
         <li data-md="">
          <p>Otherwise, <code class="highlight"><span class="n">DECAY_COPY</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">G</span><span class="o">></span><span class="p">(</span><span class="n">g</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">val</span><span class="p">))</span></code>.</p>
        </ul>
      <tr>
       <td><code class="highlight"><span class="n">EXCEPTIONAL</span></code>
       <td> The expression <code class="highlight"><span class="n">DECAY_COPY</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">G</span><span class="o">></span><span class="p">(</span><span class="n">g</span><span class="p">))(</span><span class="n">exception_arg</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">ex</span><span class="p">))</span></code>. 
    </table>
    <p><b><code class="highlight"><span class="n">ContinuableFuture</span></code> Requirements</b></p>
    <table border="1">
     <tbody>
      <tr>
       <th>Expression
       <th>Return Type
       <th>Operational Semantics
      <tr>
       <td><code class="highlight"><span class="n">cf</span><span class="p">.</span><span class="n">get_executor</span><span class="p">()</span></code>
       <td><code class="highlight"><span class="n">E</span></code>
       <td> <strong>Returns:</strong> The executor that the future is bound to. 
      <tr>
       <td><code class="highlight"><span class="n">rcf</span><span class="p">.</span><span class="n">then</span><span class="p">(</span><span class="n">g</span><span class="p">)</span></code>
       <td><code class="highlight"><span class="n">CF</span><span class="o">&lt;</span><span class="n">E</span><span class="p">,</span> <span class="n">R</span><span class="o">></span></code>
       <td>
         <strong>Returns:</strong> A <code class="highlight"><span class="n">ContinuableFuture</span></code> that is bound to the executor <code class="highlight"><span class="n">e</span></code> and
    that wraps the type returned by execution of either the value or exception
    operations implemented in the continuation. 
        <p><strong>Effects:</strong> When <code class="highlight"><span class="n">rcf</span></code> becomes nonexceptionally ready, and if <code class="highlight"><span class="n">NORMAL</span></code> is a
      well-formed expression, creates an execution agent which invokes <code class="highlight"><span class="n">NORMAL</span></code> at most once, with the call to <code class="highlight"><span class="n">DECAY_COPY</span></code> being evaluated in the thread
      that called <code class="highlight"><span class="p">.</span><span class="n">then</span></code>.</p>
        <p>Otherwise, when <code class="highlight"><span class="n">rcf</span></code> becomes exceptionally ready, if <code class="highlight"><span class="n">EXCEPTIONAL</span></code> is a
      well-formed expression, creates an execution agent which invokes <code class="highlight"><span class="n">EXCEPTIONAL</span></code> at most once, with the call to <code class="highlight"><span class="n">DECAY_COPY</span></code> being evaluated
      in the thread that called <code class="highlight"><span class="p">.</span><span class="n">then</span></code>.</p>
        <p>If <code class="highlight"><span class="n">NORMAL</span></code> and <code class="highlight"><span class="n">EXCEPTIONAL</span></code> are both well-formed expressions, <code class="highlight"><span class="k">decltype</span><span class="p">(</span><span class="n">EXCEPTIONAL</span><span class="p">)</span></code> shall be convertible to <code class="highlight"><span class="n">R</span></code>.</p>
        <p>If <code class="highlight"><span class="n">NORMAL</span></code> is not a well-formed expression and <code class="highlight"><span class="n">EXCEPTIONAL</span></code> is a
      well-formed expression, <code class="highlight"><span class="k">decltype</span><span class="p">(</span><span class="n">EXCEPTIONAL</span><span class="p">)</span></code> shall be convertible to <code class="highlight"><span class="k">decltype</span><span class="p">(</span><span class="n">val</span><span class="p">)</span></code>.</p>
        <p>If neither <code class="highlight"><span class="n">NORMAL</span></code> nor <code class="highlight"><span class="n">EXCEPTIONAL</span></code> are well-formed expressions, the
      invocation of <code class="highlight"><span class="p">.</span><span class="n">then</span></code> shall be ill-formed.</p>
        <p>May block pending completion of <code class="highlight"><span class="n">NORMAL</span></code> or <code class="highlight"><span class="n">EXCEPTIONAL</span></code>.</p>
        <p>The invocation of <code class="highlight"><span class="p">.</span><span class="n">then</span></code> <a href="http://eel.is/c++draft/intro.races#def:synchronize_with">synchronizes with</a> (C++Std [intro.multithread]) the invocation of <code class="highlight"><span class="n">g</span></code>.</p>
        <p><a data-link-type="dfn" href="#fulfillment" id="ref-for-fulfillment⑦">Fulfills</a> the <code class="highlight"><span class="n">ContinuableFuture</span></code> with the result of the <code class="highlight"><span class="n">NORMAL</span></code> or <code class="highlight"><span class="n">EXCEPTIONAL</span></code> expression, or any exception thrown by either.
      Otherwise, <a data-link-type="dfn" href="#fulfillment" id="ref-for-fulfillment⑧">fulfills</a> the <code class="highlight"><span class="n">ContinuableFuture</span></code> with either <code class="highlight"><span class="n">val</span></code> or <code class="highlight"><span class="n">e</span></code>.</p>
        <p><strong>Synchronization:</strong> The destruction of the continuation that generates <code class="highlight"><span class="n">rcf</span></code>'s value <a href="http://eel.is/c++draft/intro.races#def:synchronize_with">synchronizes with</a> the invocation of <code class="highlight"><span class="n">g</span></code> and with the destruction
      of <code class="highlight"><span class="n">g</span></code>.</p>
    </table>
   </center>
   <h3 class="heading settled" data-level="2.6" id="wording_shared_future"><span class="secno">2.6. </span><span class="content"><code class="highlight"><span class="n">SharedFuture</span></code> Requirements</span><a class="self-link" href="#wording_shared_future"></a></h3>
   <ol>
    <li data-md="">
     <p>A <dfn class="dfn-paneled" data-dfn-type="dfn" data-noexport="" id="shared-future">shared future</dfn> is a <a data-link-type="dfn" href="#non-uniquely-owned-future" id="ref-for-non-uniquely-owned-future①">non-uniquely owned future</a> that is copyable, is bound to an executor and that allows one or more continuation to be attached to it.</p>
    <li data-md="">
     <p>A <code class="highlight"><span class="n">SharedFuture</span></code> shall meet the <code class="highlight"><span class="n">ContinuableFuture</span></code> requirements, the <code class="highlight"><span class="n">CopyConstructible</span></code> requirements, the <code class="highlight"><span class="n">CopyAssignable</span></code> requirements and the requirements described in the Tables below.</p>
   </ol>
   <center>
    <p><b>Descriptive Variable Definitions</b></p>
    <table border="1">
     <tbody>
      <tr>
       <th>Variable
       <th>Definition
      <tr>
       <td><code class="highlight"><span class="n">E</span></code>
       <td>An executor type.
      <tr>
       <td><code class="highlight"><span class="n">e</span></code>
       <td>A value of type <code class="highlight"><span class="n">E</span></code>.
      <tr>
       <td><code class="highlight"><span class="n">T</span></code>
       <td>Any (possibly cv-qualified) object type that is not an array.
      <tr>
       <td><code class="highlight"><span class="n">CF</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>
       <td>A <code class="highlight"><span class="n">ContinuableFuture</span></code> type for executor type <code class="highlight"><span class="n">E</span></code> and value type <code class="highlight"><span class="n">T</span></code>.
      <tr>
       <td><code class="highlight"><span class="n">SHF</span><span class="o">&lt;</span><span class="n">E</span><span class="p">,</span> <span class="n">T</span><span class="o">></span></code>
       <td>A <code class="highlight"><span class="n">SharedFuture</span></code> type for executor type <code class="highlight"><span class="n">E</span></code> and value type <code class="highlight"><span class="n">T</span></code>.
      <tr>
       <td><code class="highlight"><span class="n">shf</span></code>
       <td>A value of type <code class="highlight"><span class="n">SHF</span><span class="o">&lt;</span><span class="n">E</span><span class="p">,</span> <span class="n">T</span><span class="o">></span></code>.
      <tr>
       <td><code class="highlight"><span class="n">NORMAL</span></code>
       <td> The expression <code class="highlight"><span class="n">DECAY_COPY</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">G</span><span class="o">></span><span class="p">(</span><span class="n">g</span><span class="p">))(</span><span class="n">val</span><span class="p">)</span></code> if <code class="highlight"><span class="n">T</span></code> is non-void and <code class="highlight"><span class="n">DECAY_COPY</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">G</span><span class="o">></span><span class="p">(</span><span class="n">g</span><span class="p">))()</span></code> if <code class="highlight"><span class="n">T</span></code> is void. 
      <tr>
       <td><code class="highlight"><span class="n">EXCEPTIONAL</span></code>
       <td> The expression <code class="highlight"><span class="n">DECAY_COPY</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">G</span><span class="o">></span><span class="p">(</span><span class="n">g</span><span class="p">))(</span><span class="n">exception_arg</span><span class="p">,</span> <span class="n">ex</span><span class="p">)</span></code>, 
    </table>
    <p><b><code class="highlight"><span class="n">SharedFuture</span></code> Requirements</b></p>
    <table border="1">
     <tbody>
      <tr>
       <th>Expression
       <th>Return Type
       <th>Operational Semantics
      <tr>
       <td><code class="highlight"><span class="n">shf</span><span class="p">.</span><span class="n">then</span><span class="p">(</span><span class="n">g</span><span class="p">)</span></code>
       <td>
         <strong>If</strong> <code class="highlight"><span class="n">T</span></code> is non-void and <code class="highlight"><span class="n">INVOKE</span><span class="p">(</span><span class="n">declval</span><span class="o">&lt;</span><span class="n">G</span><span class="o">></span><span class="p">(),</span> <span class="n">declval</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span><span class="p">())</span></code> or if <code class="highlight"><span class="n">T</span></code> is <code class="highlight"><span class="kt">void</span></code> and <code class="highlight"><span class="n">INVOKE</span><span class="p">(</span><span class="n">declval</span><span class="o">&lt;</span><span class="n">G</span><span class="o">></span><span class="p">())</span></code> is well-formed: 
        <p><code class="highlight"><span class="n">CF</span><span class="o">&lt;</span><span class="n">E</span><span class="p">,</span> <span class="k">decltype</span><span class="p">(</span><span class="n">INVOKE</span><span class="p">(</span><span class="n">declval</span><span class="o">&lt;</span><span class="n">G</span><span class="o">></span><span class="p">(),</span> <span class="n">declval</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span><span class="p">()))</span><span class="o">></span></code></p>
        <p><strong>Otherwise</strong>:</p>
        <p><code class="highlight"><span class="n">CF</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></p>
       <td>
         <strong>Returns:</strong> A <code class="highlight"><span class="n">ContinuableFuture</span></code> that is bound to the executor <code class="highlight"><span class="n">e</span></code> and
    that wraps the type returned by execution of either the value or exception
    operations implemented in the continuation. 
        <p><strong>Effects:</strong> When <code class="highlight"><span class="n">shf</span></code> becomes nonexceptionally ready, and if <code class="highlight"><span class="n">NORMAL</span></code> is a
      well-formed expression, creates an execution agent which invokes <code class="highlight"><span class="n">NORMAL</span></code> at most once, with the call to <code class="highlight"><span class="n">DECAY_COPY</span></code> being evaluated in the thread
      that called <code class="highlight"><span class="p">.</span><span class="n">then</span></code>.</p>
        <p>Otherwise, when <code class="highlight"><span class="n">shf</span></code> becomes exceptionally ready, if <code class="highlight"><span class="n">EXCEPTIONAL</span></code> is a
      well-formed expression, creates an execution agent which invokes <code class="highlight"><span class="n">EXCEPTIONAL</span></code> at most once, with the call to <code class="highlight"><span class="n">DECAY_COPY</span></code> being evaluated
      in the thread that called <code class="highlight"><span class="p">.</span><span class="n">then</span></code>.</p>
        <p>If <code class="highlight"><span class="n">NORMAL</span></code> and <code class="highlight"><span class="n">EXCEPTIONAL</span></code> are both well-formed expressions, <code class="highlight"><span class="k">decltype</span><span class="p">(</span><span class="n">EXCEPTIONAL</span><span class="p">)</span></code> shall be convertible to <code class="highlight"><span class="n">R</span></code>.</p>
        <p>If <code class="highlight"><span class="n">NORMAL</span></code> is not a well-formed expression and <code class="highlight"><span class="n">EXCEPTIONAL</span></code> is a
      well-formed expression, <code class="highlight"><span class="k">decltype</span><span class="p">(</span><span class="n">EXCEPTIONAL</span><span class="p">)</span></code> shall be convertible to <code class="highlight"><span class="k">decltype</span><span class="p">(</span><span class="n">val</span><span class="p">)</span></code>.</p>
        <p>If neither <code class="highlight"><span class="n">NORMAL</span></code> nor <code class="highlight"><span class="n">EXCEPTIONAL</span></code> are well-formed expressions, the
      invocation of <code class="highlight"><span class="p">.</span><span class="n">then</span></code> shall be ill-formed.</p>
        <p>May block pending completion of <code class="highlight"><span class="n">NORMAL</span></code> or <code class="highlight"><span class="n">EXCEPTIONAL</span></code>.</p>
        <p>The invocation of <code class="highlight"><span class="p">.</span><span class="n">then</span></code> <a href="http://eel.is/c++draft/intro.races#def:synchronize_with">synchronizes with</a> (C++Std [intro.multithread]) the invocation of <code class="highlight"><span class="n">g</span></code>.</p>
        <p><a data-link-type="dfn" href="#fulfillment" id="ref-for-fulfillment⑨">Fulfills</a> the <code class="highlight"><span class="n">ContinuableFuture</span></code> with the result of the <code class="highlight"><span class="n">NORMAL</span></code> or <code class="highlight"><span class="n">EXCEPTIONAL</span></code> expression, or any exception thrown by either.
      Otherwise, <a data-link-type="dfn" href="#fulfillment" id="ref-for-fulfillment①⓪">fulfills</a> the <code class="highlight"><span class="n">ContinuableFuture</span></code> with either <code class="highlight"><span class="n">val</span></code> or <code class="highlight"><span class="n">e</span></code>.</p>
        <p><strong>Postconditions:</strong> Has no observable affect on <code class="highlight"><span class="n">sfh</span></code>.</p>
      <tr>
       <td><code class="highlight"><span class="n">shf</span><span class="p">.</span><span class="n">via</span><span class="p">(</span><span class="n">e</span><span class="p">)</span></code>
       <td>Implementation-defined
       <td>
         <strong>Returns:</strong> A <code class="highlight"><span class="n">ContinuableFuture</span></code> for type <code class="highlight"><span class="n">T</span></code> that is bound to the executor <code class="highlight"><span class="n">e</span></code>. 
        <p><strong>Effect:</strong> Returns an implementation-defined <code class="highlight"><span class="n">ContinuableFuture</span></code> onto which continuations can be attached that will run on <code class="highlight"><span class="n">e</span></code>.</p>
        <p><strong>Success:</strong> Succeeds if:</p>
        <ul>
         <li data-md="">
          <p><code class="highlight"><span class="n">e</span></code> is a <code class="highlight"><span class="n">ThenExecutor</span></code> where <code class="highlight"><span class="n">make_promise_contract</span><span class="p">(</span><span class="n">e</span><span class="p">)</span></code> is well-formed.</p>
         <li data-md="">
          <p><code class="highlight"><span class="n">e</span></code> is a <code class="highlight"><span class="n">OnewayExecutor</span></code> or is convertible to a OnewayExecutor.</p>
        </ul>
        <p>Fails at compile-time otherwise.</p>
        <p><strong>Postconditions:</strong> Has no observable affect on <code class="highlight"><span class="n">sfh</span></code>.</p>
    </table>
   </center>
   <h3 class="heading settled" data-level="2.7" id="wording_erasing_promise"><span class="secno">2.7. </span><span class="content"><code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">execution</span><span class="o">::</span><span class="n">promise</span></code></span><a class="self-link" href="#wording_erasing_promise"></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="o">></span>
<span class="n">class</span> <span class="n">promise</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">promise</span><span class="p">()</span> <span class="n">noexcept</span><span class="p">;</span>
    <span class="n">promise</span><span class="p">(</span><span class="n">promise</span><span class="o">&amp;&amp;</span><span class="p">)</span> <span class="n">noexcept</span><span class="p">;</span>
    <span class="n">template</span> <span class="o">&lt;</span><span class="kr">typename</span> <span class="n">Promise</span><span class="o">></span>
    <span class="n">explicit</span> <span class="n">promise</span><span class="p">(</span><span class="n">Promise</span><span class="o">&amp;&amp;</span> <span class="n">p</span><span class="p">);</span>

    <span class="kt">void</span> <span class="nf">set_value</span><span class="p">(</span><span class="cm">/* see below */</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="kr">typename</span> <span class="n">Error</span><span class="o">></span>
    <span class="kt">void</span> <span class="n">set_exception</span><span class="p">(</span><span class="n">Error</span><span class="o">&amp;&amp;</span> <span class="n">err</span><span class="p">)</span> <span class="o">&amp;&amp;</span><span class="p">;</span>

    <span class="kt">bool</span> <span class="nf">valid</span><span class="p">()</span> <span class="k">const</span> <span class="n">noexcept</span><span class="p">;</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="p">};</span>
</pre>
   <p>A <code class="highlight"><span class="n">promise</span></code> refers to a <a data-link-type="dfn" href="#promise" id="ref-for-promise①⓪">promise</a> and is associated with a <a data-link-type="dfn" href="#future" id="ref-for-future③⑧">future</a>, either through type-erasure or through construction of an underlying <a data-link-type="dfn" href="#promise" id="ref-for-promise①①">promise</a> with an overload of <code class="highlight"><span class="n">make_promise_contract</span><span class="p">()</span></code>.</p>
   <p><br></p>
<pre class="highlight"><span class="n">promise</span><span class="p">()</span> <span class="k">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Effects:</em> Constructs a <code class="highlight"><span class="n">promise</span></code> object that does not refer to a <a data-link-type="dfn" href="#promise" id="ref-for-promise①②">promise</a></p>
    <li data-md="">
     <p><em>Postconditions:</em></p>
     <ul>
      <li data-md="">
       <p><code class="highlight"><span class="n">valid</span><span class="p">()</span> <span class="o">==</span> false</code>.</p>
     </ul>
   </ul>
   <p><br></p>
<pre class="highlight"><span class="n">promise</span><span class="p">(</span><span class="n">promise</span><span class="o">&amp;&amp;</span> <span class="n">rhs</span><span class="p">)</span> <span class="k">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Effects:</em> Move constructs a <code class="highlight"><span class="n">promise</span></code> object from <code class="highlight"><span class="n">rhs</span></code> that refers
   to the same <a data-link-type="dfn" href="#promise" id="ref-for-promise①③">promise</a> and is associated with the same <a data-link-type="dfn" href="#future" id="ref-for-future③⑨">future</a> (if <code class="highlight"><span class="n">rhs</span></code> refers to a <a data-link-type="dfn" href="#promise" id="ref-for-promise①④">promise</a>).</p>
    <li data-md="">
     <p><em>Postconditions:</em></p>
     <ul>
      <li data-md="">
       <p><code class="highlight"><span class="n">valid</span><span class="p">()</span></code> returns the same value as <code class="highlight"><span class="n">rhs</span><span class="p">.</span><span class="n">valid</span><span class="p">()</span></code> prior to the constructor
invocation.</p>
      <li data-md="">
       <p><code class="highlight"><span class="n">rhs</span><span class="p">.</span><span class="n">valid</span><span class="p">()</span> <span class="o">==</span> false</code>.</p>
     </ul>
   </ul>
   <p><br></p>
<pre class="highlight"><span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">Promise</span><span class="o">></span>
<span class="n">promise</span><span class="p">(</span><span class="n">Promise</span><span class="o">&amp;&amp;</span> <span class="n">rhs</span><span class="p">)</span> <span class="k">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Requires:</em></p>
    <li data-md="">
     <p><code class="highlight"><span class="n">Promise</span></code> meets the requirements for <code class="highlight"><span class="n">Promise</span><span class="o">&lt;</span><span class="n">value_type</span><span class="o">></span></code></p>
    <li data-md="">
     <p><code class="highlight"><span class="o">!</span><span class="n">is_same_v</span><span class="o">&lt;</span><span class="n">decay_t</span><span class="o">&lt;</span><span class="n">Promise</span><span class="o">></span><span class="p">,</span> <span class="n">promise</span><span class="o">></span></code></p>
    <li data-md="">
     <p><code class="highlight"><span class="o">!</span><span class="n">is_reference_v</span><span class="o">&lt;</span><span class="n">Promise</span><span class="o">></span></code> <em>Note:</em> This constrains the parameter to be an rvalue reference rather than a forwarding reference <em>—end note</em>]</p>
    <li data-md="">
     <p><em>Effects:</em> Constructs a <code class="highlight"><span class="n">promise</span></code> object that refers to the <a data-link-type="dfn" href="#promise" id="ref-for-promise①⑤">promise</a> <code class="highlight"><span class="n">rhs</span></code> and is associated with the same <a data-link-type="dfn" href="#future" id="ref-for-future④⓪">future</a> as <code class="highlight"><span class="n">rhs</span></code>.
   (if <code class="highlight"><span class="n">rhs</span></code> is associated with a <a data-link-type="dfn" href="#future" id="ref-for-future④①">future</a>).</p>
    <li data-md="">
     <p><em>Postconditions:</em></p>
     <ul>
      <li data-md="">
       <p><code class="highlight"><span class="n">valid</span><span class="p">()</span></code> returns the same value as <code class="highlight"><span class="n">rhs</span><span class="p">.</span><span class="n">valid</span><span class="p">()</span></code> prior to the constructor
invocation.</p>
     </ul>
   </ul>
   <p><br></p>
<pre class="highlight"><span class="kt">void</span> <span class="n">promise</span><span class="o">::</span><span class="n">set_value</span><span class="p">(</span><span class="k">const</span> <span class="n">T</span><span class="o">&amp;</span> <span class="n">val</span><span class="p">)</span> <span class="o">&amp;&amp;</span><span class="p">;</span>
<span class="kt">void</span> <span class="n">promise</span><span class="o">::</span><span class="n">set_value</span><span class="p">(</span><span class="n">T</span><span class="o">&amp;&amp;</span> <span class="n">val</span><span class="p">)</span> <span class="o">&amp;&amp;</span><span class="p">;</span>
<span class="kt">void</span> <span class="n">promise</span><span class="o">&lt;</span><span class="kt">void</span><span class="o">>::</span><span class="n">set_value</span><span class="p">()</span> <span class="o">&amp;&amp;</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Effects:</em></p>
    <li data-md="">
     <p>If <code class="highlight"><span class="n">valid</span><span class="p">()</span> <span class="o">==</span> true</code>,</p>
     <ul>
      <li data-md="">
       <p>For <code class="highlight"><span class="n">promise</span><span class="o">::</span><span class="n">set_value</span><span class="p">(</span><span class="k">const</span> <span class="n">T</span><span class="o">&amp;</span> <span class="n">val</span><span class="p">)</span> <span class="o">&amp;&amp;</span></code>: equivalent to calling <code class="highlight"><span class="n">set_value</span><span class="p">(</span><span class="n">val</span><span class="p">)</span></code> on the <a data-link-type="dfn" href="#promise" id="ref-for-promise①⑥">promise</a> that <code class="highlight"><span class="o">*</span><span class="k">this</span></code> refers to.</p>
      <li data-md="">
       <p>For <code class="highlight"><span class="n">promise</span><span class="o">::</span><span class="n">set_value</span><span class="p">(</span><span class="n">T</span><span class="o">&amp;&amp;</span> <span class="n">val</span><span class="p">)</span> <span class="o">&amp;&amp;</span></code>: equivalent to calling <code class="highlight"><span class="n">set_value</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">val</span><span class="p">))</span></code> on the <a data-link-type="dfn" href="#promise" id="ref-for-promise①⑦">promise</a> that <code class="highlight"><span class="o">*</span><span class="k">this</span></code> refers to.</p>
      <li data-md="">
       <p>For <code class="highlight"><span class="n">promise</span><span class="o">&lt;</span><span class="kt">void</span><span class="o">>::</span><span class="n">set_value</span><span class="p">()</span> <span class="o">&amp;&amp;</span></code>: equivalent to calling <code class="highlight"><span class="n">set_value</span><span class="p">()</span></code> on the <a data-link-type="dfn" href="#promise" id="ref-for-promise①⑧">promise</a> that <code class="highlight"><span class="o">*</span><span class="k">this</span></code> refers to.</p>
     </ul>
    <li data-md="">
     <p>Otherwise, throws</p>
    <li data-md="">
     <p><em>Throws:</em> <code class="highlight"><span class="n">future_error</span></code> with error condition <code class="highlight"><span class="n">no_state</span></code> if <code class="highlight"><span class="n">valid</span><span class="p">()</span> <span class="o">==</span> false</code></p>
    <li data-md="">
     <p><em>Postconditions:</em></p>
    <li data-md="">
     <p><code class="highlight"><span class="n">valid</span><span class="p">()</span> <span class="o">==</span> false</code></p>
    <li data-md="">
     <p><em>Notes:</em> <code class="highlight"><span class="n">promise</span><span class="o">::</span><span class="n">set_value</span><span class="p">(</span><span class="k">const</span> <span class="n">T</span><span class="o">&amp;</span> <span class="n">val</span><span class="p">)</span> <span class="o">&amp;&amp;</span></code> does not participate in overload resolution unless <code class="highlight"><span class="n">is_copy_constructible_v</span><span class="o">&lt;</span><span class="n">decay_t</span><span class="o">&lt;</span><span class="n">T</span><span class="o">>></span></code></p>
   </ul>
   <p><br></p>
<pre class="highlight"><span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">Error</span><span class="o">></span>
<span class="kt">void</span> <span class="n">set_exception</span><span class="p">(</span><span class="n">Error</span><span class="o">&amp;&amp;</span> <span class="n">err</span><span class="p">)</span> <span class="o">&amp;&amp;</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Requires:</em></p>
    <li data-md="">
     <p><code class="highlight"><span class="n">Error</span></code> is contextually convertible to <code class="highlight"><span class="n">exception_ptr</span></code></p>
    <li data-md="">
     <p><em>Effects:</em></p>
    <li data-md="">
     <p>If <code class="highlight"><span class="n">valid</span><span class="p">()</span> <span class="o">==</span> true</code>, equivalent to calling <code class="highlight"><span class="n">set_exception</span><span class="p">(</span><span class="n">exception_ptr</span><span class="p">{</span><span class="n">forward</span><span class="o">&lt;</span><span class="n">Error</span><span class="o">></span><span class="p">(</span><span class="n">err</span><span class="p">)})</span></code> on the <a data-link-type="dfn" href="#promise" id="ref-for-promise①⑨">promise</a> that <code class="highlight"><span class="o">*</span><span class="k">this</span></code> refers to.</p>
    <li data-md="">
     <p>Otherwise, throws</p>
    <li data-md="">
     <p><em>Throws:</em> <code class="highlight"><span class="n">future_error</span></code> with error condition <code class="highlight"><span class="n">no_state</span></code> if <code class="highlight"><span class="n">valid</span><span class="p">()</span> <span class="o">==</span> false</code></p>
    <li data-md="">
     <p><em>Postconditions:</em></p>
    <li data-md="">
     <p><code class="highlight"><span class="n">valid</span><span class="p">()</span> <span class="o">==</span> false</code></p>
   </ul>
   <p><br></p>
<pre class="highlight"><span class="kt">bool</span> <span class="nf">valid</span><span class="p">()</span> <span class="k">const</span> <span class="k">noexcept</span><span class="p">;</span>
<span class="k">explicit</span> <span class="k">operator</span> <span class="nf">bool</span><span class="p">()</span> <span class="k">const</span> <span class="k">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Returns:</em> <code class="highlight">true</code> if <code class="highlight"><span class="o">*</span><span class="k">this</span></code> refers to a <a data-link-type="dfn" href="#promise" id="ref-for-promise②⓪">promise</a> and the referenced promise is <code class="highlight"><span class="n">valid</span><span class="p">()</span></code>, or <code class="highlight">false</code> otherwise</p>
   </ul>
   <h3 class="heading settled" data-level="2.8" id="wording_erasing_semi_future"><span class="secno">2.8. </span><span class="content"><code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">execution</span><span class="o">::</span><span class="n">semi_future</span></code></span><a class="self-link" href="#wording_erasing_semi_future"></a></h3>
<pre class="highlight"><span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">T</span><span class="o">></span>
<span class="k">class</span> <span class="nc">semi_future</span> <span class="p">{</span>
<span class="k">public</span><span class="o">:</span>
    <span class="k">using</span> <span class="n">value_type</span> <span class="o">=</span> <span class="n">T</span><span class="p">;</span>

    <span class="n">semi_future</span><span class="p">(</span><span class="n">semi_future</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">semi_future</span><span class="p">(</span><span class="k">const</span> <span class="n">semi_future</span><span class="o">&amp;</span><span class="p">)</span> <span class="o">=</span> <span class="k">delete</span><span class="p">;</span>

    <span class="n">semi_future</span><span class="o">&amp;</span> <span class="k">operator</span><span class="o">=</span><span class="p">(</span><span class="k">const</span> <span class="n">semi_future</span><span class="o">&amp;</span><span class="p">)</span> <span class="o">=</span> <span class="k">delete</span><span class="p">;</span>
    <span class="n">semi_future</span><span class="o">&amp;</span> <span class="k">operator</span><span class="o">=</span><span class="p">(</span><span class="n">semi_future</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="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">E</span><span class="o">></span>
    <span class="k">explicit</span> <span class="n">semi_future</span><span class="p">(</span><span class="n">continuable_future</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span> <span class="n">E</span><span class="o">>&amp;&amp;</span><span class="p">);</span>

    <span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">E</span><span class="o">></span>
    <span class="k">explicit</span> <span class="n">semi_future</span><span class="p">(</span><span class="n">shared_future</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span> <span class="n">E</span><span class="o">>&amp;&amp;</span><span class="p">);</span>

    <span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">EI</span><span class="o">></span>
    <span class="n">continuable_future</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span> <span class="n">EI</span><span class="o">></span> <span class="n">via</span><span class="p">(</span><span class="n">EI</span><span class="p">)</span> <span class="o">&amp;&amp;</span><span class="p">;</span>
<span class="p">};</span>
</pre>
   <p><br></p>
<pre class="highlight"><span class="n">continuable_future</span><span class="p">(</span><span class="n">semi_future</span><span class="o">&amp;&amp;</span> <span class="n">rhs</span><span class="p">);</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Effects:</em> Move constructs a future object from <code class="highlight"><span class="n">rhs</span></code> that refers to the
same <a data-link-type="dfn" href="#future" id="ref-for-future④②">future</a> and its associated with the same <a data-link-type="dfn" href="#promise" id="ref-for-promise②①">promise</a> (if <code class="highlight"><span class="n">rhs</span></code> refers to a <a data-link-type="dfn" href="#future" id="ref-for-future④③">future</a>).</p>
    <li data-md="">
     <p><em>Postconditions:</em></p>
     <ul>
      <li data-md="">
       <p>valid() returns the same value as rhs.valid() prior to the constructor
invocation.</p>
      <li data-md="">
       <p>rhs.valid() == false.</p>
     </ul>
   </ul>
   <p><br></p>
<pre class="highlight"><span class="n">semi_future</span><span class="p">(</span><span class="k">const</span> <span class="n">semi_future</span><span class="o">&amp;</span> <span class="n">rhs</span><span class="p">);</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Effects:</em> Copy constructs a future object from <code class="highlight"><span class="n">rhs</span></code> that refers to the
same <a data-link-type="dfn" href="#future" id="ref-for-future④④">future</a> and its associated with the same <a data-link-type="dfn" href="#promise" id="ref-for-promise②②">promise</a> (if <code class="highlight"><span class="n">rhs</span></code> refers to a <a data-link-type="dfn" href="#future" id="ref-for-future④⑤">future</a>).</p>
    <li data-md="">
     <p><em>Postconditions:</em> valid() returns the same value as rhs.valid() prior to the
constructor invocation. The validity of rhs does not change.</p>
   </ul>
   <p><br></p>
<pre class="highlight"><span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">E</span><span class="o">></span>
<span class="n">semi_future</span><span class="p">(</span><span class="n">continuable_future</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span> <span class="n">E</span><span class="o">>&amp;&amp;</span> <span class="n">rhs</span><span class="p">);</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Effects:</em> Move constructs a future object from <code class="highlight"><span class="n">rhs</span></code> that refers to the
same <a data-link-type="dfn" href="#future" id="ref-for-future④⑥">future</a> and its associated with the same <a data-link-type="dfn" href="#promise" id="ref-for-promise②③">promise</a> (if <code class="highlight"><span class="n">rhs</span></code> refers to a <a data-link-type="dfn" href="#future" id="ref-for-future④⑦">future</a>).</p>
    <li data-md="">
     <p><em>Postconditions:</em></p>
    <li data-md="">
     <p>valid() returns the same value as rhs.valid() prior to the constructor invocation.</p>
    <li data-md="">
     <p>rhs.valid() == false.</p>
   </ul>
   <p><br></p>
<pre class="highlight"><span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">E</span><span class="o">></span>
<span class="k">explicit</span> <span class="n">semi_future</span><span class="p">(</span><span class="n">shared_future</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span> <span class="n">E</span><span class="o">>&amp;&amp;</span> <span class="n">rhs</span><span class="p">);</span>

<span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">E</span><span class="o">></span>
<span class="k">explicit</span> <span class="n">semi_future</span><span class="p">(</span><span class="k">const</span> <span class="n">shared_future</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>
</pre>
   <ul>
    <li data-md="">
     <p><em>Effects:</em> Move constructs a future object from <code class="highlight"><span class="n">rhs</span></code> that refers to the
same <a data-link-type="dfn" href="#future" id="ref-for-future④⑧">future</a> and its associated with the same <a data-link-type="dfn" href="#promise" id="ref-for-promise②④">promise</a> (if <code class="highlight"><span class="n">rhs</span></code> refers to a <a data-link-type="dfn" href="#future" id="ref-for-future④⑨">future</a>).</p>
    <li data-md="">
     <p><em>Postconditions:</em></p>
     <ul>
      <li data-md="">
       <p>valid() returns the same value as rhs.valid() prior to the constructor
invocation.</p>
      <li data-md="">
       <p>rhs.valid() == false.</p>
     </ul>
   </ul>
   <p><br></p>
<pre class="highlight"><span class="n">continuable_future</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span> <span class="n">EI</span><span class="o">></span> <span class="n">via</span><span class="p">(</span><span class="n">EI</span> <span class="n">ex</span><span class="p">)</span> <span class="o">&amp;&amp;</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Effects:</em> Returns a new future that will complete when this completes but
on which continuations will be enqueued to a new executor.</p>
    <li data-md="">
     <p><em>Returns:</em> A continuable_future modified to carry executor ex of
type EI.</p>
    <li data-md="">
     <p><em>Requires:</em></p>
    <li data-md="">
     <p><code class="highlight"><span class="n">e</span></code> is a <code class="highlight"><span class="n">ThenExecutor</span></code> where <code class="highlight"><span class="n">make_promise_contract</span><span class="p">(</span><span class="n">e</span><span class="p">)</span></code> is well-formed.</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">e</span></code> is a <code class="highlight"><span class="n">OnewayExecutor</span></code> or is convertible to a OnewayExecutor.</p>
    <li data-md="">
     <p><em>Postconditions:</em> valid() == false.</p>
   </ul>
   <p><br></p>
<pre class="highlight"><span class="kt">bool</span> <span class="nf">valid</span><span class="p">()</span> <span class="k">const</span> <span class="k">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Returns:</em> Returns true if this is a valid future. False otherwise.</p>
   </ul>
   <h3 class="heading settled" data-level="2.9" id="wording_erasing_continuable_future"><span class="secno">2.9. </span><span class="content"><code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">execution</span><span class="o">::</span><span class="n">continuable_future</span></code></span><a class="self-link" href="#wording_erasing_continuable_future"></a></h3>
<pre class="highlight"><span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">T</span><span class="p">,</span> <span class="k">class</span> <span class="nc">E</span><span class="o">></span>
<span class="k">class</span> <span class="nc">continuable_future</span> <span class="p">{</span>
<span class="k">public</span><span class="o">:</span>
    <span class="k">using</span> <span class="n">value_type</span> <span class="o">=</span> <span class="n">T</span><span class="p">;</span>
    <span class="k">using</span> <span class="n">executor_type</span> <span class="o">=</span> <span class="n">Ex</span><span class="p">;</span>
    <span class="k">using</span> <span class="n">semi_future_type</span> <span class="o">=</span> <span class="n">semi_future</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span><span class="p">;</span>

    <span class="n">continuable_future</span><span class="p">(</span><span class="k">const</span> <span class="n">continuable_future</span><span class="o">&amp;</span><span class="p">)</span> <span class="o">=</span> <span class="k">delete</span><span class="p">;</span>
    <span class="n">continuable_future</span><span class="p">(</span><span class="n">continuable_future</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">continuable_future</span><span class="o">&amp;</span> <span class="k">operator</span><span class="o">=</span><span class="p">(</span><span class="k">const</span> <span class="n">continuable_future</span><span class="o">&amp;</span><span class="p">)</span> <span class="o">=</span> <span class="k">delete</span><span class="p">;</span>
    <span class="n">continuable_future</span><span class="o">&amp;</span> <span class="k">operator</span><span class="o">=</span><span class="p">(</span><span class="n">continuable_future</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="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">E</span><span class="o">></span>
    <span class="k">explicit</span> <span class="n">continuable_future</span><span class="p">(</span><span class="n">shared_future</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span> <span class="n">E</span><span class="o">>&amp;&amp;</span><span class="p">);</span>
    <span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">E</span><span class="o">></span>
    <span class="k">explicit</span> <span class="n">continuable_future</span><span class="p">(</span><span class="k">const</span> <span class="n">shared_future</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>

    <span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">ReturnFuture</span><span class="p">,</span> <span class="k">class</span> <span class="nc">F</span><span class="o">></span>
    <span class="n">ReturnFuture</span> <span class="n">then</span><span class="p">(</span><span class="n">FutureContinuation</span><span class="o">&amp;&amp;</span><span class="p">)</span> <span class="o">&amp;&amp;</span><span class="p">;</span>

    <span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">EI</span><span class="o">></span>
    <span class="n">continuable_future</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span> <span class="n">EI</span><span class="o">></span> <span class="n">via</span><span class="p">(</span><span class="n">EI</span><span class="p">)</span> <span class="o">&amp;&amp;</span><span class="p">;</span>

    <span class="n">E</span> <span class="nf">get_executor</span><span class="p">()</span> <span class="k">const</span><span class="p">;</span>
    <span class="n">semi_future</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span> <span class="n">semi</span><span class="p">()</span> <span class="o">&amp;&amp;</span><span class="p">;</span>
    <span class="n">shared_future</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">share</span><span class="p">()</span> <span class="o">&amp;&amp;</span><span class="p">;</span>

    <span class="kt">bool</span> <span class="nf">valid</span><span class="p">()</span> <span class="k">const</span>
<span class="p">}</span>
<span class="p">};</span>
</pre>
   <p><br></p>
<pre class="highlight"><span class="n">continuable_future</span><span class="p">(</span><span class="n">continuable_future</span><span class="o">&amp;&amp;</span> <span class="n">rhs</span><span class="p">);</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Effects:</em> Move constructs a future object from <code class="highlight"><span class="n">rhs</span></code> that refers to the
same <a data-link-type="dfn" href="#future" id="ref-for-future⑤⓪">future</a> and its associated with the same <a data-link-type="dfn" href="#promise" id="ref-for-promise②⑤">promise</a> (if <code class="highlight"><span class="n">rhs</span></code> refers to a <a data-link-type="dfn" href="#future" id="ref-for-future⑤①">future</a>).</p>
    <li data-md="">
     <p><em>Postconditions:</em></p>
     <ul>
      <li data-md="">
       <p>valid() returns the same value as rhs.valid() prior to the constructor
invocation.</p>
      <li data-md="">
       <p>rhs.valid() == false.</p>
     </ul>
   </ul>
   <p><br></p>
<pre class="highlight"><span class="n">continuable_future</span><span class="p">(</span><span class="k">const</span> <span class="n">continuable_future</span><span class="o">&amp;</span> <span class="n">rhs</span><span class="p">);</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Effects:</em> Copy constructs a future object from <code class="highlight"><span class="n">rhs</span></code> that refers to the
same <a data-link-type="dfn" href="#future" id="ref-for-future⑤②">future</a> and its associated with the same <a data-link-type="dfn" href="#promise" id="ref-for-promise②⑥">promise</a> (if <code class="highlight"><span class="n">rhs</span></code> refers to a <a data-link-type="dfn" href="#future" id="ref-for-future⑤③">future</a>).</p>
    <li data-md="">
     <p><em>Postconditions:</em> valid() returns the same value as rhs.valid() prior to the
constructor invocation. The validity of rhs does not change.</p>
   </ul>
   <p><br></p>
<pre class="highlight"><span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">E</span><span class="o">></span>
<span class="k">explicit</span> <span class="n">continuable_future</span><span class="p">(</span><span class="n">shared_future</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span> <span class="n">E</span><span class="o">>&amp;&amp;</span> <span class="n">rhs</span><span class="p">);</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Effects:</em> Move constructs a future object from <code class="highlight"><span class="n">rhs</span></code> that refers to the
same <a data-link-type="dfn" href="#future" id="ref-for-future⑤④">future</a> and its associated with the same <a data-link-type="dfn" href="#promise" id="ref-for-promise②⑦">promise</a> (if <code class="highlight"><span class="n">rhs</span></code> refers to a <a data-link-type="dfn" href="#future" id="ref-for-future⑤⑤">future</a>).</p>
    <li data-md="">
     <p><em>Postconditions:</em></p>
     <ul>
      <li data-md="">
       <p>valid() returns the same value as rhs.valid() prior to the constructor
invocation.</p>
      <li data-md="">
       <p>rhs.valid() == false.</p>
     </ul>
   </ul>
   <p><br></p>
<pre class="highlight"><span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">E</span><span class="o">></span>
<span class="k">explicit</span> <span class="n">continuable_future</span><span class="p">(</span><span class="k">const</span> <span class="n">shared_future</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>
</pre>
   <ul>
    <li data-md="">
     <p><em>Effects:</em> Copy constructs a future object from <code class="highlight"><span class="n">rhs</span></code> that refers to the
same <a data-link-type="dfn" href="#future" id="ref-for-future⑤⑥">future</a> and its associated with the same <a data-link-type="dfn" href="#promise" id="ref-for-promise②⑧">promise</a> (if <code class="highlight"><span class="n">rhs</span></code> refers to a <a data-link-type="dfn" href="#future" id="ref-for-future⑤⑦">future</a>).</p>
    <li data-md="">
     <p><em>Postconditions:</em> valid() returns the same value as rhs.valid() prior to the
constructor invocation. The validity of rhs does not change.</p>
   </ul>
   <p><br></p>
<pre class="highlight"><span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">ReturnFuture</span><span class="p">,</span> <span class="k">class</span> <span class="nc">F</span><span class="o">></span>
<span class="n">ReturnFuture</span> <span class="n">then</span><span class="p">(</span><span class="n">F</span><span class="o">&amp;&amp;</span><span class="p">)</span> <span class="o">&amp;&amp;</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Requires:</em> F satisfies the requirements of FutureContinuation.</p>
    <li data-md="">
     <p><em>Returns:</em> A <code class="highlight"><span class="n">ContinuableFuture</span></code> that is bound to the executor <code class="highlight"><span class="n">e</span></code> and
that wraps the type returned by execution of either the value or exception
operations implemented in the continuation. The type of the returned <code class="highlight"><span class="n">ContinuableFuture</span></code> is defined by <code class="highlight"><span class="n">Executor</span></code> <code class="highlight"><span class="n">E</span></code>.</p>
    <li data-md="">
     <p><em>Effects:</em></p>
     <ul>
      <li data-md="">
       <p>For <code class="highlight"><span class="n">NORMAL</span></code> defined as the expression <code class="highlight"><span class="n">DECAY_COPY</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">F</span><span class="o">></span><span class="p">(</span><span class="n">g</span><span class="p">))(</span><span class="n">val</span><span class="p">)</span></code> if <code class="highlight"><span class="n">T</span></code> is non-void and <code class="highlight"><span class="n">DECAY_COPY</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">F</span><span class="o">></span><span class="p">(</span><span class="n">g</span><span class="p">))()</span></code> if <code class="highlight"><span class="n">T</span></code> is void.</p>
      <li data-md="">
       <p>For <code class="highlight"><span class="n">EXCEPTIONAL</span></code> defined as the expression <code class="highlight"><span class="n">DECAY_COPY</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">F</span><span class="o">></span><span class="p">(</span><span class="n">f</span><span class="p">))(</span><span class="n">exception_arg</span><span class="p">,</span> <span class="n">ex</span><span class="p">)</span></code>,</p>
      <li data-md="">
       <p>When <code class="highlight"><span class="o">*</span><span class="k">this</span></code> becomes nonexceptionally ready, and if <code class="highlight"><span class="n">NORMAL</span></code> is a
well-formed expression, creates an execution agent which invokes <code class="highlight"><span class="n">NORMAL</span></code> at most once, with the call to <code class="highlight"><span class="n">DECAY_COPY</span></code> being evaluated in the thread
that called <code class="highlight"><span class="p">.</span><span class="n">then</span></code>.</p>
      <li data-md="">
       <p>Otherwise, when <code class="highlight"><span class="o">*</span><span class="k">this</span></code> becomes exceptionally ready, if <code class="highlight"><span class="n">EXCEPTIONAL</span></code> is a
well-formed expression, creates an execution agent which invokes <code class="highlight"><span class="n">EXCEPTIONAL</span></code> at most once, with the call to <code class="highlight"><span class="n">DECAY_COPY</span></code> being evaluated
in the thread that called <code class="highlight"><span class="p">.</span><span class="n">then</span></code>.</p>
      <li data-md="">
       <p>If <code class="highlight"><span class="n">NORMAL</span></code> and <code class="highlight"><span class="n">EXCEPTIONAL</span></code> are both well-formed expressions, <code class="highlight"><span class="k">decltype</span><span class="p">(</span><span class="n">EXCEPTIONAL</span><span class="p">)</span></code> shall be convertible to <code class="highlight"><span class="n">R</span></code>.</p>
      <li data-md="">
       <p>If <code class="highlight"><span class="n">NORMAL</span></code> is not a well-formed expression and <code class="highlight"><span class="n">EXCEPTIONAL</span></code> is a
well-formed expression, <code class="highlight"><span class="k">decltype</span><span class="p">(</span><span class="n">EXCEPTIONAL</span><span class="p">)</span></code> shall be convertible to <code class="highlight"><span class="k">decltype</span><span class="p">(</span><span class="n">val</span><span class="p">)</span></code>.</p>
      <li data-md="">
       <p>If neither <code class="highlight"><span class="n">NORMAL</span></code> nor <code class="highlight"><span class="n">EXCEPTIONAL</span></code> are well-formed expressions, the
invocation of <code class="highlight"><span class="p">.</span><span class="n">then</span></code> shall be ill-formed.</p>
      <li data-md="">
       <p>May block pending completion of <code class="highlight"><span class="n">NORMAL</span></code> or <code class="highlight"><span class="n">EXCEPTIONAL</span></code>.</p>
      <li data-md="">
       <p>The invocation of <code class="highlight"><span class="p">.</span><span class="n">then</span></code> <a href="http://eel.is/c++draft/intro.races#def:synchronize_with">synchronizes with</a> (C++Std [intro.multithread]) the invocation of <code class="highlight"><span class="n">f</span></code>.</p>
      <li data-md="">
       <p>Stores the result of either the <code class="highlight"><span class="n">NORMAL</span></code> or <code class="highlight"><span class="n">EXCEPTIONAL</span></code> expression, or
any exception thrown by either, in the associated shared state of the
resulting <code class="highlight"><span class="n">ContinuableFuture</span></code>. Otherwise, stores either <code class="highlight"><span class="n">val</span></code> or <code class="highlight"><span class="n">e</span></code> in
the associated shared state of the resulting <code class="highlight"><span class="n">ContinuableFuture</span></code>.</p>
     </ul>
    <li data-md="">
     <p><em>Postconditions:</em> valid() == false.</p>
   </ul>
   <p><br></p>
<pre class="highlight"><span class="n">continuable_future</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span> <span class="n">EI</span><span class="o">></span> <span class="n">via</span><span class="p">(</span><span class="n">EI</span> <span class="n">ex</span><span class="p">)</span> <span class="o">&amp;&amp;</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Effects:</em> Returns a new future that will complete when this completes but
on which continuations will be enqueued to a new executor.</p>
    <li data-md="">
     <p><em>Returns:</em> A continuable_future modified to carry executor ex of
type EI.</p>
    <li data-md="">
     <p><em>Requires:</em></p>
    <li data-md="">
     <p><code class="highlight"><span class="n">e</span></code> is a <code class="highlight"><span class="n">ThenExecutor</span></code> where <code class="highlight"><span class="n">make_promise_contract</span><span class="p">(</span><span class="n">e</span><span class="p">)</span></code> is well-formed.</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">e</span></code> is a <code class="highlight"><span class="n">OnewayExecutor</span></code> or is convertible to a OnewayExecutor.</p>
    <li data-md="">
     <p><em>Postconditions:</em> valid() == false.</p>
   </ul>
   <p><br></p>
<pre class="highlight"><span class="n">E</span> <span class="nf">get_executor</span><span class="p">()</span> <span class="k">const</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Returns:</em> If is_valid() returns true returns the executor contained within the
future. Otherwise throws std::future_error.</p>
   </ul>
   <p><br></p>
<pre class="highlight"><span class="n">semi_future</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span> <span class="n">semi</span><span class="p">()</span> <span class="o">&amp;&amp;</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Returns:</em> Returns a semi_future of the same value type as *this and that
completes when this completes, but that erases the executor. is_valid() on the
returned semi_future will return the same value as is_valid() on
*this.</p>
   </ul>
   <p><br></p>
<pre class="highlight"><span class="kt">bool</span> <span class="nf">valid</span><span class="p">()</span> <span class="k">const</span> <span class="k">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Returns:</em> Returns true if this is a valid future. False otherwise.</p>
   </ul>
   <p><br></p>
<pre class="highlight"><span class="n">shared_future</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">share</span><span class="p">()</span> <span class="o">&amp;&amp;</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p>
      <em>Returns:</em> shared_future
      <r>(std::move(*this)).</r>
     </p>
    <li data-md="">
     <p><em>Postconditions:</em> valid() == false.</p>
   </ul>
   <h3 class="heading settled" data-level="2.10" id="wording_erasing_shared_future"><span class="secno">2.10. </span><span class="content"><code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">execution</span><span class="o">::</span><span class="n">shared_future</span></code></span><a class="self-link" href="#wording_erasing_shared_future"></a></h3>
<pre class="highlight"><span class="k">namespace</span> <span class="n">std</span><span class="o">::</span><span class="n">execution</span> <span class="p">{</span>
  <span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">T</span><span class="p">,</span> <span class="k">class</span> <span class="nc">E</span><span class="o">></span>
  <span class="k">class</span> <span class="nc">shared_future</span> <span class="p">{</span>
  <span class="k">public</span><span class="o">:</span>
      <span class="k">using</span> <span class="n">value_type</span> <span class="o">=</span> <span class="n">T</span><span class="p">;</span>
      <span class="k">using</span> <span class="n">executor_type</span> <span class="o">=</span> <span class="n">Ex</span><span class="p">;</span>
      <span class="k">using</span> <span class="n">semi_future_type</span> <span class="o">=</span> <span class="n">semi_future</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span><span class="p">;</span>

      <span class="n">shared_future</span><span class="p">(</span><span class="k">const</span> <span class="n">shared_future</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">shared_future</span><span class="p">(</span><span class="n">shared_future</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">shared_future</span><span class="o">&amp;</span> <span class="k">operator</span><span class="o">=</span><span class="p">(</span><span class="k">const</span> <span class="n">shared_future</span><span class="o">&amp;</span><span class="p">)</span> <span class="o">=</span> <span class="k">default</span>
      <span class="n">shared_future</span><span class="o">&amp;</span> <span class="k">operator</span><span class="o">=</span><span class="p">(</span><span class="n">shared_future</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="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">E</span><span class="o">></span>
      <span class="k">explicit</span> <span class="n">shared_future</span><span class="p">(</span><span class="n">continuable_future</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span> <span class="n">E</span><span class="o">>&amp;&amp;</span><span class="p">);</span>

      <span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">ReturnFuture</span><span class="p">,</span> <span class="k">class</span> <span class="nc">F</span><span class="o">></span>
      <span class="n">ReturnFuture</span> <span class="n">then</span><span class="p">(</span><span class="n">FutureContinuation</span><span class="o">&amp;&amp;</span><span class="p">);</span>

      <span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">EI</span><span class="o">></span>
      <span class="n">shared_future</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span> <span class="n">EI</span><span class="o">></span> <span class="n">via</span><span class="p">(</span><span class="n">EI</span><span class="p">);</span>

      <span class="n">E</span> <span class="nf">get_executor</span><span class="p">()</span> <span class="k">const</span><span class="p">;</span>
      <span class="n">semi_future</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span> <span class="n">semi</span><span class="p">();</span>

      <span class="kt">bool</span> <span class="nf">valid</span><span class="p">()</span> <span class="k">const</span><span class="p">;</span>
  <span class="p">}</span>
  <span class="p">};</span>
<span class="p">}</span>
</pre>
   <p><br></p>
<pre class="highlight"><span class="n">shared_future</span><span class="p">(</span><span class="n">shared_future</span><span class="o">&amp;&amp;</span> <span class="n">rhs</span><span class="p">);</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Effects:</em> Move constructs a future object that refers to the shared state that
  was originally referred to by rhs (if any).</p>
    <li data-md="">
     <p><em>Postconditions:</em></p>
     <ul>
      <li data-md="">
       <p>valid() returns the same value as rhs.valid() prior to the constructor invocation.</p>
      <li data-md="">
       <p>rhs.valid() == false.</p>
     </ul>
   </ul>
   <p><br></p>
<pre class="highlight"><span class="n">shared_future</span><span class="p">(</span><span class="k">const</span> <span class="n">shared_future</span><span class="o">&amp;</span> <span class="n">rhs</span><span class="p">);</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Effects:</em> Copy constructs a future object that refers to the shared state that was originally referred to by rhs (if any).</p>
    <li data-md="">
     <p><em>Postconditions:</em> valid() returns the same value as rhs.valid() prior to the constructor invocation. The validity of rhs does not change.</p>
   </ul>
   <p><br></p>
<pre class="highlight"><span class="k">explicit</span> <span class="nf">shared_future</span><span class="p">(</span><span class="n">continuable_future</span><span class="o">&amp;&amp;</span> <span class="n">rhs</span><span class="p">);</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Effects:</em> Move constructs a future object that refers to the shared state that
  was originally referred to by rhs (if any).</p>
    <li data-md="">
     <p><em>Postconditions:</em></p>
     <ul>
      <li data-md="">
       <p>valid() returns the same value as rhs.valid() prior to the constructor invocation.</p>
      <li data-md="">
       <p>rhs.valid() == false.</p>
     </ul>
   </ul>
   <p><br></p>
<pre class="highlight"><span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">ReturnFuture</span><span class="p">,</span> <span class="k">class</span> <span class="nc">F</span><span class="o">></span>
<span class="n">ReturnFuture</span> <span class="n">then</span><span class="p">(</span><span class="n">F</span><span class="o">&amp;&amp;</span><span class="p">);</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Requires:</em> F satisfies the requirements of FutureContinuation.</p>
    <li data-md="">
     <p><em>Returns:</em> A <code class="highlight"><span class="n">ContinuableFuture</span></code> that is bound to the executor <code class="highlight"><span class="n">e</span></code> and
  that wraps the type returned by execution of either the value or exception
  operations implemented in the continuation. The type of the returned <code class="highlight"><span class="n">ContinuableFuture</span></code> is defined by <code class="highlight"><span class="n">Executor</span></code> <code class="highlight"><span class="n">E</span></code>.</p>
    <li data-md="">
     <p><em>Effects:</em></p>
     <ul>
      <li data-md="">
       <p>For <code class="highlight"><span class="n">NORMAL</span></code> defined as the expression <code class="highlight"><span class="n">DECAY_COPY</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">F</span><span class="o">></span><span class="p">(</span><span class="n">g</span><span class="p">))(</span><span class="n">val</span><span class="p">)</span></code> if <code class="highlight"><span class="n">T</span></code> is non-void and <code class="highlight"><span class="n">DECAY_COPY</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">F</span><span class="o">></span><span class="p">(</span><span class="n">g</span><span class="p">))()</span></code> if <code class="highlight"><span class="n">T</span></code> is void.</p>
      <li data-md="">
       <p>For <code class="highlight"><span class="n">EXCEPTIONAL</span></code> defined as the expression <code class="highlight"><span class="n">DECAY_COPY</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">F</span><span class="o">></span><span class="p">(</span><span class="n">f</span><span class="p">))(</span><span class="n">exception_arg</span><span class="p">,</span> <span class="n">ex</span><span class="p">)</span></code>,</p>
      <li data-md="">
       <p>When <code class="highlight"><span class="o">*</span><span class="k">this</span></code> becomes nonexceptionally ready, and if <code class="highlight"><span class="n">NORMAL</span></code> is a
well-formed expression, creates an execution agent which invokes <code class="highlight"><span class="n">NORMAL</span></code> at most once, with the call to <code class="highlight"><span class="n">DECAY_COPY</span></code> being evaluated in the thread
that called <code class="highlight"><span class="p">.</span><span class="n">then</span></code>.</p>
      <li data-md="">
       <p>Otherwise, when <code class="highlight"><span class="o">*</span><span class="k">this</span></code> becomes exceptionally ready, if <code class="highlight"><span class="n">EXCEPTIONAL</span></code> is a
well-formed expression, creates an execution agent which invokes <code class="highlight"><span class="n">EXCEPTIONAL</span></code> at most once, with the call to <code class="highlight"><span class="n">DECAY_COPY</span></code> being evaluated
in the thread that called <code class="highlight"><span class="p">.</span><span class="n">then</span></code>.</p>
      <li data-md="">
       <p>If <code class="highlight"><span class="n">NORMAL</span></code> and <code class="highlight"><span class="n">EXCEPTIONAL</span></code> are both well-formed expressions, <code class="highlight"><span class="k">decltype</span><span class="p">(</span><span class="n">EXCEPTIONAL</span><span class="p">)</span></code> shall be convertible to <code class="highlight"><span class="n">R</span></code>.</p>
      <li data-md="">
       <p>If <code class="highlight"><span class="n">NORMAL</span></code> is not a well-formed expression and <code class="highlight"><span class="n">EXCEPTIONAL</span></code> is a
well-formed expression, <code class="highlight"><span class="k">decltype</span><span class="p">(</span><span class="n">EXCEPTIONAL</span><span class="p">)</span></code> shall be convertible to <code class="highlight"><span class="k">decltype</span><span class="p">(</span><span class="n">val</span><span class="p">)</span></code>.</p>
      <li data-md="">
       <p>If neither <code class="highlight"><span class="n">NORMAL</span></code> nor <code class="highlight"><span class="n">EXCEPTIONAL</span></code> are well-formed expressions, the
invocation of <code class="highlight"><span class="p">.</span><span class="n">then</span></code> shall be ill-formed.</p>
      <li data-md="">
       <p>May block pending completion of <code class="highlight"><span class="n">NORMAL</span></code> or <code class="highlight"><span class="n">EXCEPTIONAL</span></code>.</p>
      <li data-md="">
       <p>The invocation of <code class="highlight"><span class="p">.</span><span class="n">then</span></code> <a href="http://eel.is/c++draft/intro.races#def:synchronize_with">synchronizes with</a> (C++Std [intro.multithread]) the invocation of <code class="highlight"><span class="n">f</span></code>.</p>
      <li data-md="">
       <p>Stores the result of either the <code class="highlight"><span class="n">NORMAL</span></code> or <code class="highlight"><span class="n">EXCEPTIONAL</span></code> expression, or
any exception thrown by either, in the associated shared state of the
resulting <code class="highlight"><span class="n">ContinuableFuture</span></code>. Otherwise, stores either <code class="highlight"><span class="n">val</span></code> or <code class="highlight"><span class="n">e</span></code> in
the associated shared state of the resulting <code class="highlight"><span class="n">ContinuableFuture</span></code>.</p>
     </ul>
    <li data-md="">
     <p><em>Postconditions:</em> No observable change to *this.</p>
   </ul>
   <p><br></p>
<pre class="highlight"><span class="n">shared_future</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span> <span class="n">EI</span><span class="o">></span> <span class="n">via</span><span class="p">(</span><span class="n">EI</span> <span class="n">ex</span><span class="p">);</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Effects:</em> Returns a new future that will complete when this completes but
  on which continuations will be enqueued to a new executor.</p>
    <li data-md="">
     <p><em>Returns:</em> A shared_future modified to carry executor ex of type EI.</p>
    <li data-md="">
     <p><em>Requires:</em></p>
    <li data-md="">
     <p><code class="highlight"><span class="n">e</span></code> is a <code class="highlight"><span class="n">ThenExecutor</span></code> where <code class="highlight"><span class="n">make_promise_contract</span><span class="p">(</span><span class="n">e</span><span class="p">)</span></code> is well-formed.</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">e</span></code> is a <code class="highlight"><span class="n">OnewayExecutor</span></code> or is convertible to a OnewayExecutor.</p>
    <li data-md="">
     <p><em>Postconditions:</em> No observable change to *this.</p>
   </ul>
   <p><br></p>
<pre class="highlight"><span class="n">E</span> <span class="nf">get_executor</span><span class="p">()</span> <span class="k">const</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Returns:</em> If is_valid() returns true returns the executor contained within the
future. Otherwise throws std::future_error.</p>
   </ul>
   <p><br></p>
<pre class="highlight"><span class="n">semi_future</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span> <span class="n">semi</span><span class="p">();</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Returns:</em> Returns a semi_future of the same value type as *this and that
  completes when this completes, but that erases the executor. is_valid() on the
  returned semi_future will return the same value as is_valid() on
  *this.</p>
   </ul>
   <p><br></p>
<pre class="highlight"><span class="kt">bool</span> <span class="nf">valid</span><span class="p">()</span> <span class="k">const</span> <span class="k">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Returns:</em> Returns true if this is a valid future. False otherwise.</p>
   </ul>
   <h3 class="heading settled" data-level="2.11" id="wording_make_promise_contract"><span class="secno">2.11. </span><span class="content"><code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">execution</span><span class="o">::</span><span class="n">make_promise_contract</span></code></span><a class="self-link" href="#wording_make_promise_contract"></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">Executor</span><span class="o">></span>
<span class="cm">/* see below */</span>
<span class="n">make_promise_contract</span><span class="p">(</span><span class="k">const</span> <span class="n">Executor</span><span class="o">&amp;</span> <span class="n">ex</span><span class="p">)</span>
  <span class="n">requires</span> <span class="n">execution</span><span class="o">::</span><span class="n">is_then_executor_v</span><span class="o">&lt;</span><span class="n">Executor</span><span class="o">></span> <span class="o">&amp;&amp;</span> <span class="n">execution</span><span class="o">::</span><span class="n">can_query_v</span><span class="o">&lt;</span><span class="n">Executor</span><span class="p">,</span> <span class="n">promise_contract_t</span><span class="o">&lt;</span><span class="n">T</span><span class="o">>></span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Effects:</em> equivalent to <code class="highlight"><span class="n">execution</span><span class="o">::</span><span class="n">query</span><span class="p">(</span><span class="n">ex</span><span class="p">,</span> <span class="n">promise_contract_t</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span><span class="p">{})</span></code></p>
    <li data-md="">
     <p><em>Returns:</em> same as <code class="highlight"><span class="n">execution</span><span class="o">::</span><span class="n">query</span><span class="p">(</span><span class="n">ex</span><span class="p">,</span> <span class="n">promise_contract_t</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span><span class="p">{})</span></code></p>
   </ul>
   <p><br></p>
<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">Executor</span><span class="o">></span>
<span class="n">pair</span><span class="o">&lt;</span><span class="n">promise</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span><span class="p">,</span> <span class="n">continuable_future</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">Executor</span><span class="o">>></span>
<span class="n">make_promise_contract</span><span class="p">(</span><span class="k">const</span> <span class="n">Executor</span><span class="o">&amp;</span> <span class="n">ex</span><span class="p">)</span>
  <span class="n">requires</span> <span class="n">execution</span><span class="o">::</span><span class="n">is_one_way_executor_v</span><span class="o">&lt;</span><span class="n">Executor</span><span class="o">></span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Returns:</em> A pair of:</p>
     <ul>
      <li data-md="">
       <p>a <code class="highlight"><span class="n">promise</span></code> that refers to a <a data-link-type="dfn" href="#promise" id="ref-for-promise②⑨">promise</a> that is associated with the <a data-link-type="dfn" href="#future" id="ref-for-future⑤⑧">future</a> in the pair</p>
      <li data-md="">
       <p>a <code class="highlight"><span class="n">continuable_future</span></code> that is associated with the <a data-link-type="dfn" href="#promise" id="ref-for-promise③⓪">promise</a> and is bound to <code class="highlight"><span class="n">ex</span></code>.</p>
     </ul>
   </ul>
   <p><br></p>
<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="o">></span>
<span class="n">pair</span><span class="o">&lt;</span><span class="n">promise</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span><span class="p">,</span> <span class="n">semi_future</span><span class="o">&lt;</span><span class="n">T</span><span class="o">>></span>
<span class="n">make_promise_contract</span><span class="p">()</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Returns:</em> A pair of:</p>
     <ul>
      <li data-md="">
       <p>a <code class="highlight"><span class="n">promise</span></code> that refers to a <a data-link-type="dfn" href="#promise" id="ref-for-promise③①">promise</a> that is associated with the <a data-link-type="dfn" href="#future" id="ref-for-future⑤⑨">future</a> in the pair</p>
      <li data-md="">
       <p>a <code class="highlight"><span class="n">semi_future</span></code> that is associated with the <a data-link-type="dfn" href="#promise" id="ref-for-promise③②">promise</a>.</p>
     </ul>
   </ul>
   <h3 class="heading settled" data-level="2.12" id="wording_blocking_functions"><span class="secno">2.12. </span><span class="content">Generic Future Blocking Functions</span><a class="self-link" href="#wording_blocking_functions"></a></h3>
   <p>In [<strong>thread.syn</strong>] and [<strong>thread.thread.this</strong>] add:</p>
<pre class="highlight"><span class="k">namespace</span> <span class="n">std</span><span class="o">::</span><span class="n">this_thread</span> <span class="p">{</span>

  <span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">Future</span><span class="o">></span>
    <span class="kt">void</span> <span class="n">future_wait</span><span class="p">(</span><span class="n">Future</span><span class="o">&amp;</span> <span class="n">f</span><span class="p">)</span> <span class="k">noexcept</span><span class="p">;</span>

  <span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">Future</span><span class="o">></span>
    <span class="n">future_value_t</span><span class="o">&lt;</span><span class="n">decay_t</span><span class="o">&lt;</span><span class="n">Future</span><span class="o">>></span> <span class="n">future_get</span><span class="p">(</span><span class="n">Future</span><span class="o">&amp;&amp;</span> <span class="n">f</span><span class="p">);</span>

<span class="p">}</span>
</pre>
   <p>In [<strong>thread.thread.this</strong>] add:</p>
<pre class="highlight"><span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">Future</span><span class="o">></span>
  <span class="kt">void</span> <span class="n">future_wait</span><span class="p">(</span><span class="n">Future</span><span class="o">&amp;</span> <span class="n">f</span><span class="p">)</span> <span class="k">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Requires:</em> <code class="highlight"><span class="n">Future</span></code> meets the requirements of <code class="highlight"><span class="n">SemiFuture</span></code>.</p>
    <li data-md="">
     <p><em>Effects:</em> Blocks the calling thread until <code class="highlight"><span class="n">f</span></code> becomes ready.</p>
    <li data-md="">
     <p><em>Synchronization:</em> The destruction of the continuation that <a data-link-type="dfn" href="#fulfillment" id="ref-for-fulfillment①①">fulfills</a> <code class="highlight"><span class="n">f</span></code>'s <a href="http://eel.is/c++draft/intro.races#def:synchronize_with">synchronizes with</a> <code class="highlight"><span class="n">future_wait</span></code> calls blocking until <code class="highlight"><span class="n">f</span></code> becomes ready.</p>
<pre class="highlight"><span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">Future</span><span class="o">></span>
  <span class="n">future_value_t</span><span class="o">&lt;</span><span class="n">decay_t</span><span class="o">&lt;</span><span class="n">Future</span><span class="o">>></span> <span class="n">future_get</span><span class="p">(</span><span class="n">Future</span><span class="o">&amp;&amp;</span> <span class="n">f</span><span class="p">);</span>
</pre>
    <li data-md="">
     <p><em>Requires:</em></p>
    <li data-md="">
     <p><code class="highlight"><span class="n">decay_t</span><span class="o">&lt;</span><span class="n">Future</span><span class="o">></span></code> shall meet the <code class="highlight"><span class="n">SemiFuture</span></code> requirements.</p>
    <li data-md="">
     <p><code class="highlight"><span class="o">!</span><span class="n">is_reference_v</span><span class="o">&lt;</span><span class="n">Future</span><span class="o">></span></code> [ <em>Note:</em> This constrains the parameter to be an rvalue reference rather than a forwarding reference.
  — <em>end note</em> ]</p>
    <li data-md="">
     <p><em>Effects:</em></p>
    <li data-md="">
     <p>Blocks the calling thread until <code class="highlight"><span class="n">f</span></code> becomes ready.</p>
    <li data-md="">
     <p>Retrieves the <a data-link-type="dfn" href="#asynchronous-result" id="ref-for-asynchronous-result⑦">asynchronous result</a>.</p>
    <li data-md="">
     <p><em>Returns:</em></p>
     <ul>
      <li data-md="">
       <p>If <code class="highlight"><span class="n">f</span></code> becomes <a data-link-type="dfn" href="#ready" id="ref-for-ready⑤">ready</a> with a value, moves the value from <code class="highlight"><span class="n">f</span></code> and returns it
to the caller.</p>
     </ul>
    <li data-md="">
     <p><em>Postconditions:</em> <code class="highlight"><span class="n">f</span></code> is <a data-link-type="dfn" href="#invalid" id="ref-for-invalid④">invalid</a>.</p>
    <li data-md="">
     <p><em>Synchronization:</em> The destruction of the continuation that generates <code class="highlight"><span class="n">f</span></code>'s
 value <a href="http://eel.is/c++draft/intro.races#def:synchronize_with">synchronizes with</a> <code class="highlight"><span class="n">future_get</span></code> calls blocking until <code class="highlight"><span class="n">f</span></code> becomes ready.</p>
    <li data-md="">
     <p><em>Throws:</em> If <code class="highlight"><span class="n">f</span></code> becomes <a data-link-type="dfn" href="#ready" id="ref-for-ready⑥">ready</a> with an exception, that exception is rethrown.</p>
   </ul>
   <h3 class="heading settled" data-level="2.13" id="wording_future_continuation_helper_functions"><span class="secno">2.13. </span><span class="content"><code class="highlight"><span class="n">FutureContinuation</span></code> Helper Functions</span><a class="self-link" href="#wording_future_continuation_helper_functions"></a></h3>
<pre class="highlight"><span class="k">namespace</span> <span class="n">std</span><span class="o">::</span><span class="n">execution</span> <span class="p">{</span>

<span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">F</span><span class="o">></span>
  <span class="cm">/* see below */</span> <span class="n">on_value</span><span class="p">(</span><span class="n">F</span><span class="o">&amp;&amp;</span> <span class="n">f</span><span class="p">);</span>

<span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">F</span><span class="o">></span>
  <span class="cm">/* see below */</span> <span class="n">on_error</span><span class="p">(</span><span class="n">F</span><span class="o">&amp;&amp;</span> <span class="n">f</span><span class="p">);</span>

<span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">F</span><span class="p">,</span> <span class="k">class</span> <span class="nc">G</span><span class="o">></span>
  <span class="cm">/* see below */</span> <span class="n">on_value_or_error</span><span class="p">(</span><span class="n">F</span><span class="o">&amp;&amp;</span> <span class="n">f</span><span class="p">,</span> <span class="n">G</span><span class="o">&amp;&amp;</span> <span class="n">g</span><span class="p">);</span>

<span class="p">}</span>
</pre>
<pre class="highlight"><span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">F</span><span class="o">></span>
  <span class="cm">/* see below */</span> <span class="n">on_value</span><span class="p">(</span><span class="n">F</span><span class="o">&amp;&amp;</span> <span class="n">f</span><span class="p">);</span>
</pre>
   <p><strong>Requires:</strong></p>
   <ul>
    <li data-md="">
     <p>For any (possibly cv-qualified) object type <code class="highlight"><span class="n">T</span></code>, <code class="highlight"><span class="n">invoke</span><span class="p">(</span><span class="n">declval</span><span class="o">&lt;</span><span class="n">F</span><span class="o">></span><span class="p">(),</span> <span class="n">declval</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span><span class="p">())</span></code> shall be well-formed.</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">F</span></code> shall meet the <code class="highlight"><span class="n">MoveConstructible</span></code> requirements.</p>
   </ul>
   <p><strong>Returns:</strong> A <code class="highlight"><span class="n">FutureContinuation</span></code> object, <code class="highlight"><span class="n">fc</span></code>, of implementation-defined type such that:</p>
   <ul>
    <li data-md="">
     <p><code class="highlight"><span class="n">fc</span><span class="p">(</span><span class="n">t</span><span class="p">)</span></code> is well-formed for objects <code class="highlight"><span class="n">t</span></code> of type <code class="highlight"><span class="n">T</span></code> and has the same effects as <code class="highlight"><span class="n">invoke</span><span class="p">(</span><span class="n">ff</span><span class="p">,</span> <span class="n">t</span><span class="p">)</span></code>, where <code class="highlight"><span class="n">ff</span></code> is an instance of <code class="highlight"><span class="n">F</span></code> move-constructed from <code class="highlight"><span class="n">forward</span><span class="o">&lt;</span><span class="n">F</span><span class="o">></span><span class="p">(</span><span class="n">f</span><span class="p">)</span></code>.
The object <code class="highlight"><span class="n">ff</span></code> is constructed before the return of <code class="highlight"><span class="n">on_value</span><span class="p">()</span></code> and
destroyed when <code class="highlight"><span class="n">fc</span></code> is destroyed.</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">fc</span><span class="p">(</span><span class="n">exception_arg</span><span class="p">,</span> <span class="n">exception_ptr</span><span class="p">{})</span></code> is ill-formed.</p>
<pre class="highlight"><span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">F</span><span class="o">></span>
  <span class="cm">/* see below */</span> <span class="n">on_error</span><span class="p">(</span><span class="n">F</span><span class="o">&amp;&amp;</span> <span class="n">f</span><span class="p">);</span>
</pre>
   </ul>
   <p><strong>Requires:</strong></p>
   <ul>
    <li data-md="">
     <p><code class="highlight"><span class="n">invoke</span><span class="p">(</span><span class="n">declval</span><span class="o">&lt;</span><span class="n">F</span><span class="o">></span><span class="p">(),</span> <span class="n">declval</span><span class="o">&lt;</span><span class="n">exception_ptr</span><span class="o">></span><span class="p">())</span></code> shall be well-formed.</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">F</span></code> shall meet the <code class="highlight"><span class="n">MoveConstructible</span></code> requirements.</p>
   </ul>
   <p><strong>Returns:</strong> A <code class="highlight"><span class="n">FutureContinuation</span></code> object, <code class="highlight"><span class="n">fc</span></code>, of implementation-defined type such that:</p>
   <ul>
    <li data-md="">
     <p><code class="highlight"><span class="n">fc</span><span class="p">(</span><span class="n">exception_tag</span><span class="p">,</span> <span class="n">e</span><span class="p">)</span></code> is well-formed for objects <code class="highlight"><span class="n">e</span></code> of type <code class="highlight"><span class="n">exception_ptr</span></code> and
has the same effects as <code class="highlight"><span class="n">invoke</span><span class="p">(</span><span class="n">ff</span><span class="p">,</span> <span class="n">e</span><span class="p">)</span></code>, where <code class="highlight"><span class="n">ff</span></code> is an object of type <code class="highlight"><span class="n">F</span></code> move-constructed from <code class="highlight"><span class="n">forward</span><span class="o">&lt;</span><span class="n">F</span><span class="o">></span><span class="p">(</span><span class="n">f</span><span class="p">)</span></code>.
The object <code class="highlight"><span class="n">ff</span></code> is constructed before the return of <code class="highlight"><span class="n">on_error</span></code> and
destroyed when <code class="highlight"><span class="n">fc</span></code> is destroyed.</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">fc</span><span class="p">(</span><span class="n">t</span><span class="p">)</span></code> is ill-formed for any type <code class="highlight"><span class="n">T</span></code>.</p>
<pre class="highlight"><span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">F</span><span class="p">,</span> <span class="k">class</span> <span class="nc">G</span><span class="o">></span>
  <span class="cm">/* see below */</span> <span class="n">on_value_or_error</span><span class="p">(</span><span class="n">F</span><span class="o">&amp;&amp;</span> <span class="n">f</span><span class="p">,</span> <span class="n">G</span><span class="o">&amp;&amp;</span> <span class="n">g</span><span class="p">);</span>
</pre>
   </ul>
   <p><strong>Requires:</strong></p>
   <ul>
    <li data-md="">
     <p>For any (possibly cv-qualified) object type <code class="highlight"><span class="n">T</span></code>, <code class="highlight"><span class="n">invoke</span><span class="p">(</span><span class="n">declval</span><span class="o">&lt;</span><span class="n">F</span><span class="o">></span><span class="p">(),</span> <span class="n">declval</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span><span class="p">())</span></code> and <code class="highlight"><span class="n">invoke</span><span class="p">(</span><span class="n">declval</span><span class="o">&lt;</span><span class="n">G</span><span class="o">></span><span class="p">(),</span> <span class="n">declval</span><span class="o">&lt;</span><span class="n">exception_ptr</span><span class="o">></span><span class="p">())</span></code> shall be well-formed.</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">F</span></code> and <code class="highlight"><span class="n">G</span></code> shall meet the <code class="highlight"><span class="n">MoveConstructible</span></code> requirements.</p>
   </ul>
   <p><strong>Returns:</strong> A <code class="highlight"><span class="n">FutureContinuation</span></code> object, <code class="highlight"><span class="n">fc</span></code>, of implementation-defined type such that:</p>
   <ul>
    <li data-md="">
     <p><code class="highlight"><span class="n">fc</span><span class="p">(</span><span class="n">t</span><span class="p">)</span></code> is well-formed for objects <code class="highlight"><span class="n">t</span></code> of type <code class="highlight"><span class="n">T</span></code> and has the same effects
as <code class="highlight"><span class="n">invoke</span><span class="p">(</span><span class="n">ff</span><span class="p">,</span> <span class="n">t</span><span class="p">)</span></code>, where <code class="highlight"><span class="n">ff</span></code> is an object of type <code class="highlight"><span class="n">F</span></code> move-constructed
from <code class="highlight"><span class="n">forward</span><span class="o">&lt;</span><span class="n">F</span><span class="o">></span><span class="p">(</span><span class="n">f</span><span class="p">)</span></code>.
The object <code class="highlight"><span class="n">ff</span></code> is constructed before the return of <code class="highlight"><span class="n">on_value_or_error</span></code> and destroyed when <code class="highlight"><span class="n">fc</span></code> is destroyed.</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">fc</span><span class="p">(</span><span class="n">exception_tag</span><span class="p">,</span> <span class="n">e</span><span class="p">)</span></code> is well-formed for objects <code class="highlight"><span class="n">e</span></code> of type <code class="highlight"><span class="n">exception_ptr</span></code> and
has the same effects as <code class="highlight"><span class="n">invoke</span><span class="p">(</span><span class="n">gg</span><span class="p">,</span> <span class="n">e</span><span class="p">)</span></code>, where <code class="highlight"><span class="n">gg</span></code> is an object of type of <code class="highlight"><span class="n">G</span></code> move-constructed from <code class="highlight"><span class="n">forward</span><span class="o">&lt;</span><span class="n">G</span><span class="o">></span><span class="p">(</span><span class="n">g</span><span class="p">)</span></code>. 
The object <code class="highlight"><span class="n">gg</span></code> is constructed before the return of <code class="highlight"><span class="n">on_value_or_error</span></code> and
destroyed when <code class="highlight"><span class="n">fc</span></code> is destroyed.</p>
   </ul>
   <h3 class="heading settled" data-level="2.14" id="wording_p0443"><span class="secno">2.14. </span><span class="content">Proposed Modifications to Executors</span><a class="self-link" href="#wording_p0443"></a></h3>
   <h4 class="heading settled" data-level="2.14.1" id="wording_p0443_future"><span class="secno">2.14.1. </span><span class="content"><code class="highlight"><span class="n">Future</span></code> Requirements</span><a class="self-link" href="#wording_p0443_future"></a></h4>
   <p>Remove this section.</p>
   <h4 class="heading settled" data-level="2.14.2" id="wording_p0443_two_way_executor"><span class="secno">2.14.2. </span><span class="content"><code class="highlight"><span class="n">TwoWayExecutor</span></code> Requirements</span><a class="self-link" href="#wording_p0443_two_way_executor"></a></h4>
   <p>In the <em>Return Type</em> column:</p>
   <p><strong>Replace:</strong></p>
   <blockquote> A type that satisfies the <code class="highlight"><span class="n">Future</span></code> requirements for the value type <code class="highlight"><span class="n">R</span></code>. </blockquote>
   <p><strong>With:</strong></p>
   <blockquote> A type that satisfies the <code class="highlight"><span class="n">ContinuableFuture</span></code> requirements for the value type <code class="highlight"><span class="n">R</span></code>. </blockquote>
   <p>In the <em>Operational Semantics</em> column:</p>
   <p><strong>Replace:</strong></p>
   <blockquote> in the associated shared state of the resulting <code class="highlight"><span class="n">Future</span></code>. </blockquote>
   <p><strong>With:</strong></p>
   <blockquote> in the resulting <code class="highlight"><span class="n">ContinuableFuture</span></code>. </blockquote>
   <h4 class="heading settled" data-level="2.14.3" id="wording_p0443_then_executor"><span class="secno">2.14.3. </span><span class="content"><code class="highlight"><span class="n">ThenExecutor</span></code> Requirements</span><a class="self-link" href="#wording_p0443_then_executor"></a></h4>
   <p>In the type requirements list:</p>
   <p><strong>Replace:</strong></p>
   <blockquote>
    <ul>
     <li data-md="">
      <p><code class="highlight"><span class="n">fut</span></code> denotes a future object satisfying the <code class="highlight"><span class="n">Future</span></code> requirements,</p>
    </ul>
   </blockquote>
   <p><strong>With:</strong></p>
   <blockquote>
    <ul>
     <li data-md="">
      <p><code class="highlight"><span class="n">fut</span></code> denotes a future object that:</p>
     <li data-md="">
      <p>was returned by a call to <code class="highlight"><span class="n">x</span><span class="p">.</span><span class="n">twoway_execute</span></code>, <code class="highlight"><span class="n">x</span><span class="p">.</span><span class="n">bulk_twoway_execute</span></code>, <code class="highlight"><span class="n">x</span><span class="p">.</span><span class="n">then_execute</span></code>, or <code class="highlight"><span class="n">x</span><span class="p">.</span><span class="n">bulk_then_execute</span></code> and meets the <code class="highlight"><span class="n">ContinuableFuture</span></code> requirements.</p>
     <li data-md="">
      <p>was returned by a call to <code class="highlight"><span class="n">execution</span><span class="o">::</span><span class="n">query</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">promise_contract_t</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span><span class="p">)</span></code> or <code class="highlight"><span class="n">execution</span><span class="o">::</span><span class="n">query</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">cancellable_promise_contract_t</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span><span class="p">)</span></code>.</p>
    </ul>
   </blockquote>
   <p>In the <em>Return Type</em> column:</p>
   <p><strong>Replace:</strong></p>
   <blockquote> A type that satisfies the <code class="highlight"><span class="n">Future</span></code> requirements for the value type <code class="highlight"><span class="n">R</span></code>. </blockquote>
   <p><strong>With:</strong></p>
   <blockquote> A type that satisfies the <code class="highlight"><span class="n">ContinuableFuture</span></code> requirements for the value type <code class="highlight"><span class="n">R</span></code>. </blockquote>
   <p>In the <em>Operational Semantics</em> column:</p>
   <p><strong>Replace:</strong></p>
   <blockquote> in the associated shared state of the resulting <code class="highlight"><span class="n">Future</span></code>. </blockquote>
   <p><strong>With:</strong></p>
   <blockquote> in the resulting <code class="highlight"><span class="n">ContinuableFuture</span></code>. </blockquote>
   <h4 class="heading settled" data-level="2.14.4" id="wording_p0443_bulk_two_way_executor"><span class="secno">2.14.4. </span><span class="content"><code class="highlight"><span class="n">BulkTwoWayExecutor</span></code> Requirements</span><a class="self-link" href="#wording_p0443_bulk_two_way_executor"></a></h4>
   <p>In the <em>Return Type</em> column:</p>
   <p><strong>Replace:</strong></p>
   <blockquote> A type that satisfies the <code class="highlight"><span class="n">Future</span></code> requirements for the value type <code class="highlight"><span class="n">R</span></code>. </blockquote>
   <p><strong>With:</strong></p>
   <blockquote> A type that satisfies the <code class="highlight"><span class="n">ContinuableFuture</span></code> requirements for the value type <code class="highlight"><span class="n">R</span></code>. </blockquote>
   <p>In the <em>Operational Semantics</em> column:</p>
   <p><strong>Replace:</strong></p>
   <blockquote> in the associated shared state of the resulting <code class="highlight"><span class="n">Future</span></code>. </blockquote>
   <p><strong>With:</strong></p>
   <blockquote> in the resulting <code class="highlight"><span class="n">ContinuableFuture</span></code>. </blockquote>
   <h4 class="heading settled" data-level="2.14.5" id="wording_p0443_bulk_then_executor"><span class="secno">2.14.5. </span><span class="content"><code class="highlight"><span class="n">BulkThenExecutor</span></code> Requirements</span><a class="self-link" href="#wording_p0443_bulk_then_executor"></a></h4>
   <p>In the type requirements list:</p>
   <p><strong>Replace:</strong></p>
   <blockquote>
    <ul>
     <li data-md="">
      <p>fut denotes a future object satisfying the Future requirements,</p>
    </ul>
   </blockquote>
   <p><strong>With:</strong></p>
   <blockquote>
    <ul>
     <li data-md="">
      <p>fut denotes a future object that:</p>
     <li data-md="">
      <p>was returned by a call to <code class="highlight"><span class="n">x</span><span class="p">.</span><span class="n">twoway_execute</span></code>, <code class="highlight"><span class="n">x</span><span class="p">.</span><span class="n">bulk_twoway_execute</span></code>, <code class="highlight"><span class="n">x</span><span class="p">.</span><span class="n">then_execute</span></code>, or <code class="highlight"><span class="n">x</span><span class="p">.</span><span class="n">bulk_then_execute</span></code> and meets the <code class="highlight"><span class="n">ContinuableFuture</span></code> requirements.</p>
     <li data-md="">
      <p>was returned by a call to <code class="highlight"><span class="n">execution</span><span class="o">::</span><span class="n">query</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">promise_contract_t</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span><span class="p">)</span></code> or <code class="highlight"><span class="n">execution</span><span class="o">::</span><span class="n">query</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">cancellable_promise_contract_t</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span><span class="p">)</span></code>.</p>
    </ul>
   </blockquote>
   <p>In the <em>Return Type</em> column:</p>
   <p><strong>Replace:</strong></p>
   <blockquote> A type that satisfies the <code class="highlight"><span class="n">Future</span></code> requirements for the value type <code class="highlight"><span class="n">R</span></code>. </blockquote>
   <p><strong>With:</strong></p>
   <blockquote> A type that satisfies the <code class="highlight"><span class="n">ContinuableFuture</span></code> requirements for the value type <code class="highlight"><span class="n">R</span></code> </blockquote>
   <p>In the <em>Operational Semantics</em> column:</p>
   <p><strong>Replace:</strong></p>
   <blockquote> in the associated shared state of the resulting Future. </blockquote>
   <p><strong>With:</strong></p>
   <blockquote> in the resulting ContinuableFuture. </blockquote>
   <h4 class="heading settled" data-level="2.14.6" id="wording_p0443_twoway_t"><span class="secno">2.14.6. </span><span class="content"><code class="highlight"><span class="n">twoway_t</span></code> Customization Points</span><a class="self-link" href="#wording_p0443_twoway_t"></a></h4>
   <p><strong>Replace:</strong></p>
   <blockquote> it is <code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">experimental</span><span class="o">::</span><span class="n">future</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span></code> </blockquote>
   <p><strong>With:</strong></p>
   <blockquote> it is a <code class="highlight"><span class="n">execution</span><span class="o">::</span><span class="n">continuable_future</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span> <span class="n">E1</span><span class="o">></span></code> </blockquote>
   <h4 class="heading settled" data-level="2.14.7" id="wording_p0443_single_t"><span class="secno">2.14.7. </span><span class="content"><code class="highlight"><span class="n">single_t</span></code> Customization Points</span><a class="self-link" href="#wording_p0443_single_t"></a></h4>
   <p><strong>Replace:</strong></p>
   <blockquote> it is <code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">experimental</span><span class="o">::</span><span class="n">future</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span></code> </blockquote>
   <p><strong>With:</strong></p>
   <blockquote> it is <code class="highlight"><span class="n">execution</span><span class="o">::</span><span class="n">continuable_future</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span> <span class="n">E1</span><span class="o">></span></code> </blockquote>
   <h4 class="heading settled" data-level="2.14.8" id="wording_p0443_blocking_and_directionality_properties"><span class="secno">2.14.8. </span><span class="content">Properties To Indicate If Blocking And Directionality May Be Adapted</span><a class="self-link" href="#wording_p0443_blocking_and_directionality_properties"></a></h4>
   <p>Remove <code class="highlight"><span class="n">twoway_t</span></code> from the <strong>Requirements</strong> column of the Table.</p>
   <h4 class="heading settled" data-level="2.14.9" id="wording_p0443_erasing_executor"><span class="secno">2.14.9. </span><span class="content">Class Template <code class="highlight"><span class="n">executor</span></code></span><a class="self-link" href="#wording_p0443_erasing_executor"></a></h4>
   <p><strong>Replace:</strong></p>
   <blockquote>
<pre class="highlight"><span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">Function</span><span class="o">></span>
  <span class="n">std</span><span class="o">::</span><span class="n">experimental</span><span class="o">::</span><span class="n">future</span><span class="o">&lt;</span><span class="n">result_of_t</span><span class="o">&lt;</span><span class="n">decay_t</span><span class="o">&lt;</span><span class="n">Function</span><span class="o">></span><span class="p">()</span><span class="o">>></span>
    <span class="n">twoway_execute</span><span class="p">(</span><span class="n">Function</span><span class="o">&amp;&amp;</span> <span class="n">f</span><span class="p">)</span> <span class="k">const</span>
</pre>
   </blockquote>
   <p><strong>With:</strong></p>
   <blockquote>
<pre class="highlight"><span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">Function</span><span class="o">></span>
  <span class="n">execution</span><span class="o">::</span><span class="n">semi_future</span><span class="o">&lt;</span><span class="n">result_of_t</span><span class="o">&lt;</span><span class="n">decay_t</span><span class="o">&lt;</span><span class="n">Function</span><span class="o">></span><span class="p">()</span><span class="o">>></span>
    <span class="n">twoway_execute</span><span class="p">(</span><span class="n">Function</span><span class="o">&amp;&amp;</span> <span class="n">f</span><span class="p">)</span> <span class="k">const</span>
</pre>
   </blockquote>
   <p><strong>Replace:</strong></p>
   <blockquote>
<pre class="highlight"><span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">Function</span><span class="p">,</span> <span class="k">class</span> <span class="nc">ResultFactory</span><span class="p">,</span> <span class="k">class</span> <span class="nc">SharedFactory</span><span class="o">></span>
  <span class="n">std</span><span class="o">::</span><span class="n">experimental</span><span class="o">::</span><span class="n">future</span><span class="o">&lt;</span><span class="n">result_of_t</span><span class="o">&lt;</span><span class="n">decay_t</span><span class="o">&lt;</span><span class="n">ResultFactory</span><span class="o">></span><span class="p">()</span><span class="o">>></span>
    <span class="n">bulk_twoway_execute</span><span class="p">(</span><span class="n">Function</span><span class="o">&amp;&amp;</span> <span class="n">f</span><span class="p">,</span> <span class="kt">size_t</span> <span class="n">n</span><span class="p">,</span> <span class="n">ResultFactory</span><span class="o">&amp;&amp;</span> <span class="n">rf</span><span class="p">,</span> <span class="n">SharedFactory</span><span class="o">&amp;&amp;</span> <span class="n">sf</span><span class="p">)</span> <span class="k">const</span><span class="p">;</span>
</pre>
   </blockquote>
   <p><strong>With:</strong></p>
   <blockquote>
<pre class="highlight"><span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">Function</span><span class="p">,</span> <span class="k">class</span> <span class="nc">ResultFactory</span><span class="p">,</span> <span class="k">class</span> <span class="nc">SharedFactory</span><span class="o">></span>
  <span class="n">execution</span><span class="o">::</span><span class="n">semi_future</span><span class="o">&lt;</span><span class="n">result_of_t</span><span class="o">&lt;</span><span class="n">decay_t</span><span class="o">&lt;</span><span class="n">ResultFactory</span><span class="o">></span><span class="p">()</span><span class="o">>></span>
    <span class="n">bulk_twoway_execute</span><span class="p">(</span><span class="n">Function</span><span class="o">&amp;&amp;</span> <span class="n">f</span><span class="p">,</span> <span class="kt">size_t</span> <span class="n">n</span><span class="p">,</span> <span class="n">ResultFactory</span><span class="o">&amp;&amp;</span> <span class="n">rf</span><span class="p">,</span> <span class="n">SharedFactory</span><span class="o">&amp;&amp;</span> <span class="n">sf</span><span class="p">)</span> <span class="k">const</span><span class="p">;</span>
</pre>
   </blockquote>
   <h4 class="heading settled" data-level="2.14.10" id="wording_p0443_erasing_executor_operations"><span class="secno">2.14.10. </span><span class="content"><code class="highlight"><span class="n">executor</span></code> Operations</span><a class="self-link" href="#wording_p0443_erasing_executor_operations"></a></h4>
   <p><strong>Replace:</strong></p>
   <blockquote>
<pre class="highlight"><span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">Function</span><span class="o">></span>
  <span class="n">std</span><span class="o">::</span><span class="n">experimental</span><span class="o">::</span><span class="n">future</span><span class="o">&lt;</span><span class="n">result_of_t</span><span class="o">&lt;</span><span class="n">decay_t</span><span class="o">&lt;</span><span class="n">Function</span><span class="o">></span><span class="p">()</span><span class="o">>></span>
    <span class="n">twoway_execute</span><span class="p">(</span><span class="n">Function</span><span class="o">&amp;&amp;</span> <span class="n">f</span><span class="p">)</span> <span class="k">const</span>
</pre>
   </blockquote>
   <p><strong>With:</strong></p>
   <blockquote>
<pre class="highlight"><span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">Function</span><span class="o">></span>
  <span class="cm">/* implementation-defined future type */</span>
    <span class="n">twoway_execute</span><span class="p">(</span><span class="n">Function</span><span class="o">&amp;&amp;</span> <span class="n">f</span><span class="p">)</span> <span class="k">const</span>
</pre>
   </blockquote>
   <p><strong>Replace:</strong></p>
   <blockquote> <em>Returns:</em> A future, whose shared state is made ready when the future returned by <code class="highlight"><span class="n">e</span><span class="p">.</span><span class="n">twoway_execute</span><span class="p">(</span><span class="n">f2</span><span class="p">)</span></code> is made ready, containing the result of <code class="highlight"><span class="n">f1</span><span class="p">()</span></code> or any
  exception thrown by <code class="highlight"><span class="n">f1</span><span class="p">()</span></code>.
[ <em>Note:</em> <code class="highlight"><span class="n">e2</span><span class="p">.</span><span class="n">twoway_execute</span><span class="p">(</span><span class="n">f2</span><span class="p">)</span></code> may return any future type that satisfies the <code class="highlight"><span class="n">Future</span></code> requirements, and not necessarily
One possible implementation approach is for the polymorphic wrapper to attach a
  continuation to the inner future via that object’s <code class="highlight"><span class="n">then</span><span class="p">()</span></code> member function.
When invoked, this continuation stores the result in the outer future’s
  associated shared state and makes that shared state ready.
— <em>end note</em> ] </blockquote>
   <p><strong>With:</strong></p>
   <blockquote> <em>Returns:</em> A value whose type satisfies the <code class="highlight"><span class="n">ContinuableFuture</span></code> requirements.
The returned future is <a data-link-type="dfn" href="#fulfillment" id="ref-for-fulfillment①②">fulfilled</a> when <code class="highlight"><span class="n">f1</span><span class="p">()</span></code> completes execution, with
  the result of <code class="highlight"><span class="n">f1</span><span class="p">()</span></code> (if <code class="highlight"><span class="k">decltype</span><span class="p">(</span><span class="n">f1</span><span class="p">())</span></code> is <code class="highlight" data-span-tag="non-"><span class="kt">void</span></code>), valueless completion
  (if <code class="highlight"><span class="k">decltype</span><span class="p">(</span><span class="n">f1</span><span class="p">())</span></code> is <code class="highlight"><span class="kt">void</span></code>), or any exception thrown by <code class="highlight"><span class="n">f1</span><span class="p">()</span></code>. </blockquote>
   <p><strong>Replace:</strong></p>
   <blockquote>
<pre class="highlight"><span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">Function</span><span class="p">,</span> <span class="k">class</span> <span class="nc">ResultFactory</span><span class="p">,</span> <span class="k">class</span> <span class="nc">SharedFactory</span><span class="o">></span>
  <span class="n">std</span><span class="o">::</span><span class="n">experimental</span><span class="o">::</span><span class="n">future</span><span class="o">&lt;</span><span class="n">result_of_t</span><span class="o">&lt;</span><span class="n">decay_t</span><span class="o">&lt;</span><span class="n">ResultFactory</span><span class="o">></span><span class="p">()</span><span class="o">>></span>
    <span class="kt">void</span> <span class="n">bulk_twoway_execute</span><span class="p">(</span><span class="n">Function</span><span class="o">&amp;&amp;</span> <span class="n">f</span><span class="p">,</span> <span class="kt">size_t</span> <span class="n">n</span><span class="p">,</span> <span class="n">ResultFactory</span><span class="o">&amp;&amp;</span> <span class="n">rf</span><span class="p">,</span> <span class="n">SharedFactory</span><span class="o">&amp;&amp;</span> <span class="n">sf</span><span class="p">)</span> <span class="k">const</span><span class="p">;</span>
</pre>
   </blockquote>
   <p><strong>With:</strong></p>
   <blockquote>
<pre class="highlight"><span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">Function</span><span class="p">,</span> <span class="k">class</span> <span class="nc">ResultFactory</span><span class="p">,</span> <span class="k">class</span> <span class="nc">SharedFactory</span><span class="o">></span>
  <span class="cm">/* implementation-defined future type */</span>
     <span class="n">bulk_twoway_execute</span><span class="p">(</span><span class="n">Function</span><span class="o">&amp;&amp;</span> <span class="n">f</span><span class="p">,</span> <span class="kt">size_t</span> <span class="n">n</span><span class="p">,</span> <span class="n">ResultFactory</span><span class="o">&amp;&amp;</span> <span class="n">rf</span><span class="p">,</span> <span class="n">SharedFactory</span><span class="o">&amp;&amp;</span> <span class="n">sf</span><span class="p">)</span> <span class="k">const</span><span class="p">;</span>
</pre>
   </blockquote>
   <p><strong>Replace:</strong></p>
   <blockquote> <em>Returns:</em> A future, whose shared state is made ready when the future returned
  by e.bulk_twoway_execute(f2, n, rf2, sf2) is made ready, containing the result
  in r1 (if decltype(rf1()) is non-void) or any exception thrown by an
  invocation <code class="highlight"><span class="n">f1</span></code>.
[ <em>Note:</em> <code class="highlight"><span class="n">e</span><span class="p">.</span><span class="n">bulk_twoway_execute</span><span class="p">(</span><span class="n">f2</span><span class="p">)</span></code> may return any future type that satisfies the <code class="highlight"><span class="n">Future</span></code> requirements, and not necessarily <code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">experimental</span><span class="o">::</span><span class="n">future</span></code>.
One possible implementation approach is for the polymorphic wrapper to attach a
  continuation to the inner future via that object’s <code class="highlight"><span class="n">then</span><span class="p">()</span></code> member function.
When invoked, this continuation stores the result in the outer future’s
  associated shared state and makes that shared state ready.
— <em>end note</em> ] </blockquote>
   <p><strong>With:</strong></p>
   <p><em>Returns:</em></p>
   <blockquote> A value whose type satisfies the <code class="highlight"><span class="n">ContinuableFuture</span></code> requirements.
The returned future is <a data-link-type="dfn" href="#fulfillment" id="ref-for-fulfillment①③">fulfilled</a> when <code class="highlight"><span class="n">f1</span><span class="p">()</span></code> completes execution, with
  the result in <code class="highlight"><span class="n">r1</span></code> (if <code class="highlight"><span class="k">decltype</span><span class="p">(</span><span class="n">rf1</span><span class="p">())</span></code> is <code class="highlight" data-span-tag="non-"><span class="kt">void</span></code>), valueless completion
  (if <code class="highlight"><span class="k">decltype</span><span class="p">(</span><span class="n">rf1</span><span class="p">())</span></code> is void), or any exception thrown by an invocation <code class="highlight"><span class="n">f1</span></code>. </blockquote>
   <h4 class="heading settled" data-level="2.14.11" id="wording_p0443_static_thread_pool"><span class="secno">2.14.11. </span><span class="content"><code class="highlight"><span class="n">static_thread_pool</span></code> Executor Type</span><a class="self-link" href="#wording_p0443_static_thread_pool"></a></h4>
   <p><strong>Replace:</strong></p>
   <blockquote>
<pre class="highlight"><span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">Function</span><span class="o">></span>
  <span class="n">std</span><span class="o">::</span><span class="n">experimental</span><span class="o">::</span><span class="n">future</span><span class="o">&lt;</span><span class="n">result_of_t</span><span class="o">&lt;</span><span class="n">decay_t</span><span class="o">&lt;</span><span class="n">Function</span><span class="o">></span><span class="p">()</span><span class="o">>></span>
    <span class="n">twoway_execute</span><span class="p">(</span><span class="n">Function</span><span class="o">&amp;&amp;</span> <span class="n">f</span><span class="p">)</span> <span class="k">const</span>

<span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">Function</span><span class="p">,</span> <span class="k">class</span> <span class="nc">Future</span><span class="o">></span>
  <span class="n">std</span><span class="o">::</span><span class="n">experimental</span><span class="o">::</span><span class="n">future</span><span class="o">&lt;</span><span class="n">result_of_t</span><span class="o">&lt;</span><span class="n">decay_t</span><span class="o">&lt;</span><span class="n">Function</span><span class="o">></span><span class="p">(</span><span class="n">decay_t</span><span class="o">&lt;</span><span class="n">Future</span><span class="o">></span><span class="p">)</span><span class="o">>></span>
    <span class="n">then_execute</span><span class="p">(</span><span class="n">Function</span><span class="o">&amp;&amp;</span> <span class="n">f</span><span class="p">,</span> <span class="n">Future</span><span class="o">&amp;&amp;</span> <span class="n">pred</span><span class="p">)</span> <span class="k">const</span><span class="p">;</span>

<span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">Function</span><span class="p">,</span> <span class="k">class</span> <span class="nc">SharedFactory</span><span class="o">></span>
  <span class="kt">void</span> <span class="n">bulk_execute</span><span class="p">(</span><span class="n">Function</span><span class="o">&amp;&amp;</span> <span class="n">f</span><span class="p">,</span> <span class="kt">size_t</span> <span class="n">n</span><span class="p">,</span> <span class="n">SharedFactory</span><span class="o">&amp;&amp;</span> <span class="n">sf</span><span class="p">)</span> <span class="k">const</span><span class="p">;</span>

<span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">Function</span><span class="p">,</span> <span class="k">class</span> <span class="nc">ResultFactory</span><span class="p">,</span> <span class="k">class</span> <span class="nc">SharedFactory</span><span class="o">></span>
  <span class="n">std</span><span class="o">::</span><span class="n">experimental</span><span class="o">::</span><span class="n">future</span><span class="o">&lt;</span><span class="n">result_of_t</span><span class="o">&lt;</span><span class="n">decay_t</span><span class="o">&lt;</span><span class="n">ResultFactory</span><span class="o">></span><span class="p">()</span><span class="o">>></span>
    <span class="kt">void</span> <span class="n">bulk_twoway_execute</span><span class="p">(</span><span class="n">Function</span><span class="o">&amp;&amp;</span> <span class="n">f</span><span class="p">,</span> <span class="kt">size_t</span> <span class="n">n</span><span class="p">,</span> <span class="n">ResultFactory</span><span class="o">&amp;&amp;</span> <span class="n">rf</span><span class="p">,</span> <span class="n">SharedFactory</span><span class="o">&amp;&amp;</span> <span class="n">sf</span><span class="p">)</span> <span class="k">const</span><span class="p">;</span>
</pre>
   </blockquote>
   <p><strong>With:</strong></p>
   <blockquote>
<pre class="highlight"><span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">Function</span><span class="o">></span>
  <span class="n">std</span><span class="o">::</span><span class="n">execution</span><span class="o">::</span><span class="n">continuable_future</span><span class="o">&lt;</span><span class="n">result_of_t</span><span class="o">&lt;</span><span class="n">decay_t</span><span class="o">&lt;</span><span class="n">Function</span><span class="o">></span><span class="p">()</span><span class="o">></span><span class="p">,</span> <span class="n">C</span><span class="o">></span>
    <span class="n">twoway_execute</span><span class="p">(</span><span class="n">Function</span><span class="o">&amp;&amp;</span> <span class="n">f</span><span class="p">)</span> <span class="k">const</span>

<span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">Function</span><span class="p">,</span> <span class="k">class</span> <span class="nc">Future</span><span class="o">></span>
  <span class="n">execution</span><span class="o">::</span><span class="n">continuable_future</span><span class="o">&lt;</span><span class="n">result_of_t</span><span class="o">&lt;</span><span class="n">decay_t</span><span class="o">&lt;</span><span class="n">Function</span><span class="o">></span><span class="p">(</span><span class="n">decay_t</span><span class="o">&lt;</span><span class="n">Future</span><span class="o">></span><span class="p">)</span><span class="o">></span><span class="p">,</span> <span class="n">C</span><span class="o">></span>
    <span class="n">then_execute</span><span class="p">(</span><span class="n">Function</span><span class="o">&amp;&amp;</span> <span class="n">f</span><span class="p">,</span> <span class="n">Future</span><span class="o">&amp;&amp;</span> <span class="n">pred</span><span class="p">)</span> <span class="k">const</span><span class="p">;</span>

<span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">Function</span><span class="p">,</span> <span class="k">class</span> <span class="nc">SharedFactory</span><span class="o">></span>
  <span class="kt">void</span> <span class="n">bulk_execute</span><span class="p">(</span><span class="n">Function</span><span class="o">&amp;&amp;</span> <span class="n">f</span><span class="p">,</span> <span class="kt">size_t</span> <span class="n">n</span><span class="p">,</span> <span class="n">SharedFactory</span><span class="o">&amp;&amp;</span> <span class="n">sf</span><span class="p">)</span> <span class="k">const</span><span class="p">;</span>

<span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">Function</span><span class="p">,</span> <span class="k">class</span> <span class="nc">ResultFactory</span><span class="p">,</span> <span class="k">class</span> <span class="nc">SharedFactory</span><span class="o">></span>
  <span class="n">execution</span><span class="o">::</span><span class="n">continuable_future</span><span class="o">&lt;</span><span class="n">result_of_t</span><span class="o">&lt;</span><span class="n">decay_t</span><span class="o">&lt;</span><span class="n">ResultFactory</span><span class="o">></span><span class="p">()</span><span class="o">>></span><span class="p">,</span> <span class="n">C</span><span class="o">></span>
    <span class="kt">void</span> <span class="n">bulk_twoway_execute</span><span class="p">(</span><span class="n">Function</span><span class="o">&amp;&amp;</span> <span class="n">f</span><span class="p">,</span> <span class="kt">size_t</span> <span class="n">n</span><span class="p">,</span> <span class="n">ResultFactory</span><span class="o">&amp;&amp;</span> <span class="n">rf</span><span class="p">,</span> <span class="n">SharedFactory</span><span class="o">&amp;&amp;</span> <span class="n">sf</span><span class="p">)</span> <span class="k">const</span>
</pre>
    <p>Replace the same instances in the documentation section below the main code block.</p>
   </blockquote>
  </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="index"><span class="content">Index</span><a class="self-link" href="#index"></a></h2>
  <h3 class="no-num no-ref heading settled" id="index-defined-here"><span class="content">Terms defined by this specification</span><a class="self-link" href="#index-defined-here"></a></h3>
  <ul class="index">
   <li><a href="#asynchronous-result">asynchronous result</a><span>, in §2.1</span>
   <li><a href="#attachment">attach</a><span>, in §2.1</span>
   <li><a href="#attachment">attached</a><span>, in §2.1</span>
   <li><a href="#attachment">attaches</a><span>, in §2.1</span>
   <li><a href="#attachment">attachment</a><span>, in §2.1</span>
   <li><a href="#cancellation">cancel</a><span>, in §2.1</span>
   <li><a href="#cancellation">cancellation</a><span>, in §2.1</span>
   <li><a href="#cancellation-notifier">cancellation notifier</a><span>, in §2.1</span>
   <li><a href="#cancellation">cancelled</a><span>, in §2.1</span>
   <li><a href="#cancellation">cancels</a><span>, in §2.1</span>
   <li><a href="#continuable-future">continuable future</a><span>, in §2.5</span>
   <li><a href="#continuations">continuations</a><span>, in §2.1</span>
   <li><a href="#fulfillment">fulfill</a><span>, in §2.1</span>
   <li><a href="#fulfillment">fulfilled</a><span>, in §2.1</span>
   <li><a href="#fulfillment">fulfillment</a><span>, in §2.1</span>
   <li><a href="#fulfillment">fulfills</a><span>, in §2.1</span>
   <li><a href="#future">future</a><span>, in §2.1</span>
   <li><a href="#future-continuation">future continuation</a><span>, in §2.2</span>
   <li><a href="#future-exception-propagation">future exception propagation</a><span>, in §1.3</span>
   <li><a href="#future-value-propagation">future value propagation</a><span>, in §1.3</span>
   <li><a href="#invalid">invalid</a><span>, in §2.1</span>
   <li><a href="#non-uniquely-owned-future">non-uniquely owned future</a><span>, in §2.1</span>
   <li><a href="#not-ready">not ready</a><span>, in §2.1</span>
   <li><a href="#promise">promise</a><span>, in §2.1</span>
   <li><a href="#ready">ready</a><span>, in §2.1</span>
   <li><a href="#semi-future">semi future</a><span>, in §2.4</span>
   <li><a href="#shared-future">shared future</a><span>, in §2.6</span>
   <li><a href="#status">status</a><span>, in §2.1</span>
   <li><a href="#uniquely-owned-future">uniquely owned future</a><span>, in §2.1</span>
  </ul>
  <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-p0701r0">[P0701r0]
   <dd>Bryce Adelstein Lelbach. <a href="https://wg21.link/p0701r0">Back to the std2::future</a>. URL: <a href="https://wg21.link/p0701r0">https://wg21.link/p0701r0</a>
   <dt id="biblio-p0701r1">[P0701r1]
   <dd>Bryce Adelstein Lelbach. <a href="https://wg21.link/p0701r1">Back to the std2::future</a>. URL: <a href="https://wg21.link/p0701r1">https://wg21.link/p0701r1</a>
   <dt id="biblio-p0783r0">[P0783r0]
   <dd>Lee Howes, Andrii Grynenko, Jay Feldblum. <a href="https://wg21.link/p0783r0">Continuations without overcomplicating the future</a>. URL: <a href="https://wg21.link/p0783r0">https://wg21.link/p0783r0</a>
   <dt id="biblio-p0904r0">[P0904r0]
   <dd>Lee Howes, Andrii Grynenko, Jay Feldblum. <a href="https://wg21.link/p0904r0">A strawman Future API</a>. URL: <a href="https://wg21.link/p0904r0">https://wg21.link/p0904r0</a>
  </dl>
  <aside class="dfn-panel" data-for="future">
   <b><a href="#future">#future</a></b><b>Referenced in:</b>
   <ul>
    <li><a href="#ref-for-future">1.5. SemiFuture and .via For Composition</a>
    <li><a href="#ref-for-future①">2.1. The Future/Promise Execution Model</a> <a href="#ref-for-future②">(2)</a> <a href="#ref-for-future③">(3)</a> <a href="#ref-for-future④">(4)</a> <a href="#ref-for-future⑤">(5)</a> <a href="#ref-for-future⑥">(6)</a> <a href="#ref-for-future⑦">(7)</a> <a href="#ref-for-future⑧">(8)</a> <a href="#ref-for-future⑨">(9)</a> <a href="#ref-for-future①⓪">(10)</a> <a href="#ref-for-future①①">(11)</a> <a href="#ref-for-future①②">(12)</a> <a href="#ref-for-future①③">(13)</a> <a href="#ref-for-future①④">(14)</a> <a href="#ref-for-future①⑤">(15)</a> <a href="#ref-for-future①⑥">(16)</a> <a href="#ref-for-future①⑦">(17)</a> <a href="#ref-for-future①⑧">(18)</a> <a href="#ref-for-future①⑨">(19)</a> <a href="#ref-for-future②⓪">(20)</a> <a href="#ref-for-future②①">(21)</a> <a href="#ref-for-future②②">(22)</a> <a href="#ref-for-future②③">(23)</a> <a href="#ref-for-future②④">(24)</a> <a href="#ref-for-future②⑤">(25)</a> <a href="#ref-for-future②⑥">(26)</a> <a href="#ref-for-future②⑦">(27)</a> <a href="#ref-for-future②⑧">(28)</a> <a href="#ref-for-future②⑨">(29)</a> <a href="#ref-for-future③⓪">(30)</a> <a href="#ref-for-future③①">(31)</a>
    <li><a href="#ref-for-future③②">2.2. FutureContinuation Requirements</a> <a href="#ref-for-future③③">(2)</a> <a href="#ref-for-future③④">(3)</a> <a href="#ref-for-future③⑤">(4)</a>
    <li><a href="#ref-for-future③⑥">2.4. SemiFuture Requirements</a>
    <li><a href="#ref-for-future③⑦">2.5. ContinuableFuture Requirements</a>
    <li><a href="#ref-for-future③⑧">2.7. std::execution::promise</a> <a href="#ref-for-future③⑨">(2)</a> <a href="#ref-for-future④⓪">(3)</a> <a href="#ref-for-future④①">(4)</a>
    <li><a href="#ref-for-future④②">2.8. std::execution::semi_future</a> <a href="#ref-for-future④③">(2)</a> <a href="#ref-for-future④④">(3)</a> <a href="#ref-for-future④⑤">(4)</a> <a href="#ref-for-future④⑥">(5)</a> <a href="#ref-for-future④⑦">(6)</a> <a href="#ref-for-future④⑧">(7)</a> <a href="#ref-for-future④⑨">(8)</a>
    <li><a href="#ref-for-future⑤⓪">2.9. std::execution::continuable_future</a> <a href="#ref-for-future⑤①">(2)</a> <a href="#ref-for-future⑤②">(3)</a> <a href="#ref-for-future⑤③">(4)</a> <a href="#ref-for-future⑤④">(5)</a> <a href="#ref-for-future⑤⑤">(6)</a> <a href="#ref-for-future⑤⑥">(7)</a> <a href="#ref-for-future⑤⑦">(8)</a>
    <li><a href="#ref-for-future⑤⑧">2.11. std::execution::make_promise_contract</a> <a href="#ref-for-future⑤⑨">(2)</a>
   </ul>
  </aside>
  <aside class="dfn-panel" data-for="continuations">
   <b><a href="#continuations">#continuations</a></b><b>Referenced in:</b>
   <ul>
    <li><a href="#ref-for-continuations">2.1. The Future/Promise Execution Model</a> <a href="#ref-for-continuations①">(2)</a> <a href="#ref-for-continuations②">(3)</a> <a href="#ref-for-continuations③">(4)</a> <a href="#ref-for-continuations④">(5)</a> <a href="#ref-for-continuations⑤">(6)</a> <a href="#ref-for-continuations⑥">(7)</a> <a href="#ref-for-continuations⑦">(8)</a> <a href="#ref-for-continuations⑧">(9)</a> <a href="#ref-for-continuations⑨">(10)</a> <a href="#ref-for-continuations①⓪">(11)</a> <a href="#ref-for-continuations①①">(12)</a> <a href="#ref-for-continuations①②">(13)</a> <a href="#ref-for-continuations①③">(14)</a>
   </ul>
  </aside>
  <aside class="dfn-panel" data-for="uniquely-owned-future">
   <b><a href="#uniquely-owned-future">#uniquely-owned-future</a></b><b>Referenced in:</b>
   <ul>
    <li><a href="#ref-for-uniquely-owned-future">2.1. The Future/Promise Execution Model</a> <a href="#ref-for-uniquely-owned-future①">(2)</a>
   </ul>
  </aside>
  <aside class="dfn-panel" data-for="non-uniquely-owned-future">
   <b><a href="#non-uniquely-owned-future">#non-uniquely-owned-future</a></b><b>Referenced in:</b>
   <ul>
    <li><a href="#ref-for-non-uniquely-owned-future">2.1. The Future/Promise Execution Model</a>
    <li><a href="#ref-for-non-uniquely-owned-future①">2.6. SharedFuture Requirements</a>
   </ul>
  </aside>
  <aside class="dfn-panel" data-for="promise">
   <b><a href="#promise">#promise</a></b><b>Referenced in:</b>
   <ul>
    <li><a href="#ref-for-promise">2.1. The Future/Promise Execution Model</a> <a href="#ref-for-promise①">(2)</a> <a href="#ref-for-promise②">(3)</a> <a href="#ref-for-promise③">(4)</a> <a href="#ref-for-promise④">(5)</a> <a href="#ref-for-promise⑤">(6)</a> <a href="#ref-for-promise⑥">(7)</a> <a href="#ref-for-promise⑦">(8)</a> <a href="#ref-for-promise⑧">(9)</a>
    <li><a href="#ref-for-promise⑨">2.3. Promise Requirements</a>
    <li><a href="#ref-for-promise①⓪">2.7. std::execution::promise</a> <a href="#ref-for-promise①①">(2)</a> <a href="#ref-for-promise①②">(3)</a> <a href="#ref-for-promise①③">(4)</a> <a href="#ref-for-promise①④">(5)</a> <a href="#ref-for-promise①⑤">(6)</a> <a href="#ref-for-promise①⑥">(7)</a> <a href="#ref-for-promise①⑦">(8)</a> <a href="#ref-for-promise①⑧">(9)</a> <a href="#ref-for-promise①⑨">(10)</a> <a href="#ref-for-promise②⓪">(11)</a>
    <li><a href="#ref-for-promise②①">2.8. std::execution::semi_future</a> <a href="#ref-for-promise②②">(2)</a> <a href="#ref-for-promise②③">(3)</a> <a href="#ref-for-promise②④">(4)</a>
    <li><a href="#ref-for-promise②⑤">2.9. std::execution::continuable_future</a> <a href="#ref-for-promise②⑥">(2)</a> <a href="#ref-for-promise②⑦">(3)</a> <a href="#ref-for-promise②⑧">(4)</a>
    <li><a href="#ref-for-promise②⑨">2.11. std::execution::make_promise_contract</a> <a href="#ref-for-promise③⓪">(2)</a> <a href="#ref-for-promise③①">(3)</a> <a href="#ref-for-promise③②">(4)</a>
   </ul>
  </aside>
  <aside class="dfn-panel" data-for="status">
   <b><a href="#status">#status</a></b><b>Referenced in:</b>
   <ul>
    <li><a href="#ref-for-status">2.1. The Future/Promise Execution Model</a> <a href="#ref-for-status①">(2)</a> <a href="#ref-for-status②">(3)</a> <a href="#ref-for-status③">(4)</a> <a href="#ref-for-status④">(5)</a> <a href="#ref-for-status⑤">(6)</a> <a href="#ref-for-status⑥">(7)</a> <a href="#ref-for-status⑦">(8)</a> <a href="#ref-for-status⑧">(9)</a> <a href="#ref-for-status⑨">(10)</a> <a href="#ref-for-status①⓪">(11)</a>
   </ul>
  </aside>
  <aside class="dfn-panel" data-for="ready">
   <b><a href="#ready">#ready</a></b><b>Referenced in:</b>
   <ul>
    <li><a href="#ref-for-ready">2.1. The Future/Promise Execution Model</a> <a href="#ref-for-ready①">(2)</a> <a href="#ref-for-ready②">(3)</a> <a href="#ref-for-ready③">(4)</a> <a href="#ref-for-ready④">(5)</a>
    <li><a href="#ref-for-ready⑤">2.12. Generic Future Blocking Functions</a> <a href="#ref-for-ready⑥">(2)</a>
   </ul>
  </aside>
  <aside class="dfn-panel" data-for="not-ready">
   <b><a href="#not-ready">#not-ready</a></b><b>Referenced in:</b>
   <ul>
    <li><a href="#ref-for-not-ready">2.1. The Future/Promise Execution Model</a> <a href="#ref-for-not-ready①">(2)</a> <a href="#ref-for-not-ready②">(3)</a>
   </ul>
  </aside>
  <aside class="dfn-panel" data-for="invalid">
   <b><a href="#invalid">#invalid</a></b><b>Referenced in:</b>
   <ul>
    <li><a href="#ref-for-invalid">2.1. The Future/Promise Execution Model</a> <a href="#ref-for-invalid①">(2)</a> <a href="#ref-for-invalid②">(3)</a> <a href="#ref-for-invalid③">(4)</a>
    <li><a href="#ref-for-invalid④">2.12. Generic Future Blocking Functions</a>
   </ul>
  </aside>
  <aside class="dfn-panel" data-for="asynchronous-result">
   <b><a href="#asynchronous-result">#asynchronous-result</a></b><b>Referenced in:</b>
   <ul>
    <li><a href="#ref-for-asynchronous-result">2.1. The Future/Promise Execution Model</a> <a href="#ref-for-asynchronous-result①">(2)</a> <a href="#ref-for-asynchronous-result②">(3)</a> <a href="#ref-for-asynchronous-result③">(4)</a> <a href="#ref-for-asynchronous-result④">(5)</a> <a href="#ref-for-asynchronous-result⑤">(6)</a> <a href="#ref-for-asynchronous-result⑥">(7)</a>
    <li><a href="#ref-for-asynchronous-result⑦">2.12. Generic Future Blocking Functions</a>
   </ul>
  </aside>
  <aside class="dfn-panel" data-for="cancellation-notifier">
   <b><a href="#cancellation-notifier">#cancellation-notifier</a></b><b>Referenced in:</b>
   <ul>
    <li><a href="#ref-for-cancellation-notifier">1.4. The Future Cancellation Model</a> <a href="#ref-for-cancellation-notifier①">(2)</a>
    <li><a href="#ref-for-cancellation-notifier②">2.1. The Future/Promise Execution Model</a> <a href="#ref-for-cancellation-notifier③">(2)</a>
   </ul>
  </aside>
  <aside class="dfn-panel" data-for="cancellation">
   <b><a href="#cancellation">#cancellation</a></b><b>Referenced in:</b>
   <ul>
    <li><a href="#ref-for-cancellation">2.1. The Future/Promise Execution Model</a>
   </ul>
  </aside>
  <aside class="dfn-panel" data-for="attachment">
   <b><a href="#attachment">#attachment</a></b><b>Referenced in:</b>
   <ul>
    <li><a href="#ref-for-attachment">1.1. The Future/Promise Execution Model</a>
    <li><a href="#ref-for-attachment①">2.1. The Future/Promise Execution Model</a> <a href="#ref-for-attachment②">(2)</a>
   </ul>
  </aside>
  <aside class="dfn-panel" data-for="fulfillment">
   <b><a href="#fulfillment">#fulfillment</a></b><b>Referenced in:</b>
   <ul>
    <li><a href="#ref-for-fulfillment">1.1. The Future/Promise Execution Model</a>
    <li><a href="#ref-for-fulfillment①">2.1. The Future/Promise Execution Model</a> <a href="#ref-for-fulfillment②">(2)</a> <a href="#ref-for-fulfillment③">(3)</a> <a href="#ref-for-fulfillment④">(4)</a> <a href="#ref-for-fulfillment⑤">(5)</a> <a href="#ref-for-fulfillment⑥">(6)</a>
    <li><a href="#ref-for-fulfillment⑦">2.5. ContinuableFuture Requirements</a> <a href="#ref-for-fulfillment⑧">(2)</a>
    <li><a href="#ref-for-fulfillment⑨">2.6. SharedFuture Requirements</a> <a href="#ref-for-fulfillment①⓪">(2)</a>
    <li><a href="#ref-for-fulfillment①①">2.12. Generic Future Blocking Functions</a>
    <li><a href="#ref-for-fulfillment①②">2.14.10. executor Operations</a> <a href="#ref-for-fulfillment①③">(2)</a>
   </ul>
  </aside>
  <aside class="dfn-panel" data-for="future-continuation">
   <b><a href="#future-continuation">#future-continuation</a></b><b>Referenced in:</b>
   <ul>
    <li><a href="#ref-for-future-continuation">2.2. FutureContinuation Requirements</a>
   </ul>
  </aside>
  <aside class="dfn-panel" data-for="shared-future">
   <b><a href="#shared-future">#shared-future</a></b><b>Referenced in:</b>
   <ul>
    <li><a href="#ref-for-shared-future">2.1. The Future/Promise Execution Model</a> <a href="#ref-for-shared-future①">(2)</a>
   </ul>
  </aside>
<script>/* script-dfn-panel */

        document.body.addEventListener("click", function(e) {
            var queryAll = function(sel) { return [].slice.call(document.querySelectorAll(sel)); }
            // Find the dfn element or panel, if any, that was clicked on.
            var el = e.target;
            var target;
            var hitALink = false;
            while(el.parentElement) {
                if(el.tagName == "A") {
                    // Clicking on a link in a <dfn> shouldn't summon the panel
                    hitALink = true;
                }
                if(el.classList.contains("dfn-paneled")) {
                    target = "dfn";
                    break;
                }
                if(el.classList.contains("dfn-panel")) {
                    target = "dfn-panel";
                    break;
                }
                el = el.parentElement;
            }
            if(target != "dfn-panel") {
                // Turn off any currently "on" or "activated" panels.
                queryAll(".dfn-panel.on, .dfn-panel.activated").forEach(function(el){
                    el.classList.remove("on");
                    el.classList.remove("activated");
                });
            }
            if(target == "dfn" && !hitALink) {
                // open the panel
                var dfnPanel = document.querySelector(".dfn-panel[data-for='" + el.id + "']");
                if(dfnPanel) {
                    console.log(dfnPanel);
                    dfnPanel.classList.add("on");
                    var rect = el.getBoundingClientRect();
                    dfnPanel.style.left = window.scrollX + rect.right + 5 + "px";
                    dfnPanel.style.top = window.scrollY + rect.top + "px";
                    var panelRect = dfnPanel.getBoundingClientRect();
                    var panelWidth = panelRect.right - panelRect.left;
                    if(panelRect.right > document.body.scrollWidth && (rect.left - (panelWidth + 5)) > 0) {
                        // Reposition, because the panel is overflowing
                        dfnPanel.style.left = window.scrollX + rect.left - (panelWidth + 5) + "px";
                    }
                } else {
                    console.log("Couldn't find .dfn-panel[data-for='" + el.id + "']");
                }
            } else if(target == "dfn-panel") {
                // Switch it to "activated" state, which pins it.
                el.classList.add("activated");
                el.style.left = null;
                el.style.top = null;
            }

        });
        </script>