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

/* color variables included separately for reliability */

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

	html {
	}

	body {
		counter-reset: example figure issue;

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	p {
		margin: 1em 0;
	}

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

	/* Do something nice. */

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

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

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

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

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

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

	img {
		border-style: none;
	}

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


/*
Alternate table alignment rules

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

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

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

Possible extra rowspan handling

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

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

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


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

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

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

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

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

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

		.toc li {
			clear: both;
		}

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

.outdated-warning span {
	display: block;
}

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

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

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

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

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



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

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

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

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

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

    del { background: #fcc; color: #000; text-decoration: line-through; }
    ins { background: #cfc; color: #000; }
    blockquote .highlight:not(.idl) { background: initial; margin: initial; padding: 0.5em }
    blockquote ul { background: inherit; }
    blockquote code.highlight:not(.idl) { padding: initial; }
    blockquote c-[a] { color: inherit; } /* Keyword.Declaration */
    blockquote c-[b] { color: inherit; } /* Keyword.Type */
    blockquote c-[c] { color: inherit; } /* Comment */
    blockquote c-[d] { color: inherit; } /* Comment.Multiline */
    blockquote c-[e] { color: inherit; } /* Name.Attribute */
    blockquote c-[f] { color: inherit; } /* Name.Tag */
    blockquote c-[g] { color: inherit; } /* Name.Variable */
    blockquote c-[k] { color: inherit; } /* Keyword */
    blockquote c-[l] { color: inherit; } /* Literal */
    blockquote c-[m] { color: inherit; } /* Literal.Number */
    blockquote c-[n] { color: inherit; } /* Name */
    blockquote c-[o] { color: inherit; } /* Operator */
    blockquote c-[p] { color: inherit; } /* Punctuation */
    blockquote c-[s] { color: inherit; } /* Literal.String */
    blockquote c-[t] { color: inherit; } /* Literal.String.Single */
    blockquote c-[u] { color: inherit; } /* Literal.String.Double */
    blockquote c-[cp] { color: inherit; } /* Comment.Preproc */
    blockquote c-[c1] { color: inherit; } /* Comment.Single */
    blockquote c-[cs] { color: inherit; } /* Comment.Special */
    blockquote c-[kc] { color: inherit; } /* Keyword.Constant */
    blockquote c-[kn] { color: inherit; } /* Keyword.Namespace */
    blockquote c-[kp] { color: inherit; } /* Keyword.Pseudo */
    blockquote c-[kr] { color: inherit; } /* Keyword.Reserved */
    blockquote c-[ld] { color: inherit; } /* Literal.Date */
    blockquote c-[nc] { color: inherit; } /* Name.Class */
    blockquote c-[no] { color: inherit; } /* Name.Constant */
    blockquote c-[nd] { color: inherit; } /* Name.Decorator */
    blockquote c-[ni] { color: inherit; } /* Name.Entity */
    blockquote c-[ne] { color: inherit; } /* Name.Exception */
    blockquote c-[nf] { color: inherit; } /* Name.Function */
    blockquote c-[nl] { color: inherit; } /* Name.Label */
    blockquote c-[nn] { color: inherit; } /* Name.Namespace */
    blockquote c-[py] { color: inherit; } /* Name.Property */
    blockquote c-[ow] { color: inherit; } /* Operator.Word */
    blockquote c-[mb] { color: inherit; } /* Literal.Number.Bin */
    blockquote c-[mf] { color: inherit; } /* Literal.Number.Float */
    blockquote c-[mh] { color: inherit; } /* Literal.Number.Hex */
    blockquote c-[mi] { color: inherit; } /* Literal.Number.Integer */
    blockquote c-[mo] { color: inherit; } /* Literal.Number.Oct */
    blockquote c-[sb] { color: inherit; } /* Literal.String.Backtick */
    blockquote c-[sc] { color: inherit; } /* Literal.String.Char */
    blockquote c-[sd] { color: inherit; } /* Literal.String.Doc */
    blockquote c-[se] { color: inherit; } /* Literal.String.Escape */
    blockquote c-[sh] { color: inherit; } /* Literal.String.Heredoc */
    blockquote c-[si] { color: inherit; } /* Literal.String.Interpol */
    blockquote c-[sx] { color: inherit; } /* Literal.String.Other */
    blockquote c-[sr] { color: inherit; } /* Literal.String.Regex */
    blockquote c-[ss] { color: inherit; } /* Literal.String.Symbol */
    blockquote c-[vc] { color: inherit; } /* Name.Variable.Class */
    blockquote c-[vg] { color: inherit; } /* Name.Variable.Global */
    blockquote c-[vi] { color: inherit; } /* Name.Variable.Instance */
    blockquote c-[il] { color: inherit; } /* Literal.Number.Integer.Long */
  </style>
  <meta content="Bikeshed version d5d58a306, updated Fri Jan 26 16:12:28 2024 -0800" name="generator">
  <link href="http://wg21.link/Pxxxx" rel="canonical">
  <link href="https://isocpp.org/favicon.ico" rel="icon">
  <meta content="6ba78ca589eaa1a79ec1d84409ceaae4cd56bac6" name="revision">
<style>/* Boilerplate: style-autolinks */
.css.css, .property.property, .descriptor.descriptor {
    color: var(--a-normal-text);
    font-size: inherit;
    font-family: inherit;
}
.css::before, .property::before, .descriptor::before {
    content: "‘";
}
.css::after, .property::after, .descriptor::after {
    content: "’";
}
.property, .descriptor {
    /* Don't wrap property and descriptor names */
    white-space: nowrap;
}
.type { /* CSS value <type> */
    font-style: italic;
}
pre .property::before, pre .property::after {
    content: "";
}
[data-link-type="property"]::before,
[data-link-type="propdesc"]::before,
[data-link-type="descriptor"]::before,
[data-link-type="value"]::before,
[data-link-type="function"]::before,
[data-link-type="at-rule"]::before,
[data-link-type="selector"]::before,
[data-link-type="maybe"]::before {
    content: "‘";
}
[data-link-type="property"]::after,
[data-link-type="propdesc"]::after,
[data-link-type="descriptor"]::after,
[data-link-type="value"]::after,
[data-link-type="function"]::after,
[data-link-type="at-rule"]::after,
[data-link-type="selector"]::after,
[data-link-type="maybe"]::after {
    content: "’";
}

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

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

[data-link-type=biblio] {
    white-space: pre;
}

@media (prefers-color-scheme: dark) {
    :root {
        --selflink-text: black;
        --selflink-bg: silver;
        --selflink-hover-text: white;
    }
}
</style>
<style>/* Boilerplate: style-colors */
/* Any --*-text not paired with a --*-bg is assumed to have a transparent bg */
:root {
    color-scheme: light dark;

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

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

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

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

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

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

    --heading-text: #005a9c;

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

    --algo-border: #def;

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

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

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

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

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

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

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

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

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

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

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

    --datacell-border: silver;

    --indexinfo-text: #707070;

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

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

    --editedrec-bg: darkorange;
}

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

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

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

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

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

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

        --heading-text: #8af;

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

        --algo-border: #456;

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

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

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

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

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

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

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

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

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

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

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

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

        --datacell-border: silver;

        --indexinfo-text: #aaa;

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

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

        --editedrec-bg: darkorange;
    }
    /* In case a transparent-bg image doesn't expect to be on a dark bg,
       which is quite common in practice... */
    img { background: white; }
}
</style>
<style>/* Boilerplate: 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>/* Boilerplate: style-issues */
a[href].issue-return {
    float: right;
    float: inline-end;
    color: var(--issueheading-text);
    font-weight: bold;
    text-decoration: none;
}
</style>
<style>/* Boilerplate: 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>/* Boilerplate: style-selflinks */
:root {
    --selflink-text: white;
    --selflink-bg: gray;
    --selflink-hover-text: black;
}
.heading, .issue, .note, .example, li, dt {
    position: relative;
}
a.self-link {
    position: absolute;
    top: 0;
    left: calc(-1 * (3.5rem - 26px));
    width: calc(3.5rem - 26px);
    height: 2em;
    text-align: center;
    border: none;
    transition: opacity .2s;
    opacity: .5;
}
a.self-link:hover {
    opacity: 1;
}
.heading > a.self-link {
    font-size: 83%;
}
.example > a.self-link,
.note > a.self-link,
.issue > a.self-link {
    /* These blocks are overflow:auto, so positioning outside
       doesn't work. */
    left: auto;
    right: 0;
}
li > a.self-link {
    left: calc(-1 * (3.5rem - 26px) - 2em);
}
dfn > a.self-link {
    top: auto;
    left: auto;
    opacity: 0;
    width: 1.5em;
    height: 1.5em;
    background: var(--selflink-bg);
    color: var(--selflink-text);
    font-style: normal;
    transition: opacity .2s, background-color .2s, color .2s;
}
dfn:hover > a.self-link {
    opacity: 1;
}
dfn > a.self-link:hover {
    color: var(--selflink-hover-text);
}

a.self-link::before            { content: "¶"; }
.heading > a.self-link::before { content: "§"; }
dfn > a.self-link::before      { content: "#"; }
</style>
<style>/* Boilerplate: style-syntax-highlighting */
code.highlight { padding: .1em; border-radius: .3em; }
pre.highlight, pre > code.highlight { display: block; padding: 1em; margin: .5em 0; overflow: auto; border-radius: 0; }

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

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

    c-[a] { color: #d33682 } /* Keyword.Declaration */
    c-[b] { color: #d33682 } /* Keyword.Type */
    c-[c] { color: #2aa198 } /* Comment */
    c-[d] { color: #2aa198 } /* Comment.Multiline */
    c-[e] { color: #268bd2 } /* Name.Attribute */
    c-[f] { color: #b58900 } /* Name.Tag */
    c-[g] { color: #cb4b16 } /* Name.Variable */
    c-[k] { color: #d33682 } /* Keyword */
    c-[l] { color: #657b83 } /* Literal */
    c-[m] { color: #657b83 } /* Literal.Number */
    c-[n] { color: #268bd2 } /* Name */
    c-[o] { color: #657b83 } /* Operator */
    c-[p] { color: #657b83 } /* Punctuation */
    c-[s] { color: #6c71c4 } /* Literal.String */
    c-[t] { color: #6c71c4 } /* Literal.String.Single */
    c-[u] { color: #6c71c4 } /* Literal.String.Double */
    c-[ch] { color: #2aa198 } /* Comment.Hashbang */
    c-[cp] { color: #2aa198 } /* Comment.Preproc */
    c-[cpf] { color: #2aa198 } /* Comment.PreprocFile */
    c-[c1] { color: #2aa198 } /* Comment.Single */
    c-[cs] { color: #2aa198 } /* Comment.Special */
    c-[kc] { color: #d33682 } /* Keyword.Constant */
    c-[kn] { color: #d33682 } /* Keyword.Namespace */
    c-[kp] { color: #d33682 } /* Keyword.Pseudo */
    c-[kr] { color: #d33682 } /* Keyword.Reserved */
    c-[ld] { color: #657b83 } /* Literal.Date */
    c-[nc] { color: #268bd2 } /* Name.Class */
    c-[no] { color: #268bd2 } /* Name.Constant */
    c-[nd] { color: #268bd2 } /* Name.Decorator */
    c-[ni] { color: #268bd2 } /* Name.Entity */
    c-[ne] { color: #268bd2 } /* Name.Exception */
    c-[nf] { color: #268bd2 } /* Name.Function */
    c-[nl] { color: #268bd2 } /* Name.Label */
    c-[nn] { color: #268bd2 } /* Name.Namespace */
    c-[py] { color: #268bd2 } /* Name.Property */
    c-[ow] { color: #657b83 } /* Operator.Word */
    c-[mb] { color: #657b83 } /* Literal.Number.Bin */
    c-[mf] { color: #657b83 } /* Literal.Number.Float */
    c-[mh] { color: #657b83 } /* Literal.Number.Hex */
    c-[mi] { color: #657b83 } /* Literal.Number.Integer */
    c-[mo] { color: #657b83 } /* Literal.Number.Oct */
    c-[sa] { color: #6c71c4 } /* Literal.String.Affix */
    c-[sb] { color: #6c71c4 } /* Literal.String.Backtick */
    c-[sc] { color: #6c71c4 } /* Literal.String.Char */
    c-[dl] { color: #6c71c4 } /* Literal.String.Delimiter */
    c-[sd] { color: #6c71c4 } /* Literal.String.Doc */
    c-[se] { color: #6c71c4 } /* Literal.String.Escape */
    c-[sh] { color: #6c71c4 } /* Literal.String.Heredoc */
    c-[si] { color: #6c71c4 } /* Literal.String.Interpol */
    c-[sx] { color: #6c71c4 } /* Literal.String.Other */
    c-[sr] { color: #6c71c4 } /* Literal.String.Regex */
    c-[ss] { color: #6c71c4 } /* Literal.String.Symbol */
    c-[fm] { color: #268bd2 } /* Name.Function.Magic */
    c-[vc] { color: #cb4b16 } /* Name.Variable.Class */
    c-[vg] { color: #cb4b16 } /* Name.Variable.Global */
    c-[vi] { color: #cb4b16 } /* Name.Variable.Instance */
    c-[vm] { color: #cb4b16 } /* Name.Variable.Magic */
    c-[il] { color: #657b83 } /* Literal.Number.Integer.Long */
}
</style>
 <body class="h-entry">
  <div class="head">
   <p data-fill-with="logo"></p>
   <h1 class="p-name no-ref" id="title">P3482R0<br>Design for C++ networking based on IETF TAPS</h1>
   <h2 class="no-num no-toc no-ref heading settled" id="profile-and-date"><span class="content">Published Proposal, <time class="dt-updated" datetime="2024-10-14">2024-10-14</time></span></h2>
   <div data-fill-with="spec-metadata">
    <dl>
     <dt>This version:
     <dd><a class="u-url" href="http://wg21.link/Pxxxx">http://wg21.link/Pxxxx</a>
     <dt class="editor">Authors:
     <dd class="editor p-author h-card vcard"><a class="p-name fn u-email email" href="mailto:thomas.rodgers@woven-planet.global">Thomas Rodgers</a> (<span class="p-org org">Woven By Toyota</span>)
     <dd class="editor p-author h-card vcard"><a class="p-name fn u-email email" href="mailto:dkuhl@bloomberg.net">Dietmar Kühl</a> (<span class="p-org org">Bloomberg</span>)
     <dt>Audience:
     <dd>SG4
     <dt>Project:
     <dd>ISO/IEC 14882 Programming Languages — C++, ISO/IEC JTC1/SC22/WG21
     <dt>Source:
     <dd><a href="https://github.com/rodgert/papers/blob/master/source/p3185r0.bs">https://github.com/rodgert/papers/blob/master/source/p3185r0.bs</a>
    </dl>
   </div>
   <div data-fill-with="warning"></div>
   <hr title="Separator for header">
  </div>
  <div class="p-summary" data-fill-with="abstract">
   <h2 class="no-num no-toc no-ref heading settled" id="abstract"><span class="content">Abstract</span></h2>
   <p>Design proposal for creating IETF TAPS based network connections</p>
  </div>
  <nav data-fill-with="table-of-contents" id="toc">
   <h2 class="no-num no-toc no-ref" id="contents">Table of Contents</h2>
   <ol class="toc" role="directory">
    <li><a href="#background"><span class="secno">1</span> <span class="content">Background</span></a>
    <li>
     <a href="#the-taps-approach"><span class="secno">2</span> <span class="content">The TAPS approach</span></a>
     <ol class="toc">
      <li><a href="#preconnections"><span class="secno">2.1</span> <span class="content">Preconnections</span></a>
      <li><a href="#endpoints"><span class="secno">2.2</span> <span class="content">Endpoints</span></a>
      <li><a href="#transports"><span class="secno">2.3</span> <span class="content">Transports</span></a>
      <li><a href="#security"><span class="secno">2.4</span> <span class="content">Security</span></a>
      <li><a href="#preconnections-and-connections"><span class="secno">2.5</span> <span class="content">Preconnections and Connections</span></a>
      <li>
       <a href="#message-based"><span class="secno">2.6</span> <span class="content">Message Based</span></a>
       <ol class="toc">
        <li><a href="#message-contexts"><span class="secno">2.6.1</span> <span class="content">Message Contexts</span></a>
       </ol>
     </ol>
    <li><a href="#design-discussion"><span class="secno">3</span> <span class="content">Design discussion</span></a>
    <li>
     <a href="#proposed-api"><span class="secno">4</span> <span class="content">Proposed API</span></a>
     <ol class="toc">
      <li><a href="#stdexecutionproperty_key_list"><span class="secno">4.1</span> <span class="content"><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>execution</c-><c- o>::</c-><c- n>property_key_list</c-></code></span></a>
      <li><a href="#stdexecutionis_property_key_list_v"><span class="secno">4.2</span> <span class="content"><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>execution</c-><c- o>::</c-><c- n>is_property_key_list_v</c-></code></span></a>
      <li><a href="#stdexecutionqueryable"><span class="secno">4.3</span> <span class="content"><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>execution</c-><c- o>::</c-><c- n>queryable</c-></code></span></a>
      <li><a href="#stdexecutionhas_query"><span class="secno">4.4</span> <span class="content"><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>execution</c-><c- o>::</c-><c- n>has_query</c-></code></span></a>
      <li><a href="#stdexecutionhas_query_default"><span class="secno">4.5</span> <span class="content"><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>execution</c-><c- o>::</c-><c- n>has_query_default</c-></code></span></a>
      <li><a href="#stdexecutionproperty"><span class="secno">4.6</span> <span class="content"><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>execution</c-><c- o>::</c-><c- n>property</c-></code></span></a>
      <li><a href="#stdexecutionhas_property"><span class="secno">4.7</span> <span class="content"><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>execution</c-><c- o>::</c-><c- n>has_property</c-></code></span></a>
      <li><a href="#stdexecutionhas_try_query"><span class="secno">4.8</span> <span class="content"><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>execution</c-><c- o>::</c-><c- n>has_try_query</c-></code></span></a>
      <li><a href="#stdexecutionmaybe_has_property"><span class="secno">4.9</span> <span class="content"><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>execution</c-><c- o>::</c-><c- n>maybe_has_property</c-></code></span></a>
      <li><a href="#stdexecutionruntime_property"><span class="secno">4.10</span> <span class="content"><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>execution</c-><c- o>::</c-><c- n>runtime_property</c-></code></span></a>
      <li><a href="#stdexecutionruntime_env"><span class="secno">4.11</span> <span class="content"><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>execution</c-><c- o>::</c-><c- n>runtime_env</c-></code></span></a>
      <li>
       <a href="#properties-of-endpoints"><span class="secno">4.12</span> <span class="content">Properties of endpoints</span></a>
       <ol class="toc">
        <li><a href="#stdnetipaddress_v4"><span class="secno">4.12.1</span> <span class="content"><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>net</c-><c- o>::</c-><c- n>ip</c-><c- o>::</c-><c- n>address_v4</c-></code></span></a>
        <li><a href="#stdnetipaddress_v6"><span class="secno">4.12.2</span> <span class="content"><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>net</c-><c- o>::</c-><c- n>ip</c-><c- o>::</c-><c- n>address_v6</c-></code></span></a>
        <li><a href="#stdnetipaddress"><span class="secno">4.12.3</span> <span class="content"><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>net</c-><c- o>::</c-><c- n>ip</c-><c- o>::</c-><c- n>address</c-></code></span></a>
        <li><a href="#stdnethostname"><span class="secno">4.12.4</span> <span class="content"><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>net</c-><c- o>::</c-><c- n>hostname</c-></code></span></a>
        <li><a href="#stdnetinterface"><span class="secno">4.12.5</span> <span class="content"><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>net</c-><c- o>::</c-><c- n>interface</c-></code></span></a>
        <li><a href="#stdnetservice"><span class="secno">4.12.6</span> <span class="content"><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>net</c-><c- o>::</c-><c- n>service</c-></code></span></a>
        <li><a href="#stdnetsingle_source_multicast_group_address"><span class="secno">4.12.7</span> <span class="content"><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>net</c-><c- o>::</c-><c- n>single_source_multicast_group_address</c-></code></span></a>
        <li><a href="#stdnetendpoint_props"><span class="secno">4.12.8</span> <span class="content"><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>net</c-><c- o>::</c-><c- n>endpoint_props</c-></code></span></a>
       </ol>
      <li>
       <a href="#properties-of-transports"><span class="secno">4.13</span> <span class="content">Properties of transports</span></a>
       <ol class="toc">
        <li><a href="#stdnettransport_preference"><span class="secno">4.13.1</span> <span class="content"><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>net</c-><c- o>::</c-><c- n>transport_preference</c-></code></span></a>
        <li><a href="#stdnetmultipath_preference"><span class="secno">4.13.2</span> <span class="content"><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>net</c-><c- o>::</c-><c- n>multipath_preference</c-></code></span></a>
        <li><a href="#stdnetdirection_preference"><span class="secno">4.13.3</span> <span class="content"><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>net</c-><c- o>::</c-><c- n>direction_preference</c-></code></span></a>
        <li><a href="#stdnetinterface_preference"><span class="secno">4.13.4</span> <span class="content"><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>net</c-><c- o>::</c-><c- n>interface_preference</c-></code></span></a>
        <li><a href="#stdnettransport_props"><span class="secno">4.13.5</span> <span class="content"><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>net</c-><c- o>::</c-><c- n>transport_props</c-></code></span></a>
       </ol>
      <li>
       <a href="#properties-governing-transport-security"><span class="secno">4.14</span> <span class="content">Properties governing transport security</span></a>
       <ol class="toc">
        <li><a href="#stdnetsecurity_props"><span class="secno">4.14.1</span> <span class="content"><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>net</c-><c- o>::</c-><c- n>security_props</c-></code></span></a>
       </ol>
      <li>
       <a href="#obtaining-connections"><span class="secno">4.15</span> <span class="content">Obtaining Connections</span></a>
       <ol class="toc">
        <li><a href="#netinitiate"><span class="secno">4.15.1</span> <span class="content"><code class="highlight"><c- n>net</c-><c- o>::</c-><c- n>initiate</c-></code></span></a>
        <li><a href="#netlisten"><span class="secno">4.15.2</span> <span class="content"><code class="highlight"><c- n>net</c-><c- o>::</c-><c- n>listen</c-></code></span></a>
        <li><a href="#netrendezvous"><span class="secno">4.15.3</span> <span class="content"><code class="highlight"><c- n>net</c-><c- o>::</c-><c- n>rendezvous</c-></code></span></a>
       </ol>
     </ol>
    <li><a href="#next-steps"><span class="secno">5</span> <span class="content">Next steps</span></a>
    <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>
   <h2 class="heading settled" data-level="1" id="background"><span class="secno">1. </span><span class="content">Background</span><a class="self-link" href="#background"></a></h2>
   <p><a data-link-type="biblio" href="#biblio-p2762" title="Sender/Receiver Interface For Networking">[p2762]</a> Proposes a modification to the <a data-link-type="biblio" href="#biblio-netts" title="Working Draft, C++ Extensions for Networking">[netts]</a> to adopt the Sender/Receiver model (targeted to C++26).</p>
   <p><a data-link-type="biblio" href="#biblio-p3185" title="A proposed direction for C++ Standard Networking based on IETF TAPS">[p3185]</a> Proposed a direction for C++ networking based on IETF TAPS. The process of obtaining a connection in the TAPS
model is substantially different from other approaches based on Berkeley Sockets or abstractions over the socket
oriented model such as the <a data-link-type="biblio" href="#biblio-netts" title="Working Draft, C++ Extensions for Networking">[netts]</a> and <a data-link-type="biblio" href="#biblio-asio" title="Asio C++ Library">[asio]</a>.</p>
   <p><a data-link-type="biblio" href="#biblio-p1861" title="Secure Networking in C++">[p1861]</a> sketched out an interface proposal derived from Apple’s Network.Framework <a data-link-type="biblio" href="#biblio-anf" title="Apple Network.framework">[ANF]</a> and to which TAPS has design
lineage. The design discussed here differs significantly in the detail, but presents many of the same concepts.</p>
   <h2 class="heading settled" data-level="2" id="the-taps-approach"><span class="secno">2. </span><span class="content">The TAPS approach</span><a class="self-link" href="#the-taps-approach"></a></h2>
   <p>IETF TAPS uses a property based approach for describing the requirements of a connection. The TAPS infrastructure uses
these properties to select a set of one or more candidates that satisfy the supplied properties. These candidates can
be then be used to request a connection which then conforms to the supplied properties. Applications may provide additional
logic to select among multiple candidates where required to, e.g. provide a failover path in case of connection failure.</p>
   <h3 class="heading settled" data-level="2.1" id="preconnections"><span class="secno">2.1. </span><span class="content">Preconnections</span><a class="self-link" href="#preconnections"></a></h3>
   <p>Creating a connection begins with a preconnection.</p>
   <p>TAPS specifies four groups of properties which define a preconnection object -</p>
   <ul>
    <li data-md>
     <p>Local Endpoint</p>
    <li data-md>
     <p>Remote Endpoint</p>
    <li data-md>
     <p>Transport</p>
    <li data-md>
     <p>Security</p>
   </ul>
   <h3 class="heading settled" data-level="2.2" id="endpoints"><span class="secno">2.2. </span><span class="content">Endpoints</span><a class="self-link" href="#endpoints"></a></h3>
   <p>Endpoints define the origin and destination points for a connection and are distinguished into local and remote types.
Endpoints have the following properties -</p>
   <ul>
    <li data-md>
     <p>hostname, ex. "nyarlathotep.example.org"</p>
    <li data-md>
     <p>interface, ex. "en0"</p>
    <li data-md>
     <p>service, ex. "https"</p>
    <li data-md>
     <p>multicast_group, ex. "224.0.0.252" or "ff02::114"</p>
    <li data-md>
     <p>hop_limit, ex. 2</p>
   </ul>
   <h3 class="heading settled" data-level="2.3" id="transports"><span class="secno">2.3. </span><span class="content">Transports</span><a class="self-link" href="#transports"></a></h3>
   <p>Transports are defined by a set of requirements that the underlying infrastructure is expected to satisfy. Most transport
requirements are expressed as preferences which can take one of the following values -</p>
   <ul>
    <li data-md>
     <p>Require</p>
    <li data-md>
     <p>Prefer</p>
    <li data-md>
     <p>None</p>
    <li data-md>
     <p>Avoid</p>
    <li data-md>
     <p>Prohibit</p>
   </ul>
   <p>Transports have the following properties which can be used to express requirements -</p>
   <ul>
    <li data-md>
     <p>interface, a multivalued set of (interface, preference) tuples</p>
    <li data-md>
     <p>reliability, preference</p>
    <li data-md>
     <p>preserve_msg_boundaries, preference</p>
    <li data-md>
     <p>per_msg_reliability, preference</p>
    <li data-md>
     <p>preserve_order, preference</p>
    <li data-md>
     <p>zero_rtt_msg, preference</p>
    <li data-md>
     <p>multistreaming, preference</p>
    <li data-md>
     <p>full_checksum_send, preference</p>
    <li data-md>
     <p>full_checksum_recv, preference</p>
    <li data-md>
     <p>congestion_control, preference</p>
    <li data-md>
     <p>keep_alive, preference</p>
    <li data-md>
     <p>use_temp_local_address, preference</p>
    <li data-md>
     <p>multipath, enumeration { disabled, active, passive }</p>
    <li data-md>
     <p>advertises_alt_addr, preference</p>
    <li data-md>
     <p>direction, enumeration { both, send, recv }</p>
    <li data-md>
     <p>soft_error_notify, preference</p>
    <li data-md>
     <p>active_read_before_send, preference</p>
   </ul>
   <h3 class="heading settled" data-level="2.4" id="security"><span class="secno">2.4. </span><span class="content">Security</span><a class="self-link" href="#security"></a></h3>
   <p>Security for transports are also defined by a set of requirements that must be satisfied. The following properties
are supported -</p>
   <ul>
    <li data-md>
     <p>allowed_security_protocols, sequence of of protocol identifiers</p>
    <li data-md>
     <p>server_cert, sequence of certificates</p>
    <li data-md>
     <p>client_cert, sequence of certificates</p>
    <li data-md>
     <p>pinned_server_cert, sequence of certificates</p>
    <li data-md>
     <p>alpn, sequence of application layer protocol negotiation values</p>
    <li data-md>
     <p>supported_group, sequence of group identifiers</p>
    <li data-md>
     <p>ciphersuite, sequence of ciphersuite identifiers</p>
    <li data-md>
     <p>signature_algorithm, sequence of algorithm identifiers</p>
    <li data-md>
     <p>max_cached_session, integer</p>
    <li data-md>
     <p>cached_session_lifetime, duration</p>
    <li data-md>
     <p>preshared_key, key material</p>
    <li data-md>
     <p>trust_verification_handler, sequence sender</p>
    <li data-md>
     <p>challenge_handler, sequence sender</p>
   </ul>
   <h3 class="heading settled" data-level="2.5" id="preconnections-and-connections"><span class="secno">2.5. </span><span class="content">Preconnections and Connections</span><a class="self-link" href="#preconnections-and-connections"></a></h3>
   <p>The endpoint, transport, and security property sets are used to create a preconnection. Preconnections
are then used to establish connections. TAPS defines three methods on a preconnection type for creating a
connection -</p>
   <ul>
    <li data-md>
     <p>Initiate -> Connection, an <em>Active Open</em> connection (could be named <code class="highlight"><c- n>client_connection</c-></code>)</p>
    <li data-md>
     <p>Listen -> Connection, a <em>Passive Open</em> connection (could be named <code class="highlight"><c- n>server_connection</c-></code>), the returned
connection type permits rate-limiting of inbound connections by setting a connection limit property
which is decremented on each new inbound connection, and may be periodically reset.</p>
    <li data-md>
     <p>Rendezvous -> Connection, a <em>Peer to Peer</em> connection (could be named <code class="highlight"><c- n>peer_to_peer_connection</c-></code>)</p>
   </ul>
   <p>TAPS further specifies that a preconnection can be modified, but such modifications only have effects on
subsequent connections.</p>
   <p>TAPS specifies that preconnections can perform endpoint resolution -</p>
   <ul>
    <li data-md>
     <p>Resolve -> (local_endpoint[], remote_endpoint[])</p>
   </ul>
   <h3 class="heading settled" data-level="2.6" id="message-based"><span class="secno">2.6. </span><span class="content">Message Based</span><a class="self-link" href="#message-based"></a></h3>
   <p>TAPS is explicitly message based. This is a departure from Berkeley Sockets or the <a data-link-type="biblio" href="#biblio-netts" title="Working Draft, C++ Extensions for Networking">[netts]</a> which yield
up buffers as data arrives, leaving framing up to the application. TAPS introduces the notion of a <em>Framer</em> which produces complete messages (or an error) from one or more chunks of received data. Framers are
an optional argument to obtaining a Connection from a Preconnection. Framers are event driven, receiving
events about connection initiation, incoming and outgoing data, and connection termination, from the
underlying transport.</p>
   <p>Framers allow extending a connection’s protocol stack to define how to encode outbound messages, decode
inbound messages, and provide well-defined message boundaries even when using stream-oriented transport
protocols.</p>
   <p>A <code class="highlight"><c- n>default_framer</c-></code> could behave similarly to typical Berkeley socket code and yield the octets received
thus far. Higher level examples of framers might include an <code class="highlight"><c- n>http_framer</c-></code> that would parse HTTP header
properties and message boundaries from the underlying stream of bytes. User defined framers could do
things like using Thrift serialization/deserialization to operate on strongly typed domain types rather than
spans of octets.</p>
   <h4 class="heading settled" data-level="2.6.1" id="message-contexts"><span class="secno">2.6.1. </span><span class="content">Message Contexts</span><a class="self-link" href="#message-contexts"></a></h4>
   <p>On calls to send and receive data, the application may provide a MessageContext. On completion of a Send
or Receive operation, the event handler is provided the MessageContext associated with that event. These
MessageContexts serve several functions. A MessageContext passed to Send or Receive may communicate
framer-specific properties that control how a framer operates on the message data. The MessageContext can
be used to communicate with the eventual <code class="highlight"><c- n>set_value</c-><c- p>()</c-></code> handler receiving a completed message. MessageContexts
are also used to correlate multiple partial Send or Receive operations. On receipt of octets from the transport,
the MessageContext will contain information about the connection such as interface, remote endpoint, and so forth.
Framers may extend the properties of the message context to include additional information, e.g., HTTP headers,
which are metadata about the message being framed.</p>
   <h2 class="heading settled" data-level="3" id="design-discussion"><span class="secno">3. </span><span class="content">Design discussion</span><a class="self-link" href="#design-discussion"></a></h2>
   <p>The proposed general direction is to prefer TAPS concepts where sensible, e.g., in describing the properties
of a connection, being message oriented, user extensible framing and message types, etc. but to otherwise
adopt and amend as much of <a data-link-type="biblio" href="#biblio-p2762" title="Sender/Receiver Interface For Networking">[p2762]</a> as is applicable to form the basis of the overall proposal.</p>
   <p>For instance, <a data-link-type="biblio" href="#biblio-p2762" title="Sender/Receiver Interface For Networking">[p2762]</a> defines a socket type(s) and a range of CPOs defining the operations over that type.
Rather than a socket, the <code class="highlight"><c- n>connect</c-><c- p>()</c-></code>, <code class="highlight"><c- n>listen</c-><c- p>()</c-></code> and <code class="highlight"><c- n>rendezvous</c-><c- p>()</c-></code> CPOs proposed here return a <code class="highlight"><c- n>connection</c-></code> for which CPOs like <code class="highlight"><c- n>async_send</c-><c- p>()</c-></code> and <code class="highlight"><c- n>async_receive</c-><c- p>()</c-></code> would operate on much as <a data-link-type="biblio" href="#biblio-p2762" title="Sender/Receiver Interface For Networking">[p2762]</a> envisions them
working on a socket type. Certain socket-oriented operations in <a data-link-type="biblio" href="#biblio-p2762" title="Sender/Receiver Interface For Networking">[p2762]</a> would not make sense though, for
instance, anything related to building a socket acceptor is part of the connection type returned by the <code class="highlight"><c- n>listen</c-><c- p>()</c-></code> CPO and is library implementation detail that is not exposed to the library user.</p>
   <p>The committee typically defers to LEWG as the ultimate bikeshedder/arbiter of naming things, however SG4 should
provide guidance and encouragement to LEWG in choosing names and concepts to avoid deviating unnecessarily
from <a data-link-type="biblio" href="#biblio-taps_arch" title="Architecture and Requirements for Transport Services">[TAPS_Arch]</a> so that there is a common vocabulary with other TAPS implementations.</p>
   <p>Most of the properties specified by TAPS assume that the underlying transport is based on TCP/IP. The
discussion at the Tokyo meeting included speculation on how other transports might be supported by a proposal
based on TAPS, for instance using MPI as an underlying transport, which may in turn use some form of high
performance fabric, e.g., Infiniband. Similarly, <a data-link-type="biblio" href="#biblio-asio" title="Asio C++ Library">[asio]</a> provides abstractions for sockets which are based on
serial ports, IPC queues, and so forth. An endpoint for an IPC queue would not include a hostname, for instance.
Security properties would also not be relevant to the typical IPC <code class="highlight"><c- n>connection</c-></code> as this is enforced locally by
the host operating system. Transport properties might be similarly optional, or implied by the
endpoint/transport type.</p>
   <p><a data-link-type="biblio" href="#biblio-taps_interface" title="An Abstract Application Layer Interface to Transport Services">[TAPS_interface]</a> envisions three distinct kinds of connection arising from the properties of a preconnection -</p>
   <ul>
    <li data-md>
     <p>Active Open - models a typical client connection to a server</p>
    <li data-md>
     <p>Listen - models a typical server connection (socket acceptor pattern)</p>
    <li data-md>
     <p>Rendezvous - models a typical peer-to-peer arrangement</p>
   </ul>
   <p>If we allow for support of non-TCP based transports, not all of these types of connection may be supported by
an underlying transport. A publish/subscribe transport (e.g., Tibco Rendezvous), for instance, might only support
peer-to-peer connections.</p>
   <p>TAPS expects that a connection is a single object type that exposes all of the necessary operations to cover
each of the distinct types of connection. This paper instead proposes that each kind of connection be a distinct
type, exposing only those operations supported by the underlying transport for that type of connection. It is
further proposed that the various connect operations be customization points, based on the type of the supplied
preconnection argument, permitting vendor/user customization for supporting non-TCP/IP based transports.</p>
   <p>The Standard Library would provide a default transport implementation that conforms to the endpoint, transport,
and security properties outlined by TAPS, segregating those types specific to TCP/IP into a <code class="highlight"><c- n>net</c-><c- o>::</c-><c- n>ip</c-></code> namespace
similar to how the <a data-link-type="biblio" href="#biblio-netts" title="Working Draft, C++ Extensions for Networking">[netts]</a> and <a data-link-type="biblio" href="#biblio-asio" title="Asio C++ Library">[asio]</a> organize TCP/IP specific types.</p>
   <p>Preconnections are constructed from sets of properties that describe the endpoints, transport, and security
requirements. <a data-link-type="biblio" href="#biblio-p3325" title="A Utility for Creating Execution Environments">[p3325]</a> describes a mechanism for constructing and querying strongly typed properties for <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>execution</c-></code> environments. Making a preconnection a template requiring its argument types to conform to the
proposed queryable concept allows user code to provide any type(s) which satisfy this constraint. A related
proposal being explored is a type-erased <code class="highlight"><c- n>runtime_env</c-></code>, which conforms to the queryable concept. This mechanism
is used here to provide the default implementations of the various endpoint, transport and security property sets.</p>
   <p>There are corresponding property type definitions for the various properties which define a preconnection.
Each property type and the sets of the properties; <code class="highlight"><c- n>local_endpoint</c-></code>, <code class="highlight"><c- n>remote_endpoint</c-></code>, <code class="highlight"><c- n>transport_props</c-></code>, and <code class="highlight"><c- n>security_props</c-></code> have value semantics. The sets of properties; <code class="highlight"><c- n>local_endpoint</c-></code>, <code class="highlight"><c- n>remote_endpoint</c-></code>, <code class="highlight"><c- n>transport_props</c-></code>,
and <code class="highlight"><c- n>security_props</c-></code> conform to the <code class="highlight"><c- n>has_property</c-></code> or <code class="highlight"><c- n>maybe_has_property</c-></code> concept.</p>
   <p>For transport and security properties, the standard library should provide common and well formed defaults that
the user may opt into entirely, or combine with specific property choices for their use case. These could be exposed as
static members of the <code class="highlight"><c- n>transport</c-></code> and <code class="highlight"><c- n>security</c-></code> property sets.</p>
   <p>The set of properties allowed should be open-ended. This paper doesn’t contemplate how an implementation
might make use of this flexibility, other than to propose that <code class="highlight"><c- n>connect</c-><c- p>()</c-></code>, <code class="highlight"><c- n>listen</c-><c- p>()</c-></code>, and <code class="highlight"><c- n>rendezvous</c-><c- p>()</c-></code> be
expressed as CPOs, which would allow customization over how the properties of a preconnection are processed.</p>
   <p>The security handler properties for trust verification and challenge handling are also inherently asynchronous
operations. <a data-link-type="biblio" href="#biblio-taps_interface" title="An Abstract Application Layer Interface to Transport Services">[TAPS_interface]</a> envisions these would be typical callback closures, but these operations
can and should be represented using sender/receiver vocabulary types and participate in timeout and cancellation.</p>
   <p>A Future paper revision will more fully cover a discussion of sequence senders. The concept of a <code class="highlight"><c- n>sequence_sender</c-></code> extends the <code class="highlight"><c- n>sender</c-></code> by adding a <code class="highlight"><c- n>set_next_value</c-><c- p>()</c-></code> operation, which itself returns a sender which may be scheduled
for later execution when it receives a value by the <code class="highlight"><c- n>io_context</c-></code>.</p>
   <p>Trust verification callbacks as sequence senders - <a data-link-type="biblio" href="#biblio-taps_interface" title="An Abstract Application Layer Interface to Transport Services">[TAPS_interface]</a> section 6.3.8 states -</p>
   <blockquote>
    <p>Security decisions, especially pertaining to trust, are not static. Once configured, parameters can also be
supplied during Connection establishment.  These are best handled as client-provided callbacks. Callbacks
block the progress of the Connection establishment, which distinguishes them from other events in the transport
system.  How callbacks and events are implemented is specific to each implementation.
As noted, these callbacks are intended to block the forward progress of establishing a
connection. Indeed, these callbacks may require input from a user dialog in a UI, and remain blocked indefinitely
if the user strolls off for a good strong cuppa, while somewhere in the bowels of the networking implementation an <code class="highlight"><c- n>io_executor</c-></code> is waiting for a response to proceed with the connection. Basing these operations on <code class="highlight"><c- n>sequence</c-> <c- n>senders</c-></code> allows this to be efficiently scheduled and potentially cancelled.</p>
   </blockquote>
   <p>The two security callback types are -</p>
   <ul>
    <li data-md>
     <p>Trust verification, e.g., validating a remote endpoint’s X.509 certificate</p>
    <li data-md>
     <p>Identity challenge, invoked whenever a private key operation is required</p>
   </ul>
   <p>These callbacks, when modeled as a <code class="highlight"><c- n>sequence_sender</c-></code> receive a <code class="highlight"><c- n>set_next_value</c-><c- p>()</c-></code> delivering the
value required to perform the trust verification or identity challenge, returning a sender on which the
user code will later call <code class="highlight"><c- n>set_value</c-><c- p>()</c-></code>, <code class="highlight"><c- n>set_error</c-><c- p>()</c-></code>, or <code class="highlight"><c- n>set_stopped</c-><c- p>()</c-></code> indicating the outcome of the operation.
This design also permits multiple/multi-step invocations of these callback operations, rescheduling the connection
state machine with the <code class="highlight"><c- n>io_context</c-></code> as needed.</p>
   <p>Framers, in addition to producing a <em>body type</em> for a message type, may introduce headers. Headers can be
strongly typed, and the <code class="highlight"><c- n>runtime_env</c-></code> mechanism being explored for the preconnection property sets can also
be used for this purpose. A standard set of headers derived from the properties used to construct a connection
are provided to the framer. Framers can be viewed as a stack, refining one or more partial chunks of received
data into a concrete message type. Our proposal is to supply a <code class="highlight"><c- n>default_framer</c-></code> which provides raw octets of
the message body as they are received, along with the default set of message properties derived from the connection.
User defined framer types may consume the messages provided by the <code class="highlight"><c- n>default_framer</c-></code> and produce strongly-typed messages.</p>
   <p>Connection negotiation and establishment, framing, message sending, and receipt are all inherently asynchronous
operations in TAPS. The C++ design for these features should use the sender/receiver vocabulary targeted at
C++26, but that proposal is insufficient to cover the networking use case and there needs to be additional work
in refining the proposed <code class="highlight"><c- n>sequence_sender</c-></code> concept.</p>
   <p>Connections expose a set of connection specific properties. Connection properties are modifiable, and may
be modified both during pre-establishment and after the connection has been established.</p>
   <p><a data-link-type="biblio" href="#biblio-taps_interface" title="An Abstract Application Layer Interface to Transport Services">[TAPS_interface]</a> suggests that <code class="highlight"><c- n>resolve</c-></code> should be a synchronous operation on the preconnection, returning a pair
of collections of local and remote endpoints. DNS lookups are UDP based and the classic approach to DNS resolution
is an asynchronous operation, which may return multiple results across multiple UDP DNS responses. The widely used <a data-link-type="biblio" href="#biblio-c-ares" title="A modern DNS resolver written in C">[c-ares]</a> DNS resolver library expresses DNS resolution as an asynchronous operation as well. It is also possible
that name resolution can block indefinitely. A typical approach to address this possibility might be to provide a
timeout to the <code class="highlight"><c- n>resolve</c-><c- p>()</c-></code> call , e.g., <code class="highlight"><c- n>try_resolve_for</c-><c- p>()</c-></code>, but there are other scenarios where one might want to
abandon a query early. DNS queries can potentially return multiple responses, for instance. An application might not
care to wait for a complete set of responses before initiating a connection, and upon successful establishment, abandon
waiting for any further query results.  This suggests that we should instead express resolution in terms of returning
a Sender, rather than synchronously waiting for resolution and making that process cancellable via <code class="highlight"><c- n>stop_token</c-></code>.</p>
   <p>The process of constructing a Connection typically relies on resolving endpoints by name. If <code class="highlight"><c- n>resolve</c-></code> is asynchronous,
returning a sender which ultimately delivers endpoints or an error, the entry points that create connections similarly
return senders which ultimately deliver a connection or an error.</p>
   <p>Connections are a sender of asynchronous events about the connection life-cycle in addition to events for message
receipt and delivery. These life-cycle events are -</p>
   <ul>
    <li data-md>
     <p>'soft errors' if the underlying protocol stack supports access to ICMP error messages related to the Connection.</p>
    <li data-md>
     <p>'path change' events to notify the application of the underlying connection path, or if the set of local endpoints changes, etc.</p>
    <li data-md>
     <p>Closed, Abort, CloseGroup, AbortGroup, ConnectionError, etc.</p>
   </ul>
   <p>Connections are a sender of framed and, optionally, strongly typed, received Messages.</p>
   <p><a data-link-type="biblio" href="#biblio-p2762" title="Sender/Receiver Interface For Networking">[p2762]</a> modifies the socket based approach of the <a data-link-type="biblio" href="#biblio-netts" title="Working Draft, C++ Extensions for Networking">[netts]</a> to adopt the Sender/Receiver model proposed
by <a data-link-type="biblio" href="#biblio-p2300" title="std::execution">[p2300]</a>, to support asynchronous network operations. Some of these operations are subsumed by the design
approach taken by TAPS, but many others continue to be relevant, if somewhat modified, under this proposal.</p>
   <p>In particular -</p>
   <ul>
    <li data-md>
     <p><code class="highlight"><c- n>async_accept</c-><c- p>()</c-></code> is subsumed by the proposed <code class="highlight"><c- n>async_listen</c-><c- p>()</c-></code> sender operation</p>
    <li data-md>
     <p><code class="highlight"><c- n>async_connect</c-><c- p>()</c-></code> is subsumed by the proposed <code class="highlight"><c- n>async_initiate</c-><c- p>()</c-></code> operation</p>
    <li data-md>
     <p><code class="highlight"><c- n>async_resolve_address</c-><c- p>()</c-></code> and <code class="highlight"><c- n>async_resolve_name</c-><c- p>()</c-></code> are subsumed by the proposed <code class="highlight"><c- n>async_resolve</c-><c- p>()</c-></code> operation</p>
   </ul>
   <p>The <code class="highlight"><c- n>async_listen</c-><c- p>()</c-></code> operation returns a sender, which may be <code class="highlight"><c- p>.</c-><c- n>connect</c-><c- p>()</c-></code>-ed to receive the result of an accepted
connection. The application may throttle the total rate of underlying socket accepts, by throttling the rate at
which subsequent <code class="highlight"><c- n>async_listen</c-><c- p>()</c-></code> operations are initiated.</p>
   <p>The operations defined for sending data in <a data-link-type="biblio" href="#biblio-p2762" title="Sender/Receiver Interface For Networking">[p2762]</a> are modified as follows -</p>
   <ul>
    <li data-md>
     <p>TAPS is explicitly message base, <code class="highlight"><c- n>async_send</c-><c- p>()</c-></code> is a customization point intended to send whole messages,
files, etc. The decision as to how a message is encoded to an underlying transport under TAPS is delegated to a
customizable Framer, which is supplied at connection establishment. TAPS message operations always include a
caller supplied message context. The <code class="highlight"><c- n>async_send</c-><c- p>()</c-></code> method, as defined in <a data-link-type="biblio" href="#biblio-p2762" title="Sender/Receiver Interface For Networking">[p2762]</a> is modified to accept a
message context. Message framers may introduce a strongly typed message requirement, in which case the message
argument to <code class="highlight"><c- n>async_send</c-><c- p>()</c-></code> is that type, otherwise it is <code class="highlight"><c- n>ConstantBufferSequence</c-></code>.</p>
    <li data-md>
     <p>The message_flags parameter to <code class="highlight"><c- n>async_send</c-><c- p>()</c-></code> is removed; any properties that direct the transport’s delivery
of the message are supplied as part of the MessageContext.</p>
    <li data-md>
     <p>The return type of <code class="highlight"><c- n>async_send</c-><c- p>()</c-></code> is a <em>send-sender</em>. This sender may deliver values indicating that a message
has been sent, or possibly that a message send timed out before the message could be sent, in addition to any
error that might arise in the process of sending the message.</p>
    <li data-md>
     <p>There is no difference between sending a message to a stream transport vs. a datagram oriented transport from
the user’s perspective so <code class="highlight"><c- n>async_send_to</c-><c- p>()</c-></code> is removed.</p>
    <li data-md>
     <p>TAPS allows for partial send operations. Such partial sends send portions of a single logical message, which is
correlated as a single logical transaction by passing the same MessageContext instance.</p>
    <li data-md>
     <p>Partial sends still return a <em>send-sender</em> which receives the value or error that results from sending that
discrete message fragment. It is possible, under this scenario, for a partial message logical send transaction to
have partial failures and timeouts. <a data-link-type="biblio" href="#biblio-taps_interface" title="An Abstract Application Layer Interface to Transport Services">[TAPS_interface]</a> Identifies this case and suggests that the implementation
provide some way to correlate partial completions to which distinct partial send operation(s) failed. This could 
be accomplished by requiring the user to pass a distinct fragment ID as part of the MessageContext. This would
imply that the MessageContext is copied for each partial send. Doing so may be undesirable, and other approaches
might be worth exploring.</p>
   </ul>
   <p>Similarly the operations defined for receiving data are modified as follows -</p>
   <ul>
    <li data-md>
     <p>TAPS is explicitly message based, <code class="highlight"><c- n>async_receive</c-><c- p>()</c-></code> is a customization point intended to receive whole messages,
files, and so forth. The decision as to what constitutes a message under TAPS is delegated to a customizable framer, which
is supplied at connection establishment. TAPS message operations always include a caller supplied message context.
The <code class="highlight"><c- n>async_receive</c-><c- p>()</c-></code> method, as defined in <a data-link-type="biblio" href="#biblio-p2762" title="Sender/Receiver Interface For Networking">[p2762]</a> is modified to accept a message context.</p>
    <li data-md>
     <p>There is no difference between receiving a message from a stream transport vs. a datagram oriented transport
from the user’s perspective so <code class="highlight"><c- n>async_receive_from</c-><c- p>()</c-></code> is removed.</p>
    <li data-md>
     <p>An open design question is whether the supplied message context could carry, for example, a buffer pool that the framer
could then use to obtain buffers for the data of messages currently in the process being framed.</p>
    <li data-md>
     <p>TAPS allows for partial receive operations, which are similar to <code class="highlight"><c- n>async_read_some</c-><c- p>()</c-></code>. In the TAPS scheme, the
application issues multiple partial receive operations, indicating how many octets, at most, to receive, before
delivering a partial result. All such partial receive operations specifying the same MessageContext instance are
part of the same logical receive operation. The proposal here is to either extend the signature for <code class="highlight"><c- n>async_receive</c-><c- p>()</c-></code> to include a maximum read length value, or introduce an <code class="highlight"><c- n>async_receive_some</c-><c- p>()</c-></code> operation.</p>
    <li data-md>
     <p>Each call to <code class="highlight"><c- n>async_receive</c-><c- p>()</c-></code> returns a <em>receive-sender</em>, which can be <code class="highlight"><c- p>.</c-><c- n>connect</c-><c- p>()</c-></code>ed to receive the result of
that operation. Applications can throttle connections and potentially provide back pressure by controlling the number
of concurrent <code class="highlight"><c- n>async_receive</c-><c- p>()</c-></code> operations in progress at any instant.</p>
    <li data-md>
     <p>The <code class="highlight"><c- n>set_value</c-><c- p>()</c-></code> call ultimately delivered by an <code class="highlight"><c- n>async_receive</c-><c- p>()</c-></code> includes the message context supplied when the
operation was initiated, and the (potentially strongly-typed) message or partial message result.</p>
    <li data-md>
     <p><code class="highlight"><c- n>async_receive</c-><c- p>()</c-></code> operations are cancellable by the usual <code class="highlight"><c- n>stop_token</c-></code> mechanism as with any other asynchronous
operation under the <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>execution</c-></code> proposal.</p>
   </ul>
   <p>A future revision of this paper will discuss framers and the details of the underlying transport exposed to them.</p>
   <h2 class="heading settled" data-level="4" id="proposed-api"><span class="secno">4. </span><span class="content">Proposed API</span><a class="self-link" href="#proposed-api"></a></h2>
   <p>These types are from (generally) <a data-link-type="biblio" href="#biblio-p3325" title="A Utility for Creating Execution Environments">[p3325]</a> and live in the <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>execution</c-></code> namespace.</p>
   <h3 class="heading settled" data-level="4.1" id="stdexecutionproperty_key_list"><span class="secno">4.1. </span><span class="content"><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>execution</c-><c- o>::</c-><c- n>property_key_list</c-></code></span><a class="self-link" href="#stdexecutionproperty_key_list"></a></h3>
<pre class="highlight"><code><pre class="highlight"><c- k><c- k>namespace</c-></c-> <c- nn><c- nn>std</c-></c-><c- o><c- o>::</c-></c-><c- nn><c- nn>execution</c-></c-> <c- p><c- p>{</c-></c->
    <c- p><c- p>...</c-></c->

    <c- k><c- k>template</c-></c-><c- o><c- o>&lt;</c-></c-><c- k><c- k>typename</c-></c-><c- p><c- p>...</c-></c-> <c- n><c- n>Ts</c-></c-><c- o><c- o>></c-></c->
    <c- k><c- k>class</c-></c-> <c- nc><c- nc>property_key_list</c-></c-> <c- p><c- p>{</c-></c-> <c- p><c- p>};</c-></c->

    <c- p><c- p>...</c-></c->
<c- p><c- p>}</c-></c->
</pre></code></pre>
   <h3 class="heading settled" data-level="4.2" id="stdexecutionis_property_key_list_v"><span class="secno">4.2. </span><span class="content"><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>execution</c-><c- o>::</c-><c- n>is_property_key_list_v</c-></code></span><a class="self-link" href="#stdexecutionis_property_key_list_v"></a></h3>
<pre class="highlight"><code><pre class="highlight"><c- k><c- k>namespace</c-></c-> <c- nn><c- nn>std</c-></c-><c- o><c- o>::</c-></c-><c- nn><c- nn>execution</c-></c-> <c- p><c- p>{</c-></c->
    <c- p><c- p>...</c-></c->

    <c- k><c- k>template</c-></c-><c- o><c- o>&lt;</c-></c-><c- k><c- k>typename</c-></c-> <c- nc><c- nc>T</c-></c-><c- o><c- o>></c-></c->
    <c- kr><c- kr>inline</c-></c-> <c- k><c- k>constexpr</c-></c-> <c- b><c- b>bool</c-></c-> <c- n><c- n>is_property_key_list_v</c-></c-> <c- o><c- o>=</c-></c-> false<c- p><c- p>;</c-></c->

    <c- k><c- k>template</c-></c-><c- o><c- o>&lt;</c-></c-><c- k><c- k>typename</c-></c-><c- p><c- p>...</c-></c-> <c- n><c- n>Ts</c-></c-><c- o><c- o>></c-></c->
    <c- kr><c- kr>inline</c-></c-> <c- k><c- k>constexpr</c-></c-> <c- b><c- b>bool</c-></c-> <c- n><c- n>is_property_key_list_v</c-></c-><c- o><c- o>&lt;</c-></c-><c- n><c- n>property_key_list</c-></c-><c- o><c- o>&lt;</c-></c-><c- n><c- n>Ts</c-></c-><c- p><c- p>...</c-></c-><c- o><c- o>>></c-></c-> <c- o><c- o>=</c-></c-> true<c- p><c- p>;</c-></c->

    <c- p><c- p>...</c-></c->
<c- p><c- p>}</c-></c->
</pre></code></pre>
   <h3 class="heading settled" data-level="4.3" id="stdexecutionqueryable"><span class="secno">4.3. </span><span class="content"><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>execution</c-><c- o>::</c-><c- n>queryable</c-></code></span><a class="self-link" href="#stdexecutionqueryable"></a></h3>
    This concept determines whether or not a type is a Queryable Environment. 
<pre class="highlight"><code><pre class="highlight"><c- k><c- k>namespace</c-></c-> <c- nn><c- nn>std</c-></c-><c- o><c- o>::</c-></c-><c- nn><c- nn>execution</c-></c-> <c- p><c- p>{</c-></c->
    <c- p><c- p>...</c-></c->

    <c- k><c- k>template</c-></c-><c- o><c- o>&lt;</c-></c-><c- k><c- k>typename</c-></c-> <c- nc><c- nc>T</c-></c-><c- o><c- o>></c-></c->
    <c- k><c- k>concept</c-></c-> <c- nc><c- nc>queryable</c-></c-> <c- o><c- o>=</c-></c-> 
        <c- k><c- k>requires</c-></c->
        <c- p><c- p>{</c-></c->
            <c- k><c- k>typename</c-></c-> <c- nc><c- nc>T</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>property_keys</c-></c-><c- p><c- p>;</c-></c->
            <c- k><c- k>requires</c-></c-> <c- n><c- n>is_property_key_list_v</c-></c-><c- o><c- o>&lt;</c-></c-><c- k><c- k>typename</c-></c-> <c- nc><c- nc>T</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>property_keys</c-></c-><c- o><c- o>></c-></c-><c- p><c- p>;</c-></c->
        <c- p><c- p>};</c-></c->

    <c- p><c- p>...</c-></c->
<c- p><c- p>}</c-></c->
</pre></code></pre>
   <h3 class="heading settled" data-level="4.4" id="stdexecutionhas_query"><span class="secno">4.4. </span><span class="content"><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>execution</c-><c- o>::</c-><c- n>has_query</c-></code></span><a class="self-link" href="#stdexecutionhas_query"></a></h3>
    This concept determines if an Environment supports a Query. 
<pre class="highlight"><code><pre class="highlight"><c- k><c- k>namespace</c-></c-> <c- nn><c- nn>std</c-></c-><c- o><c- o>::</c-></c-><c- nn><c- nn>execution</c-></c-> <c- p><c- p>{</c-></c->
    <c- p><c- p>...</c-></c->

    <c- k><c- k>template</c-></c-><c- o><c- o>&lt;</c-></c-><c- k><c- k>typename</c-></c-> <c- nc><c- nc>E</c-></c-><c- p><c- p>,</c-></c-> <c- k><c- k>typename</c-></c-> <c- nc><c- nc>Q</c-></c-><c- o><c- o>></c-></c->
    <c- k><c- k>concept</c-></c-> <c- nc><c- nc>has_query</c-></c-> <c- o><c- o>=</c-></c->
        <c- k><c- k>requires</c-></c-> <c- p><c- p>(</c-></c-><c- n><c- n>E</c-></c-> <c- k><c- k>const</c-></c-><c- o><c- o>&amp;</c-></c-> <c- n><c- n>env</c-></c-><c- p><c- p>)</c-></c->
        <c- p><c- p>{</c-></c-> <c- n><c- n>env</c-></c-><c- p><c- p>.</c-></c-><c- n><c- n>query</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>Q</c-></c-><c- p><c- p>{</c-></c-> <c- p><c- p>});</c-></c-> <c- p><c- p>};</c-></c->

    <c- p><c- p>...</c-></c->
<c- p><c- p>}</c-></c->
</pre></code></pre>
   <h3 class="heading settled" data-level="4.5" id="stdexecutionhas_query_default"><span class="secno">4.5. </span><span class="content"><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>execution</c-><c- o>::</c-><c- n>has_query_default</c-></code></span><a class="self-link" href="#stdexecutionhas_query_default"></a></h3>
    This concept determines whether or not an Environment has a default value for a given
Query. 
<pre class="highlight"><code><pre class="highlight"><c- k><c- k>namespace</c-></c-> <c- nn><c- nn>std</c-></c-><c- o><c- o>::</c-></c-><c- nn><c- nn>execution</c-></c-> <c- p><c- p>{</c-></c->
    <c- p><c- p>...</c-></c->

    <c- k><c- k>template</c-></c-><c- o><c- o>&lt;</c-></c-><c- k><c- k>typename</c-></c-> <c- nc><c- nc>Q</c-></c-><c- o><c- o>></c-></c->
    <c- k><c- k>concept</c-></c-> <c- nc><c- nc>has_query_default</c-></c-> <c- o><c- o>=</c-></c->
        <c- k><c- k>requires</c-></c->
        <c- p><c- p>{</c-></c-> <c- n><c- n>Q</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>default_value</c-></c-><c- p><c- p>();</c-></c-> <c- p><c- p>};</c-></c->

    <c- p><c- p>...</c-></c->
<c- p><c- p>}</c-></c->
</pre></code></pre>
   <h3 class="heading settled" data-level="4.6" id="stdexecutionproperty"><span class="secno">4.6. </span><span class="content"><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>execution</c-><c- o>::</c-><c- n>property</c-></code></span><a class="self-link" href="#stdexecutionproperty"></a></h3>
    This concept determines what it means for a type to be a property. 
<pre class="highlight"><code><pre class="highlight"><c- k><c- k>namespace</c-></c-> <c- nn><c- nn>std</c-></c-><c- o><c- o>::</c-></c-><c- nn><c- nn>execution</c-></c-> <c- p><c- p>{</c-></c->
    <c- p><c- p>...</c-></c->

    <c- k><c- k>template</c-></c-><c- o><c- o>&lt;</c-></c-><c- k><c- k>typename</c-></c-> <c- nc><c- nc>T</c-></c-><c- o><c- o>></c-></c->
    <c- k><c- k>concept</c-></c-> <c- nc><c- nc>property</c-></c-> <c- o><c- o>=</c-></c-> 
        <c- n><c- n>std</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>is_empty_v</c-></c-><c- o><c- o>&lt;</c-></c-><c- n><c- n>T</c-></c-><c- o><c- o>></c-></c->
        <c- o><c- o>&amp;&amp;</c-></c-> <c- n><c- n>std</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>default_initializable</c-></c-><c- o><c- o>&lt;</c-></c-><c- n><c- n>T</c-></c-><c- o><c- o>></c-></c->

    <c- p><c- p>...</c-></c->
<c- p><c- p>}</c-></c->
</pre></code></pre>
   <h3 class="heading settled" data-level="4.7" id="stdexecutionhas_property"><span class="secno">4.7. </span><span class="content"><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>execution</c-><c- o>::</c-><c- n>has_property</c-></code></span><a class="self-link" href="#stdexecutionhas_property"></a></h3>
    This concept determines if a Queryable has a given property. 
<pre class="highlight"><code><pre class="highlight"><c- k><c- k>namespace</c-></c-> <c- nn><c- nn>std</c-></c-><c- o><c- o>::</c-></c-><c- nn><c- nn>execution</c-></c-> <c- p><c- p>{</c-></c->
    <c- p><c- p>...</c-></c->

    <c- k><c- k>template</c-></c-><c- o><c- o>&lt;</c-></c-><c- k><c- k>typename</c-></c-> <c- nc><c- nc>Q</c-></c-><c- p><c- p>,</c-></c-> <c- k><c- k>typename</c-></c-> <c- nc><c- nc>P</c-></c-><c- o><c- o>></c-></c->
    <c- k><c- k>concept</c-></c-> <c- nc><c- nc>has_property</c-></c-> <c- o><c- o>=</c-></c->
        <c- n><c- n>queryable</c-></c-><c- o><c- o>&lt;</c-></c-><c- n><c- n>Q</c-></c-><c- o><c- o>></c-></c->
        <c- o><c- o>&amp;&amp;</c-></c-> <c- n><c- n>property</c-></c-><c- o><c- o>&lt;</c-></c-><c- n><c- n>P</c-></c-><c- o><c- o>></c-></c->
        <c- o><c- o>&amp;&amp;</c-></c-> <c- n><c- n>has_query</c-></c-><c- o><c- o>&lt;</c-></c-><c- n><c- n>Q</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>P</c-></c-><c- o><c- o>></c-></c-><c- p><c- p>;</c-></c->

    <c- p><c- p>...</c-></c->
<c- p><c- p>}</c-></c->
</pre></code></pre>
   <p>The types from <a data-link-type="biblio" href="#biblio-p3325" title="A Utility for Creating Execution Environments">[p3325]</a> are extended to support a type-erased runtime Environment with
possibly empty properties.</p>
   <h3 class="heading settled" data-level="4.8" id="stdexecutionhas_try_query"><span class="secno">4.8. </span><span class="content"><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>execution</c-><c- o>::</c-><c- n>has_try_query</c-></code></span><a class="self-link" href="#stdexecutionhas_try_query"></a></h3>
    This concept determines if an Environment supports <code class="highlight"><c- n>try_query</c-></code>. 
<pre class="highlight"><code><pre class="highlight"><c- k><c- k>namespace</c-></c-> <c- nn><c- nn>std</c-></c-><c- o><c- o>::</c-></c-><c- nn><c- nn>execution</c-></c-> <c- p><c- p>{</c-></c->
    <c- p><c- p>...</c-></c->

    <c- k><c- k>template</c-></c-><c- o><c- o>&lt;</c-></c-><c- k><c- k>typename</c-></c-> <c- nc><c- nc>E</c-></c-><c- p><c- p>,</c-></c-> <c- k><c- k>typename</c-></c-> <c- nc><c- nc>Q</c-></c-><c- o><c- o>></c-></c->
    <c- k><c- k>concept</c-></c-> <c- nc><c- nc>has_try_query</c-></c-> <c- o><c- o>=</c-></c->
        <c- k><c- k>requires</c-></c-> <c- p><c- p>(</c-></c-><c- n><c- n>E</c-></c-> <c- k><c- k>const</c-></c-><c- o><c- o>&amp;</c-></c-> <c- n><c- n>env</c-></c-><c- p><c- p>);</c-></c->
        <c- p><c- p>{</c-></c-> <c- n><c- n>env</c-></c-><c- p><c- p>.</c-></c-><c- n><c- n>try_query</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>Q</c-></c-><c- p><c- p>{</c-></c-> <c- p><c- p>});</c-></c-> <c- p><c- p>};</c-></c->

    <c- p><c- p>...</c-></c->
<c- p><c- p>}</c-></c->
</pre></code></pre>
   <h3 class="heading settled" data-level="4.9" id="stdexecutionmaybe_has_property"><span class="secno">4.9. </span><span class="content"><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>execution</c-><c- o>::</c-><c- n>maybe_has_property</c-></code></span><a class="self-link" href="#stdexecutionmaybe_has_property"></a></h3>
    This concept determines if a Queryable may optionally have a given property. 
<pre class="highlight"><code><pre class="highlight"><c- k><c- k>namespace</c-></c-> <c- nn><c- nn>std</c-></c-><c- o><c- o>::</c-></c-><c- nn><c- nn>execution</c-></c-> <c- p><c- p>{</c-></c->
    <c- p><c- p>...</c-></c->

    <c- k><c- k>template</c-></c-><c- o><c- o>&lt;</c-></c-><c- k><c- k>typename</c-></c-> <c- nc><c- nc>Q</c-></c-><c- p><c- p>,</c-></c-> <c- k><c- k>typename</c-></c-> <c- nc><c- nc>P</c-></c-><c- o><c- o>></c-></c->
    <c- k><c- k>concept</c-></c-> <c- nc><c- nc>maybe_has_property</c-></c-> <c- o><c- o>=</c-></c->
        <c- n><c- n>queryable</c-></c-><c- o><c- o>&lt;</c-></c-><c- n><c- n>Q</c-></c-><c- o><c- o>></c-></c->
        <c- o><c- o>&amp;&amp;</c-></c-> <c- n><c- n>property</c-></c-><c- o><c- o>&lt;</c-></c-><c- n><c- n>P</c-></c-><c- o><c- o>></c-></c->
        <c- o><c- o>&amp;&amp;</c-></c-> <c- n><c- n>has_try_query</c-></c-><c- o><c- o>&lt;</c-></c-><c- n><c- n>Q</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>P</c-></c-><c- o><c- o>></c-></c-><c- p><c- p>;</c-></c->

    <c- p><c- p>...</c-></c->
<c- p><c- p>}</c-></c->
</pre></code></pre>
   <h3 class="heading settled" data-level="4.10" id="stdexecutionruntime_property"><span class="secno">4.10. </span><span class="content"><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>execution</c-><c- o>::</c-><c- n>runtime_property</c-></code></span><a class="self-link" href="#stdexecutionruntime_property"></a></h3>
    This concept determines if a type is a runtime type-erasable property. 
<pre class="highlight"><code><pre class="highlight"><c- k><c- k>namespace</c-></c-> <c- nn><c- nn>std</c-></c-><c- o><c- o>::</c-></c-><c- nn><c- nn>execution</c-></c-> <c- p><c- p>{</c-></c->

    <c- p><c- p>...</c-></c->

    <c- k><c- k>template</c-></c-><c- o><c- o>&lt;</c-></c-><c- k><c- k>typename</c-></c-> <c- nc><c- nc>T</c-></c-><c- o><c- o>></c-></c->
    <c- k><c- k>concept</c-></c-> <c- nc><c- nc>runtime_property</c-></c-> <c- o><c- o>=</c-></c->
        <c- n><c- n>property</c-></c-><c- o><c- o>&lt;</c-></c-><c- n><c- n>T</c-></c-><c- o><c- o>></c-></c->
        <c- o><c- o>&amp;&amp;</c-></c-> <c- k><c- k>requires</c-></c-> <c- p><c- p>{</c-></c-> <c- k><c- k>typename</c-></c-> <c- nc><c- nc>T</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>type_erased_type</c-></c-><c- p><c- p>;</c-></c-> <c- p><c- p>};</c-></c->

    <c- p><c- p>...</c-></c->
<c- p><c- p>}</c-></c->
</pre></code></pre>
   <h3 class="heading settled" data-level="4.11" id="stdexecutionruntime_env"><span class="secno">4.11. </span><span class="content"><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>execution</c-><c- o>::</c-><c- n>runtime_env</c-></code></span><a class="self-link" href="#stdexecutionruntime_env"></a></h3>
    A runtime type-erased Queryable Environment. 
<pre class="highlight"><code><pre class="highlight"><c- k><c- k>namespace</c-></c-> <c- nn><c- nn>std</c-></c-><c- o><c- o>::</c-></c-><c- nn><c- nn>execution</c-></c-> <c- p><c- p>{</c-></c->

    <c- p><c- p>...</c-></c->

    <c- k><c- k>class</c-></c-> <c- nc><c- nc>runtime_env</c-></c->
    <c- p><c- p>{</c-></c->
    <c- k><c- k>public</c-></c-><c- o><c- o>:</c-></c->
        <c- n><c- n>runtime_env</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>noexcept</c-></c-> <c- o><c- o>=</c-></c-> <c- k><c- k>default</c-></c-><c- p><c- p>;</c-></c->
        <c- k><c- k>operator</c-></c-> <c- n><c- n>runtime_env_ref</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>const</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->

        <c- k><c- k>template</c-></c-><c- o><c- o>&lt;</c-></c-><c- n><c- n>runtime_property</c-></c-> <c- n><c- n>P</c-></c-><c- p><c- p>,</c-></c-> <c- k><c- k>typename</c-></c-> <c- nc><c- nc>Tp</c-></c-><c- o><c- o>></c-></c->
            <c- k><c- k>requires</c-></c-> <c- n><c- n>std</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>constructible_from</c-></c-><c- o><c- o>&lt;</c-></c-><c- k><c- k>typename</c-></c-> <c- nc><c- nc>P</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>type_erased_type</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>Tp</c-></c-><c- o><c- o>></c-></c->
        <c- b><c- b>void</c-></c-> <c- n><c- n>set</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>P</c-></c-> <c- n><c- n>prop</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>Tp</c-></c-><c- o><c- o>&amp;&amp;</c-></c-> <c- n><c- n>init</c-></c-><c- p><c- p>);</c-></c->

        <c- k><c- k>template</c-></c-><c- o><c- o>&lt;</c-></c-><c- n><c- n>runtime_property</c-></c-> <c- n><c- n>P</c-></c-><c- o><c- o>></c-></c->
        <c- b><c- b>void</c-></c-> <c- n><c- n>unset</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>P</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->

        <c- k><c- k>template</c-></c-><c- o><c- o>&lt;</c-></c-><c- n><c- n>runtime_property</c-></c-> <c- n><c- n>P</c-></c-><c- o><c- o>></c-></c->
        <c- n><c- n>std</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>optional</c-></c-><c- o><c- o>&lt;</c-></c-><c- k><c- k>typename</c-></c-> <c- nc><c- nc>P</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>type_erased_type</c-></c-><c- o><c- o>></c-></c-> <c- n><c- n>try_query</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>P</c-></c-> <c- n><c- n>prop</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>const</c-></c->
            <c- k><c- k>noexcept</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>std</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>is_nothrow_copy_constructible_v</c-></c-><c- o><c- o>&lt;</c-></c-><c- k><c- k>typename</c-></c-> <c- nc><c- nc>P</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>type_erased_type</c-></c-><c- o><c- o>></c-></c-><c- p><c- p>);</c-></c->
    <c- p><c- p>};</c-></c->

    <c- p><c- p>...</c-></c->
<c- p><c- p>}</c-></c->
</pre></code></pre>
   <h3 class="heading settled" data-level="4.12" id="properties-of-endpoints"><span class="secno">4.12. </span><span class="content">Properties of endpoints</span><a class="self-link" href="#properties-of-endpoints"></a></h3>
   <h4 class="heading settled" data-level="4.12.1" id="stdnetipaddress_v4"><span class="secno">4.12.1. </span><span class="content"><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>net</c-><c- o>::</c-><c- n>ip</c-><c- o>::</c-><c- n>address_v4</c-></code></span><a class="self-link" href="#stdnetipaddress_v4"></a></h4>
    The IPV4 Address type. 
<pre class="highlight"><code><pre class="highlight"><c- k><c- k>namespace</c-></c-> <c- nn><c- nn>std</c-></c-><c- o><c- o>::</c-></c-><c- nn><c- nn>net</c-></c-><c- o><c- o>::</c-></c-><c- nn><c- nn>ip</c-></c-> <c- p><c- p>{</c-></c->

    <c- p><c- p>...</c-></c->

    <c- k><c- k>class</c-></c-> <c- nc><c- nc>address_v4</c-></c->
    <c- p><c- p>{</c-></c->
    <c- k><c- k>public</c-></c-><c- o><c- o>:</c-></c->
        <c- k><c- k>using</c-></c-> <c- n><c- n>uint_type</c-></c-> <c- o><c- o>=</c-></c-> <c- b><c- b>uint_least32_t</c-></c-><c- p><c- p>;</c-></c->
        <c- k><c- k>using</c-></c-> <c- n><c- n>bytes_type</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>std</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>array</c-></c-><c- o><c- o>&lt;</c-></c-><c- b><c- b>unsigned</c-></c-> <c- b><c- b>char</c-></c-><c- p><c- p>,</c-></c-> <c- k><c- k>sizeof</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>uint_type</c-></c-><c- p><c- p>)</c-></c-><c- o><c- o>></c-></c-><c- p><c- p>;</c-></c->

        <c- k><c- k>constexpr</c-></c-> <c- n><c- n>address_v4</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
        <c- k><c- k>constexpr</c-></c-> <c- k><c- k>explicit</c-></c-> <c- n><c- n>address_v4</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>bytes_type</c-></c-> <c- k><c- k>const</c-></c-><c- o><c- o>&amp;</c-></c-> <c- n><c- n>bytes</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
        <c- k><c- k>constexpr</c-></c-> <c- k><c- k>explicit</c-></c-> <c- n><c- n>address_v4</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>uint_type</c-></c-> <c- n><c- n>v</c-></c-><c- p><c- p>);</c-></c->
    <c- p><c- p>};</c-></c->
    <c- p><c- p>...</c-></c->
<c- p><c- p>}</c-></c->
</pre></code></pre>
   <h4 class="heading settled" data-level="4.12.2" id="stdnetipaddress_v6"><span class="secno">4.12.2. </span><span class="content"><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>net</c-><c- o>::</c-><c- n>ip</c-><c- o>::</c-><c- n>address_v6</c-></code></span><a class="self-link" href="#stdnetipaddress_v6"></a></h4>
    The IPV6 Address type. 
<pre class="highlight"><code><pre class="highlight"><c- k><c- k>namespace</c-></c-> <c- nn><c- nn>std</c-></c-><c- o><c- o>::</c-></c-><c- nn><c- nn>net</c-></c-><c- o><c- o>::</c-></c-><c- nn><c- nn>ip</c-></c-> <c- p><c- p>{</c-></c->

    <c- p><c- p>...</c-></c->

    <c- k><c- k>using</c-></c-> <c- n><c- n>scope_id_type</c-></c-> <c- o><c- o>=</c-></c-> <c- b><c- b>uint_least32_t</c-></c-><c- p><c- p>;</c-></c->

    <c- k><c- k>class</c-></c-> <c- nc><c- nc>address_v6</c-></c->
    <c- p><c- p>{</c-></c->
    <c- k><c- k>public</c-></c-><c- o><c- o>:</c-></c->
        <c- k><c- k>static</c-></c-> <c- k><c- k>constexpr</c-></c-> <c- n><c- n>std</c-></c-><c- o><c- o>::</c-></c-><c- b><c- b>size_t</c-></c-> <c- k><c- k>const</c-></c-> <c- n><c- n>bytes_len</c-></c-> <c- o><c- o>=</c-></c-> <c- k><c- k>sizeof</c-></c-><c- p><c- p>(</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>in6_addr</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>s6_addr</c-></c-><c- p><c- p>);</c-></c->
        <c- k><c- k>using</c-></c-> <c- n><c- n>bytes_type</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>std</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>array</c-></c-><c- o><c- o>&lt;</c-></c-><c- b><c- b>unsigned</c-></c-> <c- b><c- b>char</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>bytes_len</c-></c-><c- o><c- o>></c-></c-><c- p><c- p>;</c-></c->

        <c- k><c- k>constexpr</c-></c-> <c- n><c- n>address_v6</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->

        <c- k><c- k>constexpr</c-></c-> <c- k><c- k>explicit</c-></c-> <c- n><c- n>address_v6</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>bytes_type</c-></c-> <c- k><c- k>const</c-></c-><c- o><c- o>&amp;</c-></c-> <c- n><c- n>bytes</c-></c-><c- p><c- p>,</c-></c->
                                      <c- n><c- n>scope_id_type</c-></c-> <c- n><c- n>scope</c-></c-> <c- o><c- o>=</c-></c-> <c- mi><c- mi>0</c-></c-><c- p><c- p>)</c-></c->
                <c- k><c- k>noexcept</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>std</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>numeric_limits</c-></c-><c- o><c- o>&lt;</c-></c-><c- n><c- n>bytes_type</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>value_type</c-></c-><c- o><c- o>>::</c-></c-><c- n><c- n>max</c-></c-><c- p><c- p>()</c-></c-> <c- o><c- o>==</c-></c-> <c- mh><c- mh>0xff</c-></c-><c- p><c- p>);</c-></c->
    <c- p><c- p>};</c-></c->

    <c- p><c- p>...</c-></c->
<c- p><c- p>}</c-></c->
</pre></code></pre>
   <h4 class="heading settled" data-level="4.12.3" id="stdnetipaddress"><span class="secno">4.12.3. </span><span class="content"><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>net</c-><c- o>::</c-><c- n>ip</c-><c- o>::</c-><c- n>address</c-></code></span><a class="self-link" href="#stdnetipaddress"></a></h4>
    The IP Address type. 
<pre class="highlight"><code><pre class="highlight"><c- k><c- k>namespace</c-></c-> <c- nn><c- nn>std</c-></c-><c- o><c- o>::</c-></c-><c- nn><c- nn>net</c-></c-><c- o><c- o>::</c-></c-><c- nn><c- nn>ip</c-></c-> <c- p><c- p>{</c-></c->

    <c- p><c- p>...</c-></c->

    <c- k><c- k>class</c-></c-> <c- nc><c- nc>address</c-></c->
    <c- p><c- p>{</c-></c->
    <c- k><c- k>public</c-></c-><c- o><c- o>:</c-></c->
        <c- k><c- k>constexpr</c-></c-> <c- k><c- k>explicit</c-></c-> <c- n><c- n>address</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>address_v4</c-></c-> <c- n><c- n>addr</c-></c-><c- p><c- p>);</c-></c->
        <c- k><c- k>constexpr</c-></c-> <c- k><c- k>explicit</c-></c-> <c- n><c- n>address</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>address_v6</c-></c-> <c- n><c- n>addr</c-></c-><c- p><c- p>);</c-></c->

        <c- k><c- k>constexpr</c-></c-> <c- b><c- b>bool</c-></c-> <c- nf><c- nf>is_v4</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>const</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
        <c- k><c- k>constexpr</c-></c-> <c- b><c- b>bool</c-></c-> <c- nf><c- nf>is_v6</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>const</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- p><c- p>};</c-></c->

    <c- p><c- p>...</c-></c->
<c- p><c- p>}</c-></c->
</pre></code></pre>
   <h4 class="heading settled" data-level="4.12.4" id="stdnethostname"><span class="secno">4.12.4. </span><span class="content"><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>net</c-><c- o>::</c-><c- n>hostname</c-></code></span><a class="self-link" href="#stdnethostname"></a></h4>
    The hostname type. 
<pre class="highlight"><code><pre class="highlight"><c- k><c- k>namespace</c-></c-> <c- nn><c- nn>std</c-></c-><c- o><c- o>::</c-></c-><c- nn><c- nn>net</c-></c-> <c- p><c- p>{</c-></c->

    <c- p><c- p>...</c-></c->

    <c- k><c- k>class</c-></c-> <c- nc><c- nc>hostname</c-></c->
    <c- p><c- p>{</c-></c->
    <c- k><c- k>public</c-></c-><c- o><c- o>:</c-></c->
        <c- n><c- n>hostname</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>std</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>string_view</c-></c-> <c- n><c- n>str</c-></c-><c- p><c- p>);</c-></c->

        <c- p><c- p>...</c-></c->
    <c- p><c- p>};</c-></c->

    <c- p><c- p>...</c-></c->
<c- p><c- p>}</c-></c->
</pre></code></pre>
   <h4 class="heading settled" data-level="4.12.5" id="stdnetinterface"><span class="secno">4.12.5. </span><span class="content"><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>net</c-><c- o>::</c-><c- n>interface</c-></code></span><a class="self-link" href="#stdnetinterface"></a></h4>
    The network interface type. 
<pre class="highlight"><code><pre class="highlight"><c- k><c- k>namespace</c-></c-> <c- nn><c- nn>std</c-></c-><c- o><c- o>::</c-></c-><c- nn><c- nn>net</c-></c-> <c- p><c- p>{</c-></c->

    <c- p><c- p>...</c-></c->

    <c- k><c- k>class</c-></c-> <c- nc><c- nc>interface</c-></c->
    <c- p><c- p>{</c-></c->
    <c- k><c- k>public</c-></c-><c- o><c- o>:</c-></c->
        <c- n><c- n>interface</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>std</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>string_view</c-></c-> <c- n><c- n>str</c-></c-><c- p><c- p>);</c-></c->

        <c- p><c- p>...</c-></c->
    <c- p><c- p>};</c-></c->

    <c- p><c- p>...</c-></c->
<c- p><c- p>}</c-></c->
</pre></code></pre>
   <h4 class="heading settled" data-level="4.12.6" id="stdnetservice"><span class="secno">4.12.6. </span><span class="content"><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>net</c-><c- o>::</c-><c- n>service</c-></code></span><a class="self-link" href="#stdnetservice"></a></h4>
    The network service type. 
<pre class="highlight"><code><pre class="highlight"><c- k><c- k>namespace</c-></c-> <c- nn><c- nn>std</c-></c-><c- o><c- o>::</c-></c-><c- nn><c- nn>net</c-></c-> <c- p><c- p>{</c-></c->

    <c- p><c- p>...</c-></c->

    <c- k><c- k>class</c-></c-> <c- nc><c- nc>service</c-></c->
    <c- p><c- p>{</c-></c->
    <c- k><c- k>public</c-></c-><c- o><c- o>:</c-></c->
        <c- n><c- n>service</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>std</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>string_view</c-></c-> <c- n><c- n>str</c-></c-><c- p><c- p>);</c-></c->

        <c- c1><c- c1>// TODO constants for well known services, e.g. 'https'</c-></c->

        <c- p><c- p>...</c-></c->
    <c- p><c- p>};</c-></c->

    <c- p><c- p>...</c-></c->
<c- p><c- p>}</c-></c->
</pre></code></pre>
   <h4 class="heading settled" data-level="4.12.7" id="stdnetsingle_source_multicast_group_address"><span class="secno">4.12.7. </span><span class="content"><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>net</c-><c- o>::</c-><c- n>single_source_multicast_group_address</c-></code></span><a class="self-link" href="#stdnetsingle_source_multicast_group_address"></a></h4>
    The single source multicast group address type. 
<pre class="highlight"><code><pre class="highlight"><c- k><c- k>namespace</c-></c-> <c- nn><c- nn>std</c-></c-><c- o><c- o>::</c-></c-><c- nn><c- nn>net</c-></c-> <c- p><c- p>{</c-></c->

    <c- p><c- p>...</c-></c->

    <c- k><c- k>class</c-></c-> <c- nc><c- nc>single_source_multicast_group_address</c-></c->
    <c- p><c- p>{</c-></c->
    <c- k><c- k>public</c-></c-><c- o><c- o>:</c-></c->
        <c- n><c- n>single_source_multicast_group_address</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>ip</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>address</c-></c-> <c- n><c- n>group</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>ip</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>address</c-></c-> <c- n><c- n>source</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->

        <c- n><c- n>ip</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>address</c-></c-> <c- k><c- k>const</c-></c-><c- o><c- o>&amp;</c-></c-> <c- n><c- n>group</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>const</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
        <c- n><c- n>ip</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>address</c-></c-> <c- k><c- k>const</c-></c-><c- o><c- o>&amp;</c-></c-> <c- n><c- n>source</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>const</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->

        <c- p><c- p>...</c-></c->
    <c- p><c- p>};</c-></c->

    <c- p><c- p>...</c-></c->
<c- p><c- p>}</c-></c->
</pre></code></pre>
   <h4 class="heading settled" data-level="4.12.8" id="stdnetendpoint_props"><span class="secno">4.12.8. </span><span class="content"><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>net</c-><c- o>::</c-><c- n>endpoint_props</c-></code></span><a class="self-link" href="#stdnetendpoint_props"></a></h4>
    Nested namespace containing strongly typed properties of endpoints. 
<pre class="highlight"><code><pre class="highlight"><c- k><c- k>namespace</c-></c-> <c- nn><c- nn>std</c-></c-><c- o><c- o>::</c-></c-><c- nn><c- nn>net</c-></c-><c- o><c- o>::</c-></c-><c- nn><c- nn>transport_props</c-></c-> <c- p><c- p>{</c-></c->

    <c- p><c- p>...</c-></c->

    <c- k><c- k>class</c-></c-> <c- nc><c- nc>hostname</c-></c->
    <c- p><c- p>{</c-></c->
    <c- k><c- k>public</c-></c-><c- o><c- o>:</c-></c->
        <c- k><c- k>using</c-></c-> <c- n><c- n>value_type</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>hostname</c-></c-><c- p><c- p>;</c-></c->
        <c- p><c- p>...</c-></c->
    <c- p><c- p>};</c-></c->

    <c- k><c- k>class</c-></c-> <c- nc><c- nc>ip_address</c-></c->
    <c- p><c- p>{</c-></c->
    <c- k><c- k>public</c-></c-><c- o><c- o>:</c-></c->
        <c- k><c- k>using</c-></c-> <c- n><c- n>value_type</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>ip</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>address</c-></c-><c- p><c- p>;</c-></c->
        <c- p><c- p>...</c-></c->
    <c- p><c- p>};</c-></c->

    <c- k><c- k>class</c-></c-> <c- nc><c- nc>port</c-></c-> 
    <c- p><c- p>{</c-></c->
    <c- k><c- k>public</c-></c-><c- o><c- o>:</c-></c->
        <c- k><c- k>using</c-></c-> <c- n><c- n>value_type</c-></c-> <c- o><c- o>=</c-></c-> <c- b><c- b>uint16_t</c-></c-><c- p><c- p>;</c-></c->
        <c- p><c- p>...</c-></c->
    <c- p><c- p>};</c-></c->

    <c- k><c- k>class</c-></c-> <c- nc><c- nc>interface</c-></c->
    <c- p><c- p>{</c-></c->
    <c- k><c- k>public</c-></c-><c- o><c- o>:</c-></c->
        <c- k><c- k>using</c-></c-> <c- n><c- n>value_type</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>interface</c-></c-><c- p><c- p>;</c-></c->
        <c- p><c- p>...</c-></c->
    <c- p><c- p>};</c-></c->

    <c- k><c- k>class</c-></c-> <c- nc><c- nc>service</c-></c->
    <c- p><c- p>{</c-></c->
    <c- k><c- k>public</c-></c-><c- o><c- o>:</c-></c->
        <c- k><c- k>using</c-></c-> <c- n><c- n>value_type</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>service</c-></c-><c- p><c- p>;</c-></c->
        <c- p><c- p>...</c-></c->
    <c- p><c- p>};</c-></c->

    <c- k><c- k>class</c-></c-> <c- nc><c- nc>multicast_group</c-></c->
    <c- p><c- p>{</c-></c->
    <c- k><c- k>public</c-></c-><c- o><c- o>:</c-></c->
        <c- k><c- k>using</c-></c-> <c- n><c- n>value_type</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>ip</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>address</c-></c-><c- p><c- p>;</c-></c->
        <c- p><c- p>...</c-></c->
    <c- p><c- p>};</c-></c->

    <c- k><c- k>class</c-></c-> <c- nc><c- nc>hop_limit</c-></c->
    <c- p><c- p>{</c-></c->
    <c- k><c- k>public</c-></c-><c- o><c- o>:</c-></c->
        <c- k><c- k>using</c-></c-> <c- n><c- n>value_type</c-></c-> <c- o><c- o>=</c-></c-> <c- b><c- b>uint16_t</c-></c-><c- p><c- p>;</c-></c->
        <c- p><c- p>...</c-></c->
    <c- p><c- p>};</c-></c->

    <c- k><c- k>class</c-></c-> <c- nc><c- nc>any_source_multicast_group</c-></c->
    <c- p><c- p>{</c-></c->
    <c- k><c- k>public</c-></c-><c- o><c- o>:</c-></c->
        <c- k><c- k>using</c-></c-> <c- n><c- n>value_type</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>ip</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>address</c-></c-><c- p><c- p>;</c-></c->
        <c- p><c- p>...</c-></c->
    <c- p><c- p>};</c-></c->

    <c- k><c- k>class</c-></c-> <c- nc><c- nc>single_source_multicast_group</c-></c->
    <c- p><c- p>{</c-></c->
    <c- k><c- k>public</c-></c-><c- o><c- o>:</c-></c->
        <c- k><c- k>using</c-></c-> <c- n><c- n>value_type</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>single_source_multicast_group_address</c-></c-><c- p><c- p>;</c-></c->
        <c- p><c- p>...</c-></c->
    <c- p><c- p>};</c-></c->

    <c- p><c- p>...</c-></c->
<c- p><c- p>}</c-></c->
</pre></code></pre>
   <h3 class="heading settled" data-level="4.13" id="properties-of-transports"><span class="secno">4.13. </span><span class="content">Properties of transports</span><a class="self-link" href="#properties-of-transports"></a></h3>
   <h4 class="heading settled" data-level="4.13.1" id="stdnettransport_preference"><span class="secno">4.13.1. </span><span class="content"><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>net</c-><c- o>::</c-><c- n>transport_preference</c-></code></span><a class="self-link" href="#stdnettransport_preference"></a></h4>
    Enumeration to describe the preference for a transport property to apply to a connection. 
<pre class="highlight"><code><pre class="highlight"><c- k><c- k>namespace</c-></c-> <c- nn><c- nn>std</c-></c-><c- o><c- o>::</c-></c-><c- nn><c- nn>net</c-></c-> <c- p><c- p>{</c-></c->

    <c- p><c- p>...</c-></c->

    <c- k><c- k>enum</c-></c-> <c- k><c- k>class</c-></c-> <c- nc><c- nc>transport_preference</c-></c->
    <c- p><c- p>{</c-></c->
        <c- n><c- n>require</c-></c-><c- p><c- p>,</c-></c->
        <c- n><c- n>prefer</c-></c-><c- p><c- p>,</c-></c->
        <c- n><c- n>none</c-></c-><c- p><c- p>,</c-></c->
        <c- n><c- n>avoid</c-></c-><c- p><c- p>,</c-></c->
        <c- n><c- n>prohibit</c-></c->
    <c- p><c- p>};</c-></c->

    <c- p><c- p>...</c-></c->
<c- p><c- p>}</c-></c->
</pre></code></pre>
   <h4 class="heading settled" data-level="4.13.2" id="stdnetmultipath_preference"><span class="secno">4.13.2. </span><span class="content"><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>net</c-><c- o>::</c-><c- n>multipath_preference</c-></code></span><a class="self-link" href="#stdnetmultipath_preference"></a></h4>
    Enumeration describing the preference for the transport to support a multipathing. 
<pre class="highlight"><code><pre class="highlight"><c- k><c- k>namespace</c-></c-> <c- nn><c- nn>std</c-></c-><c- o><c- o>::</c-></c-><c- nn><c- nn>net</c-></c-> <c- p><c- p>{</c-></c->

    <c- p><c- p>...</c-></c->

    <c- k><c- k>enum</c-></c-> <c- k><c- k>class</c-></c-> <c- nc><c- nc>multipath_preference</c-></c->
    <c- p><c- p>{</c-></c->
        <c- n><c- n>disabled</c-></c-><c- p><c- p>,</c-></c->
        <c- n><c- n>active</c-></c-><c- p><c- p>,</c-></c->
        <c- n><c- n>passive</c-></c->
    <c- p><c- p>};</c-></c->

    <c- p><c- p>...</c-></c->
<c- p><c- p>}</c-></c->
</pre></code></pre>
   <h4 class="heading settled" data-level="4.13.3" id="stdnetdirection_preference"><span class="secno">4.13.3. </span><span class="content"><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>net</c-><c- o>::</c-><c- n>direction_preference</c-></code></span><a class="self-link" href="#stdnetdirection_preference"></a></h4>
    Enumeration describing the directionality preference for a connection. 
<pre class="highlight"><code><pre class="highlight"><c- k><c- k>namespace</c-></c-> <c- nn><c- nn>std</c-></c-><c- o><c- o>::</c-></c-><c- nn><c- nn>net</c-></c-> <c- p><c- p>{</c-></c->

    <c- p><c- p>...</c-></c->

    <c- k><c- k>enum</c-></c-> <c- k><c- k>class</c-></c-> <c- nc><c- nc>direction_preference</c-></c->
    <c- p><c- p>{</c-></c->
        <c- n><c- n>bidirectional</c-></c-><c- p><c- p>,</c-></c->
        <c- n><c- n>send</c-></c-><c- p><c- p>,</c-></c->
        <c- n><c- n>recv</c-></c->
    <c- p><c- p>};</c-></c->

    <c- p><c- p>...</c-></c->
<c- p><c- p>}</c-></c->
</pre></code></pre>
   <h4 class="heading settled" data-level="4.13.4" id="stdnetinterface_preference"><span class="secno">4.13.4. </span><span class="content"><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>net</c-><c- o>::</c-><c- n>interface_preference</c-></code></span><a class="self-link" href="#stdnetinterface_preference"></a></h4>
    Multi-valued property indicating what preference(s) should be applied to local endpoints when
evaluating potential networking interfaces. 
<pre class="highlight"><code><pre class="highlight"><c- k><c- k>namespace</c-></c-> <c- nn><c- nn>std</c-></c-><c- o><c- o>::</c-></c-><c- nn><c- nn>net</c-></c-> <c- p><c- p>{</c-></c->

    <c- p><c- p>...</c-></c->

    <c- k><c- k>class</c-></c-> <c- nc><c- nc>interface_preference</c-></c->
    <c- p><c- p>{</c-></c->
    <c- k><c- k>public</c-></c-><c- o><c- o>:</c-></c->
        <c- k><c- k>using</c-></c-> <c- n><c- n>value_type</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>std</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>pair</c-></c-><c- o><c- o>&lt;</c-></c-><c- n><c- n>interface</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>transport_preference</c-></c-><c- o><c- o>></c-></c-><c- p><c- p>;</c-></c->

        <c- n><c- n>interface_preference</c-></c-><c- p><c- p>()</c-></c-> <c- o><c- o>=</c-></c-> <c- k><c- k>default</c-></c-><c- p><c- p>;</c-></c->

        <c- n><c- n>interface_preference</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>std</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>initializer_list</c-></c-><c- o><c- o>&lt;</c-></c-><c- n><c- n>value_type</c-></c-><c- o><c- o>>&amp;&amp;</c-></c-> <c- n><c- n>values</c-></c-><c- p><c- p>)</c-></c->
            <c- o><c- o>:</c-></c-> <c- n><c- n>values_</c-></c-><c- p><c- p>{</c-></c-> <c- n><c- n>std</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>move</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>values</c-></c-><c- p><c- p>)</c-></c-> <c- p><c- p>}</c-></c->
        <c- p><c- p>{</c-></c-> <c- p><c- p>}</c-></c->

        <c- n><c- n>interface_preference</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>interface</c-></c-> <c- n><c- n>iface</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>transport_preference</c-></c-> <c- n><c- n>pref</c-></c-><c- p><c- p>)</c-></c->
            <c- o><c- o>:</c-></c-> <c- n><c- n>values_</c-></c-><c- p><c- p>{</c-></c-> <c- n><c- n>std</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>make_pair</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>iface</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>pref</c-></c-><c- p><c- p>)</c-></c-> <c- p><c- p>}</c-></c->
        <c- p><c- p>{</c-></c-> <c- p><c- p>}</c-></c->

        <c- k><c- k>using</c-></c-> <c- n><c- n>iterator</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>values_type</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>iterator</c-></c-><c- p><c- p>;</c-></c->
        <c- k><c- k>using</c-></c-> <c- n><c- n>const_iterator</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>values_type</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>const_iterator</c-></c-><c- p><c- p>;</c-></c->

        <c- n><c- n>iterator</c-></c-> <c- nf><c- nf>begin</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
        <c- n><c- n>const_iterator</c-></c-> <c- nf><c- nf>begin</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>const</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->

        <c- n><c- n>iterator</c-></c-> <c- nf><c- nf>end</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
        <c- n><c- n>const_iterator</c-></c-> <c- nf><c- nf>end</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>const</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->

        <c- b><c- b>void</c-></c-> <c- nf><c- nf>set</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>interface</c-></c-> <c- n><c- n>iface</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>transport_preference</c-></c-> <c- n><c- n>pref</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
        <c- b><c- b>void</c-></c-> <c- nf><c- nf>unset</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>interface</c-></c-> <c- n><c- n>iface</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- p><c- p>};</c-></c->

    <c- p><c- p>...</c-></c->
<c- p><c- p>}</c-></c->
</pre></code></pre>
   <h4 class="heading settled" data-level="4.13.5" id="stdnettransport_props"><span class="secno">4.13.5. </span><span class="content"><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>net</c-><c- o>::</c-><c- n>transport_props</c-></code></span><a class="self-link" href="#stdnettransport_props"></a></h4>
    Nested namespace containing strongly typed properties of transports. 
<pre class="highlight"><code><pre class="highlight"><c- k><c- k>namespace</c-></c-> <c- nn><c- nn>std</c-></c-><c- o><c- o>::</c-></c-><c- nn><c- nn>net</c-></c-><c- o><c- o>::</c-></c-><c- nn><c- nn>transport_props</c-></c-> <c- p><c- p>{</c-></c->

    <c- k><c- k>class</c-></c-> <c- nc><c- nc>interface</c-></c->
    <c- p><c- p>{</c-></c->
    <c- k><c- k>public</c-></c-><c- o><c- o>:</c-></c->
        <c- k><c- k>using</c-></c-> <c- n><c- n>value_type</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>interface_preference</c-></c-><c- p><c- p>;</c-></c->

        <c- c1><c- c1>// default value - interface_preference{ } a.k.a. any interface</c-></c->
        <c- k><c- k>static</c-></c-> <c- n><c- n>value_type</c-></c-> <c- nf><c- nf>default_value</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- p><c- p>};</c-></c->

    <c- k><c- k>class</c-></c-> <c- nc><c- nc>reliability</c-></c->
    <c- p><c- p>{</c-></c->
    <c- k><c- k>public</c-></c-><c- o><c- o>:</c-></c->
        <c- k><c- k>using</c-></c-> <c- n><c- n>value_type</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>transport_preference</c-></c-><c- p><c- p>;</c-></c->

        <c- c1><c- c1>// default value - transport_preference::require</c-></c->
        <c- k><c- k>static</c-></c-> <c- n><c- n>value_type</c-></c-> <c- nf><c- nf>default_value</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- p><c- p>};</c-></c->

    <c- k><c- k>class</c-></c-> <c- nc><c- nc>preserve_msg_boundaries</c-></c->
    <c- p><c- p>{</c-></c->
    <c- k><c- k>public</c-></c-><c- o><c- o>:</c-></c->
        <c- k><c- k>using</c-></c-> <c- n><c- n>value_type</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>transport_preference</c-></c-><c- p><c- p>;</c-></c->

        <c- c1><c- c1>// default value - transport_preference::none</c-></c->
        <c- k><c- k>static</c-></c-> <c- n><c- n>value_type</c-></c-> <c- nf><c- nf>default_value</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- p><c- p>};</c-></c->

    <c- k><c- k>class</c-></c-> <c- nc><c- nc>per_msg_reliability</c-></c->
    <c- p><c- p>{</c-></c->
    <c- k><c- k>public</c-></c-><c- o><c- o>:</c-></c->
        <c- k><c- k>using</c-></c-> <c- n><c- n>value_type</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>transport_preference</c-></c-><c- p><c- p>;</c-></c->

        <c- c1><c- c1>// default value - transport_preference::none</c-></c->
        <c- k><c- k>static</c-></c-> <c- n><c- n>value_type</c-></c-> <c- nf><c- nf>default_value</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- p><c- p>};</c-></c->

    <c- k><c- k>class</c-></c-> <c- nc><c- nc>preserve_order</c-></c->
    <c- p><c- p>{</c-></c->
    <c- k><c- k>public</c-></c-><c- o><c- o>:</c-></c->
        <c- k><c- k>using</c-></c-> <c- n><c- n>value_type</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>transport_preference</c-></c-><c- p><c- p>;</c-></c->

        <c- c1><c- c1>// default value - transport_preference::require</c-></c->
        <c- k><c- k>static</c-></c-> <c- n><c- n>value_type</c-></c-> <c- nf><c- nf>default_value</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- p><c- p>};</c-></c->

    <c- k><c- k>class</c-></c-> <c- nc><c- nc>zero_rtt_msg</c-></c->
    <c- p><c- p>{</c-></c->
    <c- k><c- k>public</c-></c-><c- o><c- o>:</c-></c->
        <c- k><c- k>using</c-></c-> <c- n><c- n>value_type</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>transport_preference</c-></c-><c- p><c- p>;</c-></c->

        <c- c1><c- c1>// default value - transport_preference::none</c-></c->
        <c- k><c- k>static</c-></c-> <c- n><c- n>value_type</c-></c-> <c- nf><c- nf>default_value</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- p><c- p>};</c-></c->

    <c- k><c- k>class</c-></c-> <c- nc><c- nc>multistreaming</c-></c->
    <c- p><c- p>{</c-></c->
    <c- k><c- k>public</c-></c-><c- o><c- o>:</c-></c->
        <c- k><c- k>using</c-></c-> <c- n><c- n>value_type</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>transport_preference</c-></c-><c- p><c- p>;</c-></c->

        <c- c1><c- c1>// default value - transport_preference::prefer</c-></c->
        <c- k><c- k>static</c-></c-> <c- n><c- n>value_type</c-></c-> <c- nf><c- nf>default_value</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- p><c- p>};</c-></c->

    <c- k><c- k>class</c-></c-> <c- nc><c- nc>full_checksum_send</c-></c->
    <c- p><c- p>{</c-></c->
    <c- k><c- k>public</c-></c-><c- o><c- o>:</c-></c->
        <c- k><c- k>using</c-></c-> <c- n><c- n>value_type</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>transport_preference</c-></c-><c- p><c- p>;</c-></c->

        <c- c1><c- c1>// default value - transport_preference::require</c-></c->
        <c- k><c- k>static</c-></c-> <c- n><c- n>value_type</c-></c-> <c- nf><c- nf>default_value</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- p><c- p>};</c-></c->

    <c- k><c- k>class</c-></c-> <c- nc><c- nc>full_checksum_recv</c-></c->
    <c- p><c- p>{</c-></c->
    <c- k><c- k>public</c-></c-><c- o><c- o>:</c-></c->
        <c- k><c- k>using</c-></c-> <c- n><c- n>value_type</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>transport_preference</c-></c-><c- p><c- p>;</c-></c->

        <c- c1><c- c1>// default value - transport_preference::require</c-></c->
        <c- k><c- k>static</c-></c-> <c- n><c- n>value_type</c-></c-> <c- nf><c- nf>default_value</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- p><c- p>};</c-></c->

    <c- k><c- k>class</c-></c-> <c- nc><c- nc>congestion_control</c-></c->
    <c- p><c- p>{</c-></c->
    <c- k><c- k>public</c-></c-><c- o><c- o>:</c-></c->
        <c- k><c- k>using</c-></c-> <c- n><c- n>value_type</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>transport_preference</c-></c-><c- p><c- p>;</c-></c->

        <c- c1><c- c1>// default value - transport_preference::require</c-></c->
        <c- k><c- k>static</c-></c-> <c- n><c- n>value_type</c-></c-> <c- nf><c- nf>default_value</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- p><c- p>};</c-></c->

    <c- k><c- k>class</c-></c-> <c- nc><c- nc>keep_alive</c-></c->
    <c- p><c- p>{</c-></c->
    <c- k><c- k>public</c-></c-><c- o><c- o>:</c-></c->
        <c- k><c- k>using</c-></c-> <c- n><c- n>value_type</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>transport_preference</c-></c-><c- p><c- p>;</c-></c->

        <c- c1><c- c1>// default value - transport_preference::none</c-></c->
        <c- k><c- k>static</c-></c-> <c- n><c- n>value_type</c-></c-> <c- nf><c- nf>default_value</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- p><c- p>};</c-></c->

    <c- k><c- k>class</c-></c-> <c- nc><c- nc>interface</c-></c->
    <c- p><c- p>{</c-></c->
    <c- k><c- k>public</c-></c-><c- o><c- o>:</c-></c->
        <c- k><c- k>using</c-></c-> <c- n><c- n>value_type</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>interface_preference</c-></c-><c- p><c- p>;</c-></c->

        <c- c1><c- c1>// default value - interface_preference{ } a.k.a. any interface</c-></c->
        <c- k><c- k>static</c-></c-> <c- n><c- n>value_type</c-></c-> <c- nf><c- nf>default_value</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- p><c- p>};</c-></c->

    <c- c1><c- c1>// TDDO class provisioning_domain; /* see [RFC7556] */</c-></c->

    <c- k><c- k>class</c-></c-> <c- nc><c- nc>use_temp_local_address</c-></c->
    <c- p><c- p>{</c-></c->
    <c- k><c- k>public</c-></c-><c- o><c- o>:</c-></c->
        <c- k><c- k>using</c-></c-> <c- n><c- n>value_type</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>transport_preference</c-></c-><c- p><c- p>;</c-></c->

        <c- c1><c- c1>// TODO review this, it varies based on address type (e.g. ipv6 only) and connection (avoid for</c-></c->
        <c- c1><c- c1>// listeners and redezvous, prefer for rest).</c-></c->
        <c- c1><c- c1>// default value - transport_preference::none</c-></c->
        <c- k><c- k>static</c-></c-> <c- n><c- n>value_type</c-></c-> <c- nf><c- nf>default_value</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- p><c- p>};</c-></c->

    <c- k><c- k>class</c-></c-> <c- nc><c- nc>multipath</c-></c->
    <c- p><c- p>{</c-></c->
    <c- k><c- k>public</c-></c-><c- o><c- o>:</c-></c->
        <c- k><c- k>using</c-></c-> <c- n><c- n>value_type</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>multipath_preference</c-></c-><c- p><c- p>;</c-></c->

        <c- c1><c- c1>// TODO review this, it varies based on how connections are initiated</c-></c->
        <c- c1><c- c1>// default value - transport_preference::disabled</c-></c->
        <c- k><c- k>static</c-></c-> <c- n><c- n>value_type</c-></c-> <c- nf><c- nf>default_value</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- p><c- p>};</c-></c->

    <c- k><c- k>class</c-></c-> <c- nc><c- nc>advertises_alt_addr</c-></c->
    <c- p><c- p>{</c-></c->
    <c- k><c- k>public</c-></c-><c- o><c- o>:</c-></c->
        <c- k><c- k>using</c-></c-> <c- n><c- n>value_type</c-></c-> <c- o><c- o>=</c-></c-> <c- b><c- b>bool</c-></c-><c- p><c- p>;</c-></c->

        <c- c1><c- c1>// default value - false</c-></c->
        <c- k><c- k>static</c-></c-> <c- n><c- n>value_type</c-></c-> <c- nf><c- nf>default_value</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- p><c- p>};</c-></c->

    <c- k><c- k>class</c-></c-> <c- nc><c- nc>direction</c-></c->
    <c- p><c- p>{</c-></c->
    <c- k><c- k>public</c-></c-><c- o><c- o>:</c-></c->
        <c- k><c- k>using</c-></c-> <c- n><c- n>value_type</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>direction_preference</c-></c-><c- p><c- p>;</c-></c->

        <c- c1><c- c1>// default value - direction_preference::bidirectional</c-></c->
        <c- k><c- k>static</c-></c-> <c- n><c- n>value_type</c-></c-> <c- nf><c- nf>default_value</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- p><c- p>};</c-></c->

    <c- k><c- k>class</c-></c-> <c- nc><c- nc>soft_error_notify</c-></c->
    <c- p><c- p>{</c-></c->
    <c- k><c- k>public</c-></c-><c- o><c- o>:</c-></c->
        <c- k><c- k>using</c-></c-> <c- n><c- n>value_type</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>transport_preference</c-></c-><c- p><c- p>;</c-></c->

        <c- c1><c- c1>// default value - direction_preference::none</c-></c->
        <c- k><c- k>static</c-></c-> <c- n><c- n>value_type</c-></c-> <c- nf><c- nf>default_value</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- p><c- p>};</c-></c->

    <c- k><c- k>class</c-></c-> <c- nc><c- nc>active_read_before_send</c-></c->
    <c- p><c- p>{</c-></c->
    <c- k><c- k>public</c-></c-><c- o><c- o>:</c-></c->
        <c- k><c- k>using</c-></c-> <c- n><c- n>value_type</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>transport_preference</c-></c-><c- p><c- p>;</c-></c->

        <c- c1><c- c1>// default value - direction_preference::none</c-></c->
        <c- k><c- k>static</c-></c-> <c- n><c- n>value_type</c-></c-> <c- nf><c- nf>default_value</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- p><c- p>};</c-></c->
<c- p><c- p>}</c-></c->
</pre></code></pre>
   <h3 class="heading settled" data-level="4.14" id="properties-governing-transport-security"><span class="secno">4.14. </span><span class="content">Properties governing transport security</span><a class="self-link" href="#properties-governing-transport-security"></a></h3>
   <h4 class="heading settled" data-level="4.14.1" id="stdnetsecurity_props"><span class="secno">4.14.1. </span><span class="content"><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>net</c-><c- o>::</c-><c- n>security_props</c-></code></span><a class="self-link" href="#stdnetsecurity_props"></a></h4>
    Nested namespace containing strongly typed security properties. 
<pre class="highlight"><code><pre class="highlight"><c- k><c- k>namespace</c-></c-> <c- nn><c- nn>std</c-></c-><c- o><c- o>::</c-></c-><c- nn><c- nn>net</c-></c-><c- o><c- o>::</c-></c-><c- nn><c- nn>security_props</c-></c-> <c- p><c- p>{</c-></c->
    <c- c1><c- c1>// TODO Additional types defining security properties</c-></c->
    
    <c- k><c- k>class</c-></c-> <c- nc><c- nc>allowed_protocols</c-></c->
    <c- p><c- p>{</c-></c->
    <c- k><c- k>public</c-></c-><c- o><c- o>:</c-></c->
        <c- k><c- k>using</c-></c-> <c- n><c- n>value_type</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>vector</c-></c-><c- o><c- o>&lt;</c-></c-><c- n><c- n>string</c-></c-><c- o><c- o>></c-></c-><c- p><c- p>;</c-></c->

        <c- c1><c- c1>// default value - implementation defined</c-></c->
        <c- k><c- k>static</c-></c-> <c- n><c- n>typed_erased_type</c-></c-> <c- nf><c- nf>default_value</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- p><c- p>};</c-></c->

    <c- k><c- k>class</c-></c-> <c- nc><c- nc>server_certificate</c-></c->
    <c- p><c- p>{</c-></c->
    <c- k><c- k>public</c-></c-><c- o><c- o>:</c-></c->
        <c- k><c- k>using</c-></c-> <c- n><c- n>value_type</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>vector</c-></c-><c- o><c- o>&lt;</c-></c-><c- n><c- n>string</c-></c-><c- o><c- o>></c-></c-><c- p><c- p>;</c-></c->
        <c- c1><c- c1>// no default value</c-></c->
    <c- p><c- p>};</c-></c->

    <c- k><c- k>class</c-></c-> <c- nc><c- nc>client_certificate</c-></c->
    <c- p><c- p>{</c-></c->
    <c- k><c- k>public</c-></c-><c- o><c- o>:</c-></c->
        <c- k><c- k>using</c-></c-> <c- n><c- n>value_type</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>vector</c-></c-><c- o><c- o>&lt;</c-></c-><c- n><c- n>string</c-></c-><c- o><c- o>></c-></c-><c- p><c- p>;</c-></c->
        <c- c1><c- c1>// no default value</c-></c->
    <c- p><c- p>};</c-></c->

    <c- k><c- k>class</c-></c-> <c- nc><c- nc>pinned_server_certificate</c-></c->
    <c- p><c- p>{</c-></c->
    <c- k><c- k>public</c-></c-><c- o><c- o>:</c-></c->
        <c- k><c- k>using</c-></c-> <c- n><c- n>value_type</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>vector</c-></c-><c- o><c- o>&lt;</c-></c-><c- n><c- n>string</c-></c-><c- o><c- o>></c-></c-><c- p><c- p>;</c-></c->
        <c- c1><c- c1>// no default value</c-></c->
    <c- p><c- p>};</c-></c->

    <c- c1><c- c1>// Application Layer Protocol Negotiation [RFC7301]</c-></c->
    <c- k><c- k>class</c-></c-> <c- nc><c- nc>alpn_t</c-></c->
    <c- p><c- p>{</c-></c->
    <c- k><c- k>public</c-></c-><c- o><c- o>:</c-></c->
        <c- k><c- k>using</c-></c-> <c- n><c- n>value_type</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>vector</c-></c-><c- o><c- o>&lt;</c-></c-><c- n><c- n>string</c-></c-><c- o><c- o>></c-></c-><c- p><c- p>;</c-></c->
        <c- c1><c- c1>// no default value</c-></c->
    <c- p><c- p>};</c-></c->

    <c- k><c- k>class</c-></c-> <c- nc><c- nc>supported_group</c-></c-> 
    <c- p><c- p>{</c-></c->
    <c- k><c- k>public</c-></c-><c- o><c- o>:</c-></c->
        <c- k><c- k>using</c-></c-> <c- n><c- n>value_type</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>vector</c-></c-><c- o><c- o>&lt;</c-></c-><c- n><c- n>string</c-></c-><c- o><c- o>></c-></c-><c- p><c- p>;</c-></c->
        <c- c1><c- c1>// no default value</c-></c->
    <c- p><c- p>};</c-></c->

    <c- k><c- k>class</c-></c-> <c- nc><c- nc>ciphersuite</c-></c-> 
    <c- p><c- p>{</c-></c->
    <c- k><c- k>public</c-></c-><c- o><c- o>:</c-></c->
        <c- k><c- k>using</c-></c-> <c- n><c- n>value_type</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>vector</c-></c-><c- o><c- o>&lt;</c-></c-><c- n><c- n>string</c-></c-><c- o><c- o>></c-></c-><c- p><c- p>;</c-></c->
        <c- c1><c- c1>// no default value</c-></c->
    <c- p><c- p>};</c-></c->

    <c- k><c- k>class</c-></c-> <c- nc><c- nc>signature_algorithm</c-></c-> 
    <c- p><c- p>{</c-></c->
    <c- k><c- k>public</c-></c-><c- o><c- o>:</c-></c->
        <c- k><c- k>using</c-></c-> <c- n><c- n>value_type</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>vector</c-></c-><c- o><c- o>&lt;</c-></c-><c- n><c- n>string</c-></c-><c- o><c- o>></c-></c-><c- p><c- p>;</c-></c->
        <c- c1><c- c1>// no default value</c-></c->
    <c- p><c- p>};</c-></c->

    <c- k><c- k>class</c-></c-> <c- nc><c- nc>max_cached_sessions</c-></c->
    <c- p><c- p>{</c-></c->
    <c- k><c- k>public</c-></c-><c- o><c- o>:</c-></c->
        <c- k><c- k>using</c-></c-> <c- n><c- n>value_type</c-></c-> <c- o><c- o>=</c-></c-> <c- b><c- b>uint32_t</c-></c-><c- p><c- p>;</c-></c->

        <c- c1><c- c1>// default value - implementation defined</c-></c->
        <c- k><c- k>static</c-></c-> <c- n><c- n>value_type</c-></c-> <c- nf><c- nf>default_value</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- p><c- p>}</c-></c->

    <c- k><c- k>class</c-></c-> <c- nc><c- nc>max_cached_sessions</c-></c->
    <c- p><c- p>{</c-></c->
    <c- k><c- k>public</c-></c-><c- o><c- o>:</c-></c->
        <c- k><c- k>using</c-></c-> <c- n><c- n>value_type</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>chrono</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>steady_clock</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>duration</c-></c-><c- p><c- p>;</c-></c->

        <c- c1><c- c1>// default value - implementation defined</c-></c->
        <c- k><c- k>static</c-></c-> <c- n><c- n>value_type</c-></c-> <c- nf><c- nf>default_value</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- p><c- p>}</c-></c->

    <c- c1><c- c1>// TODO class pre_shared_key; /* value_type = key_material */</c-></c->
    <c- c1><c- c1>// TODO class trust;  /* sequence sender */</c-></c->
    <c- c1><c- c1>// TODO class challenge;  /* sequence sender */</c-></c->
<c- p><c- p>}</c-></c->
</pre></code></pre>
   <h3 class="heading settled" data-level="4.15" id="obtaining-connections"><span class="secno">4.15. </span><span class="content">Obtaining Connections</span><a class="self-link" href="#obtaining-connections"></a></h3>
   <h4 class="heading settled" data-level="4.15.1" id="netinitiate"><span class="secno">4.15.1. </span><span class="content"><code class="highlight"><c- n>net</c-><c- o>::</c-><c- n>initiate</c-></code></span><a class="self-link" href="#netinitiate"></a></h4>
    Obtain an "active open" (e.g. client) connection. 
<pre class="highlight"><code><pre class="highlight"><c- k><c- k>namespace</c-></c-> <c- nn><c- nn>std</c-></c-><c- o><c- o>::</c-></c-><c- nn><c- nn>net</c-></c-> <c- p><c- p>{</c-></c->
    <c- n><c- n>_exposition</c-></c-> <c- n><c- n>only_</c-></c->
    <c- k><c- k>namespace</c-></c-> <c- nn><c- nn>detail</c-></c-> <c- p><c- p>{</c-></c->
        <c- k><c- k>struct</c-></c-> <c- nc><c- nc>initiate_t</c-></c->
        <c- p><c- p>{</c-></c->
            <c- k><c- k>template</c-></c-><c- o><c- o>&lt;</c-></c-><c- k><c- k>typename</c-></c-> <c- nc><c- nc>Preconnection</c-></c-><c- p><c- p>,</c-></c-> <c- k><c- k>typename</c-></c-> <c- nc><c- nc>Framer</c-></c-><c- o><c- o>></c-></c->
            <c- n><c- n>connection</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>type</c-></c-> <c- k><c- k>operator</c-></c-><c- p><c- p>()(</c-></c-><c- k><c- k>const</c-></c-> <c- n><c- n>Preconnection</c-></c-><c- o><c- o>&amp;</c-></c-><c- p><c- p>,</c-></c-> <c- k><c- k>const</c-></c-> <c- n><c- n>Framer</c-></c-><c- o><c- o>&amp;</c-></c-><c- p><c- p>);</c-></c->

            <c- k><c- k>template</c-></c-><c- o><c- o>&lt;</c-></c-><c- k><c- k>typename</c-></c-> <c- nc><c- nc>Preconnection</c-></c-><c- o><c- o>></c-></c->
            <c- n><c- n>connection</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>type</c-></c-> <c- k><c- k>operator</c-></c-><c- p><c- p>()(</c-></c-><c- k><c- k>const</c-></c-> <c- n><c- n>Preconnection</c-></c-><c- o><c- o>&amp;</c-></c-><c- p><c- p>);</c-></c->
        <c- p><c- p>};</c-></c->
    <c- p><c- p>}</c-></c->
    <c- k><c- k>using</c-></c-> <c- n><c- n>detail</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>initiate_t</c-></c-><c- p><c- p>;</c-></c->
    <c- kr><c- kr>inline</c-></c-> <c- k><c- k>constexpr</c-></c-> <c- n><c- n>initiate_t</c-></c-> <c- n><c- n>initiate</c-></c-><c- p><c- p>{</c-></c-> <c- p><c- p>};</c-></c->
<c- p><c- p>}</c-></c->
</pre></code></pre>
   <h4 class="heading settled" data-level="4.15.2" id="netlisten"><span class="secno">4.15.2. </span><span class="content"><code class="highlight"><c- n>net</c-><c- o>::</c-><c- n>listen</c-></code></span><a class="self-link" href="#netlisten"></a></h4>
    Obtain a listen (e.g. server) connection 
<pre class="highlight"><code><pre class="highlight"><c- k><c- k>namespace</c-></c-> <c- nn><c- nn>std</c-></c-><c- o><c- o>::</c-></c-><c- nn><c- nn>net</c-></c-> <c- p><c- p>{</c-></c->
    <c- n><c- n>_exposition</c-></c-> <c- n><c- n>only_</c-></c->
    <c- k><c- k>namespace</c-></c-> <c- nn><c- nn>detail</c-></c-> <c- p><c- p>{</c-></c->
        <c- k><c- k>struct</c-></c-> <c- nc><c- nc>listen_t</c-></c->
        <c- p><c- p>{</c-></c->
            <c- k><c- k>template</c-></c-><c- o><c- o>&lt;</c-></c-><c- k><c- k>typename</c-></c-> <c- nc><c- nc>Preconnection</c-></c-><c- p><c- p>,</c-></c-> <c- k><c- k>typename</c-></c-> <c- nc><c- nc>Framer</c-></c-><c- o><c- o>></c-></c->
            <c- n><c- n>listen</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>type</c-></c-> <c- k><c- k>operator</c-></c-><c- p><c- p>()(</c-></c-><c- k><c- k>const</c-></c-> <c- n><c- n>Preconnection</c-></c-><c- o><c- o>&amp;</c-></c-><c- p><c- p>,</c-></c-> <c- k><c- k>const</c-></c-> <c- n><c- n>Framer</c-></c-><c- o><c- o>&amp;</c-></c-><c- p><c- p>);</c-></c->

            <c- k><c- k>template</c-></c-><c- o><c- o>&lt;</c-></c-><c- k><c- k>typename</c-></c-> <c- nc><c- nc>Preconnection</c-></c-><c- o><c- o>></c-></c->
            <c- n><c- n>listen</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>type</c-></c-> <c- k><c- k>operator</c-></c-><c- p><c- p>()(</c-></c-><c- k><c- k>const</c-></c-> <c- n><c- n>Preconnection</c-></c-><c- o><c- o>&amp;</c-></c-><c- p><c- p>);</c-></c->
        <c- p><c- p>};</c-></c->
    <c- p><c- p>}</c-></c->
    <c- k><c- k>using</c-></c-> <c- n><c- n>detail</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>listen_t</c-></c-><c- p><c- p>;</c-></c->
    <c- kr><c- kr>inline</c-></c-> <c- k><c- k>constexpr</c-></c-> <c- n><c- n>listen_t</c-></c-> <c- n><c- n>listen</c-></c-><c- p><c- p>{</c-></c-> <c- p><c- p>};</c-></c->
<c- p><c- p>}</c-></c->
</pre></code></pre>
   <h4 class="heading settled" data-level="4.15.3" id="netrendezvous"><span class="secno">4.15.3. </span><span class="content"><code class="highlight"><c- n>net</c-><c- o>::</c-><c- n>rendezvous</c-></code></span><a class="self-link" href="#netrendezvous"></a></h4>
    Obtain a peer-to-peer connection 
<pre class="highlight"><code><pre class="highlight"><c- k><c- k>namespace</c-></c-> <c- nn><c- nn>std</c-></c-><c- o><c- o>::</c-></c-><c- nn><c- nn>net</c-></c-> <c- p><c- p>{</c-></c->
    <c- n><c- n>_exposition</c-></c-> <c- n><c- n>only_</c-></c->
    <c- k><c- k>namespace</c-></c-> <c- nn><c- nn>detail</c-></c-> <c- p><c- p>{</c-></c->
        <c- k><c- k>struct</c-></c-> <c- nc><c- nc>rendezvous_t</c-></c->
        <c- p><c- p>{</c-></c->
            <c- k><c- k>template</c-></c-><c- o><c- o>&lt;</c-></c-><c- k><c- k>typename</c-></c-> <c- nc><c- nc>Preconnection</c-></c-><c- p><c- p>,</c-></c-> <c- k><c- k>typename</c-></c-> <c- nc><c- nc>Framer</c-></c-><c- o><c- o>></c-></c->
            <c- n><c- n>rendezvous</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>type</c-></c-> <c- k><c- k>operator</c-></c-><c- p><c- p>()(</c-></c-><c- k><c- k>const</c-></c-> <c- n><c- n>Preconnection</c-></c-><c- o><c- o>&amp;</c-></c-><c- p><c- p>,</c-></c-> <c- k><c- k>const</c-></c-> <c- n><c- n>Framer</c-></c-><c- o><c- o>&amp;</c-></c-><c- p><c- p>);</c-></c->

            <c- k><c- k>template</c-></c-><c- o><c- o>&lt;</c-></c-><c- k><c- k>typename</c-></c-> <c- nc><c- nc>Preconnection</c-></c-><c- o><c- o>></c-></c->
            <c- n><c- n>rendezvous</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>type</c-></c-> <c- k><c- k>operator</c-></c-><c- p><c- p>()(</c-></c-><c- k><c- k>const</c-></c-> <c- n><c- n>Preconnection</c-></c-><c- o><c- o>&amp;</c-></c-><c- p><c- p>);</c-></c->
        <c- p><c- p>};</c-></c->
    <c- p><c- p>}</c-></c->
    <c- k><c- k>using</c-></c-> <c- n><c- n>detail</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>rendezvous_t</c-></c-><c- p><c- p>;</c-></c->
    <c- kr><c- kr>inline</c-></c-> <c- k><c- k>constexpr</c-></c-> <c- n><c- n>rendezvous_t</c-></c-> <c- n><c- n>rendezvous</c-></c-><c- p><c- p>{</c-></c-> <c- p><c- p>};</c-></c->
<c- p><c- p>}</c-></c->
</pre></code></pre>
   <h2 class="heading settled" data-level="5" id="next-steps"><span class="secno">5. </span><span class="content">Next steps</span><a class="self-link" href="#next-steps"></a></h2>
   <p>A Future paper revision to formally propose the API changes extending/modifying <a data-link-type="biblio" href="#biblio-p2762" title="Sender/Receiver Interface For Networking">[p2762]</a>.</p>
  </main>
<script>
(function() {
  "use strict";
  var collapseSidebarText = '<span aria-hidden="true">←</span> '
                          + '<span>Collapse Sidebar</span>';
  var expandSidebarText   = '<span aria-hidden="true">→</span> '
                          + '<span>Pop Out Sidebar</span>';
  var tocJumpText         = '<span aria-hidden="true">↑</span> '
                          + '<span>Jump to Table of Contents</span>';

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

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

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

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

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

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


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

    tocNav.appendChild(toggle);
  }

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

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

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

})();
</script>
  <h2 class="no-num no-ref heading settled" id="references"><span class="content">References</span><a class="self-link" href="#references"></a></h2>
  <h3 class="no-num no-ref heading settled" id="informative"><span class="content">Informative References</span><a class="self-link" href="#informative"></a></h3>
  <dl>
   <dt id="biblio-anf">[ANF]
   <dd><a href="https://developer.apple.com/documentation/network"><cite>Apple Network.framework</cite></a>. URL: <a href="https://developer.apple.com/documentation/network">https://developer.apple.com/documentation/network</a>
   <dt id="biblio-asio">[ASIO]
   <dd>Chris Kohlhoff. <a href="https://think-async.com/Asio"><cite>Asio C++ Library</cite></a>. URL: <a href="https://think-async.com/Asio">https://think-async.com/Asio</a>
   <dt id="biblio-c-ares">[C-ARES]
   <dd><a href="https://c-ares.org/"><cite>A modern DNS resolver written in C</cite></a>. URL: <a href="https://c-ares.org/">https://c-ares.org/</a>
   <dt id="biblio-netts">[NETTS]
   <dd><a href="https://wg21.link/n4734"><cite>Working Draft, C++ Extensions for Networking</cite></a>. 2018-04-04. URL: <a href="https://wg21.link/n4734">https://wg21.link/n4734</a>
   <dt id="biblio-p1861">[P1861]
   <dd>Alex Christensen; JF Bastien; Scott Herscher. <a href="https://wg21.link/p1861"><cite>Secure Networking in C++</cite></a>. URL: <a href="https://wg21.link/p1861">https://wg21.link/p1861</a>
   <dt id="biblio-p2300">[P2300]
   <dd>various. <a href="https://wg21.link/p2300"><cite>std::execution</cite></a>. URL: <a href="https://wg21.link/p2300">https://wg21.link/p2300</a>
   <dt id="biblio-p2762">[P2762]
   <dd>Dietmar Kühl (Bloomberg). <a href="https://wg21.link/p2762"><cite>Sender/Receiver Interface For Networking</cite></a>. URL: <a href="https://wg21.link/p2762">https://wg21.link/p2762</a>
   <dt id="biblio-p3185">[P3185]
   <dd>Thomas Rodgers. <a href="https://wg21.link/p3185"><cite>A proposed direction for C++ Standard Networking based on IETF TAPS</cite></a>. URL: <a href="https://wg21.link/p3185">https://wg21.link/p3185</a>
   <dt id="biblio-p3325">[P3325]
   <dd>Eric Niebler. <a href="https://wg21.link/p3325"><cite>A Utility for Creating Execution Environments</cite></a>. URL: <a href="https://wg21.link/p3325">https://wg21.link/p3325</a>
   <dt id="biblio-taps_arch">[TAPS_Arch]
   <dd><a href="https://datatracker.ietf.org/doc/draft-ietf-taps-arch/"><cite>Architecture and Requirements for Transport Services</cite></a>. 2023-11-09. URL: <a href="https://datatracker.ietf.org/doc/draft-ietf-taps-arch/">https://datatracker.ietf.org/doc/draft-ietf-taps-arch/</a>
   <dt id="biblio-taps_interface">[TAPS_interface]
   <dd><a href="https://datatracker.ietf.org/doc/draft-ietf-taps-interface/"><cite>An Abstract Application Layer Interface to Transport Services</cite></a>. 2023-11-09. URL: <a href="https://datatracker.ietf.org/doc/draft-ietf-taps-interface/">https://datatracker.ietf.org/doc/draft-ietf-taps-interface/</a>
  </dl>