<!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>P1144R12: std::is_trivially_relocatable</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 6270e4735, updated Tue Aug 6 12:12:30 2024 -0700" name="generator">
  <link href="https://isocpp.org/favicon.ico" rel="icon">
  <meta content="dark light" name="color-scheme">
<style>
p    {-moz-hyphens: none; -ms-hyphens: none; -webkit-hyphens: none; hyphens: none;}
ins  {background-color: #CCFFCC; text-decoration: underline;}
del  {background-color: #FFCACA; text-decoration: line-through;}
</style>
<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">P1144R12<br>std::is_trivially_relocatable</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-15">2024-10-15</time></span></h2>
   <div data-fill-with="spec-metadata">
    <dl>
     <dt class="editor">Author:
     <dd class="editor p-author h-card vcard"><a class="p-name fn u-email email" href="mailto:arthur.j.odwyer@gmail.com">Arthur O'Dwyer</a>
     <dt>Audience:
     <dd>SG17
     <dt>Project:
     <dd>ISO/IEC 14882 Programming Languages — C++, ISO/IEC JTC1/SC22/WG21
    </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>P1144 trivial relocation is used by Abseil, AMC, BSL, Folly, HPX, Parlay, Pocketpy, Qt, Subspace, and Thrust.
Let’s make it part of the C++ standard.</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="#changelog"><span class="secno">1</span> <span class="content">Changelog</span></a>
    <li><a href="#intro"><span class="secno">2</span> <span class="content">What’s going on here?</span></a>
    <li>
     <a href="#wording"><span class="secno">3</span> <span class="content">Proposed wording</span></a>
     <ol class="toc">
      <li><a href="#wording-cpp.predefined"><span class="secno">3.1</span> <span class="content">[cpp.predefined]</span></a>
      <li><a href="#wording-version.syn"><span class="secno">3.2</span> <span class="content">[version.syn]</span></a>
      <li><a href="#wording-defns.relocation"><span class="secno">3.3</span> <span class="content">[defns.relocation]</span></a>
      <li><a href="#wording-basic.types.general"><span class="secno">3.4</span> <span class="content">[basic.types.general]</span></a>
      <li><a href="#wording-class.prop"><span class="secno">3.5</span> <span class="content">[class.prop]</span></a>
      <li><a href="#wording-dcl.attr.trivreloc"><span class="secno">3.6</span> <span class="content">[dcl.attr.trivreloc]</span></a>
      <li><a href="#wording-cpp.cond"><span class="secno">3.7</span> <span class="content">[cpp.cond]</span></a>
      <li><a href="#wording-concepts.syn"><span class="secno">3.8</span> <span class="content">[concepts.syn]</span></a>
      <li><a href="#wording-concept.relocatable"><span class="secno">3.9</span> <span class="content">[concept.relocatable]</span></a>
      <li><a href="#wording-memory.syn"><span class="secno">3.10</span> <span class="content">[memory.syn]</span></a>
      <li><a href="#wording-meta.type.synop"><span class="secno">3.11</span> <span class="content">[meta.type.synop]</span></a>
      <li><a href="#wording-meta.unary.prop"><span class="secno">3.12</span> <span class="content">[meta.unary.prop]</span></a>
      <li><a href="#wording-algorithms.requirements"><span class="secno">3.13</span> <span class="content">[algorithms.requirements]</span></a>
      <li><a href="#wording-uninitialized.relocate"><span class="secno">3.14</span> <span class="content">[uninitialized.relocate]</span></a>
      <li><a href="#wording-specialized.relocate"><span class="secno">3.15</span> <span class="content">[specialized.relocate]</span></a>
     </ol>
    <li><a href="#acknowledgements"><span class="secno">4</span> <span class="content">Acknowledgements</span></a>
    <li>
     <a href="#polls"><span class="secno"></span> <span class="content">Appendix A: Straw polls</span></a>
     <ol class="toc">
      <li><a href="#taken-polls-2024-06-28"><span class="secno"></span> <span class="content">Poll taken in EWG at St Louis on 2024-06-28</span></a>
      <li><a href="#taken-polls-2023-02-10"><span class="secno"></span> <span class="content">Polls taken in EWGI at Issaquah on 2023-02-10</span></a>
      <li><a href="#taken-polls-2020-02-13"><span class="secno"></span> <span class="content">Polls taken in EWGI at Prague on 2020-02-13</span></a>
     </ol>
    <li>
     <a href="#references"><span class="secno"></span> <span class="content">References</span></a>
     <ol class="toc">
      <li><a href="#informative"><span class="secno"></span> <span class="content">Informative References</span></a>
     </ol>
   </ol>
  </nav>
  <main>
   <h2 class="heading settled" data-level="1" id="changelog"><span class="secno">1. </span><span class="content">Changelog</span><a class="self-link" href="#changelog"></a></h2>
   <ul>
    <li data-md>
     <p>R12 (pre-Wrocław 2024):</p>
     <ul>
      <li data-md>
       <p>Complete rewrite of the prose sections.</p>
      <li data-md>
       <p>Added missing forward-declarations to [concepts.syn], [meta.type.synop], and [memory.syn].</p>
      <li data-md>
       <p>Removed <code class="highlight"><c- p>[[</c-><c- n>nodiscard</c-><c- p>]]</c-></code> from <code class="highlight"><c- n>relocate</c-><c- p>(</c-><c- n>T</c-><c- o>*</c-><c- p>)</c-></code>,
thanks to <a href="https://github.com/cplusplus/papers/issues/1744">P2422</a>.</p>
      <li data-md>
       <p>Updated [concept.relocatable]: <code class="highlight"><c- n>u2</c-></code> mustn’t be a potentially overlapping subobject.</p>
      <li data-md>
       <p>Updated [uninitialized.relocate] and [specialized.relocate]: Instead of "side effects <i>might</i> not happen,"
we now say "<i>do</i> not happen": Memmove optimization is now mandatory. (This addresses
one of EWG’s concerns versus <a data-link-type="biblio" href="#biblio-p2786" title="Trivial Relocatability For C++26">[P2786]</a>, that P1144 leaves too much up to quality-of-implementation.)
This incidentally guarantees that <code class="highlight"><c- n>relocate</c-></code> of a trivially relocatable type will never throw.</p>
     </ul>
   </ul>
   <h2 class="heading settled" data-level="2" id="intro"><span class="secno">2. </span><span class="content">What’s going on here?</span><a class="self-link" href="#intro"></a></h2>
   <p><b>Isn’t EWG already considering a "trivial relocation" proposal, <a data-link-type="biblio" href="#biblio-p2786" title="Trivial Relocatability For C++26">[P2786]</a>?</b></p>
   <p>Yes. P2786 was forwarded (1–8–3–3–1) from EWGI to EWG at Issaquah in February 2023.</p>
   <p>P1144, which dates back to 2018, had <i>already</i> been voted out of EWGI once,
at Prague in February 2020 (1–3–4–1–0). It remains unclear why that vote was ignored.
At Issaquah, it was seen and voted <i>again</i> (0–7–4–3–1).</p>
   <p>At Tokyo in February 2024, P2786 was voted from EWG into CWG (7–9–6–0–2).
But then, at St Louis in June 2024, EWG voted strongly (21–15–3–6–5) that P2786 wasn’t ready for CWG after all,
and brought it back for further discussion. I <a href="https://wiki.edg.com/bin/view/Wg21stlouis2024/NotesEWGTrivialRelocatability">asked</a> during that meeting whether the chair of EWG was willing to schedule P1144 for discussion,
or even to take a poll of EWG on <i>whether</i> to discuss it. He said no.</p>
   <p><b>That seems... weird. Is P2786 simply better?</b></p>
   <p>In my opinion, no it is not. It’s more complicated and offers less to the programmer.
It has had no uptake in the programming community. In fact, the main reason it was so
overwhelmingly clawed back in St Louis is because of two papers presented there by
third-party library maintainers:</p>
   <ul>
    <li data-md>
     <p><a data-link-type="biblio" href="#biblio-p3233" title="Issues with P2786 (&apos;Trivial Relocatability For C++26&apos;)">[P3233]</a> "Issues with P2786" (Giuseppe D’Angelo)</p>
    <li data-md>
     <p><a data-link-type="biblio" href="#biblio-p3236" title="Please reject P2786 and adopt P1144">[P3236]</a> "Please reject P2786 and adopt P1144" (Stéphane Janel, Hans Goudey, Jacques Lucke, Alan de Freitas,
Krystian Stasiowski, Daniel Liam Anderson, Giuseppe Ottaviano, Giuseppe D’Angelo, Thiago Maciera,
Hartmut Kaiser, Isidoros Tsaousis, Shreyas Atre)</p>
   </ul>
   <p><b>Does P1144 have uptake in the community?</b></p>
   <p>Yes. In fact, since P1144R0 was modeled directly on Folly and BSL, you might say that
P1144 is the <i>committee’s</i> uptake of a <i>community</i> idea!</p>
   <p>Since 2018, most of the libraries that inspired P1144
have entrenched even further with its consistent terminology and semantics.
P1144R9 introduced a pair of feature-test macros, and some libraries have
adopted those macros, so that they <i>already today</i> get better performance on Arthur’s
reference implementation and will be "ready on day one" when P1144 is eventually adopted
by the committee. The flagship examples are:</p>
   <ul>
    <li data-md>
     <p>Facebook Folly defines its <code class="highlight"><c- n>folly</c-><c- o>::</c-><c- n>IsRelocatable</c-></code> trait in terms of P1144’s <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>is_trivially_relocatable</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code> if <code class="highlight"><c- n>__cpp_lib_trivially_relocatable</c-></code> is defined.
Otherwise, Folly falls back on <code class="highlight"><c- n>is_trivially_copyable</c-></code>.</p>
    <li data-md>
     <p>Stellar HPX defines <code class="highlight"><c- n>hpx</c-><c- o>::</c-><c- n>is_trivially_relocatable</c-></code> in terms of P1144’s <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>is_trivially_relocatable</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code> if <code class="highlight"><c- n>HPX_HAVE_P1144_RELOCATE_AT</c-></code> is defined
at build time.</p>
    <li data-md>
     <p>Google Abseil defines <code class="highlight"><c- n>absl</c-><c- o>::</c-><c- n>is_trivially_relocatable</c-></code> with P1144 semantics.
Abseil will directly use Clang’s <code class="highlight"><c- n>__is_trivially_relocatable</c-><c- p>(</c-><c- n>T</c-><c- p>)</c-></code> builtin,
but not when compiled with Clang trunk — only if <code class="highlight"><c- n>__cpp_impl_trivially_relocatable</c-></code> is defined.
(<a href="https://godbolt.org/z/znMPE6hqv">Godbolt.</a>)</p>
    <li data-md>
     <p>Carnegie Mellon’s ParlayLib project defines <a href="https://github.com/cmuparlay/parlaylib/blob/36459f4/include/parlay/type_traits.h#L250-L304"><code class="highlight"><c- n>parlay</c-><c- o>::</c-><c- n>is_trivially_relocatable</c-></code></a> in terms of P1144’s <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>is_trivially_relocatable</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code> if <code class="highlight"><c- n>__cpp_lib_trivially_relocatable</c-></code> is defined.
Otherwise, Parlay falls back on the Clang builtin.</p>
   </ul>
   <p><b>Wait. Clang has a builtin trait for this?</b></p>
   <p>Yes. That builtin was added to trunk by Devin Jeanpierre <a href="https://github.com/llvm/llvm-project/commit/19aa2db023c0128913da223d4fb02c474541ee22">in February 2022</a>,
about a year before P2786 was released to the public. The commit message indicated that
"rather than trying to pick a winning proposal for trivial relocation operations"
Clang would implement its own semantics, which turned out to be very similar to the semantics
chosen by P2786 the next year.</p>
   <p>Sadly, Clang’s chosen semantics have proven useless to many existing libraries. Folly, Abseil,
HPX, and Subspace all considered using Clang’s builtin and decided against it, due to its
current semantics. Giuseppe D’Angelo, on the KDAB company blog, <a href="https://www.kdab.com/qt-and-trivial-relocation-part-5/">observes</a>:</p>
   <blockquote>
    <p>P2786’s design is limiting and not user-friendly, to the point that there have been
serious concerns that existing libraries may not make use of it at all. In particular,
P2786’s relocation semantics do not match Qt’s. With my Qt hat on, <i>it soon became
clear that we could not have used P2786 in Qt to replace our own implementation of trivial relocation.</i></p>
   </blockquote>
   <p><a href="https://github.com/llvm/llvm-project/pull/84621">There was an effort in March 2024</a> to
give Clang trunk’s <code class="highlight"><c- n>__is_trivially_relocatable</c-><c- p>(</c-><c- n>T</c-><c- p>)</c-></code> P1144 semantics. The pull request was
supported with comments by maintainers of Abseil, Qt, AMC, Subspace, HPX, and
several smaller libraries as well.
As of this writing (October 2024), the pull request has not been accepted.
These libraries continue to rely on P1144’s feature-test macros (or just use <code class="highlight"><c- n>is_trivially_copyable</c-></code>),
because Clang trunk doesn’t support their use-cases.</p>
   <p><b>And everyone just uses <code class="highlight"><c- n>memcpy</c-></code> instead of <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>uninitialized_relocate</c-></code>, right?</b></p>
   <p>Right. Many of them have implemented a P1144-alike API in <i>terms</i> of <code class="highlight"><c- n>memcpy</c-></code>, though:</p>
   <ul>
    <li data-md>
     <p>Amadeus AMC’s <a href="https://github.com/AmadeusITGroup/amc/blob/c38e46e/include/amc/memory.hpp#L500-L522"><code class="highlight"><c- n>amc</c-><c- o>::</c-><c- n>uninitialized_relocate</c-></code></a>, <code class="highlight"><c- n>uninitialized_relocate_n</c-></code>, and <code class="highlight"><c- n>relocate_at</c-></code></p>
    <li data-md>
     <p>HPX’s <a href="https://github.com/STEllAR-GROUP/hpx/blob/659e0ea/libs/core/type_support/include/hpx/type_support/uninitialized_relocation_primitives.hpp"><code class="highlight"><c- n>hpx</c-><c- o>::</c-><c- n>experimental</c-><c- o>::</c-><c- n>uninitialized_relocate</c-></code></a>, <code class="highlight"><c- n>uninitialized_relocate_n</c-></code>, <code class="highlight"><c- n>uninitialized_relocate_backward</c-></code>, and <a href="https://github.com/STEllAR-GROUP/hpx/blob/bd32982/libs/core/type_support/include/hpx/type_support/relocate_at.hpp#L124-L133"><code class="highlight"><c- n>relocate_at</c-></code></a></p>
    <li data-md>
     <p>Parlay’s <a href="https://github.com/cmuparlay/parlaylib/blob/36459f4/include/parlay/relocation.h"><code class="highlight"><c- n>uninitialized_relocate</c-></code></a> and <code class="highlight"><c- n>uninitialized_relocate_n</c-></code></p>
    <li data-md>
     <p>Qt’s <a href="https://github.com/qt/qtbase/blob/cb40a1f/src/corelib/tools/qcontainertools_impl.h#L71-L87"><code class="highlight"><c- n>q_uninitialized_relocate_n</c-></code></a></p>
   </ul>
   <p><b>Could these two halves of the feature be severed?</b></p>
   <p>You mean, ship just the <code class="highlight"><c- n>is_trivially_relocatable</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code> trait in C++26, and then worry about the
algorithms like <code class="highlight"><c- n>uninitialized_relocate</c-></code> (and the <code class="highlight"><c- n>trivially_relocatable</c-></code> attribute itself) for C++29?
Sure, and I’d be fine with that — as long as the standard trait were defined in the P1144 way,
so that all these libraries can start using it.</p>
   <p><b>Hasn’t P2786 adjusted its trait in that direction recently?</b></p>
   <p>Yes. Following EWG’s clawback in St Louis 2024, P2786R7 decided that its <code class="highlight"><c- n>is_replaceable</c-></code> trait should
consider the move-assignment operator as well as the move-constructor. That’s a positive step. But, as
of this writing, P2786 still considers unannotated types "eligible for trivial relocation" when they have
a non-defaulted copy-constructor — whereas P1144 conservatively will not <i>assume</i> that any type is
trivially relocatable unless it is well-understood by the compiler (i.e., Rule of Zero).
Also, P2786 considers unannotated types "eligible for trivial relocation" even if they are polymorphic;
see <a data-link-type="biblio" href="#biblio-polymorphic" title="Polymorphic types aren&apos;t trivially relocatable">[Polymorphic]</a> for how that can cause segfaults in supposedly "well-defined" code.</p>
   <p>Beyond the criteria for relocatability, P2786 has other unacceptable downsides. It bifurcates
the P1144 trait into two traits — <code class="highlight"><c- n>is_trivially_relocatable</c-></code> and <code class="highlight"><c- n>is_replaceable</c-></code>, where in fact the <i>latter</i> corresponds to what everyone names <code class="highlight"><c- n>is_trivially_relocatable</c-></code> today. That will lead to confusion.
P2786 invents new functions like <code class="highlight"><c- n>swap_value_representations</c-></code> and <code class="highlight"><c- n>trivially_relocate</c-></code>, again not reflecting
existing practice. <code class="highlight"><c- n>swap_value_representations</c-></code> is defined to magically omit copying vptrs (even of
subobjects), which means different codegen for different "replaceable" types of the same size and alignment.
Contrariwise, P1144 allows us to share the same code for all trivially relocatable types of the same size, as seen
in <a href="https://godbolt.org/z/fxd7MY754">this Godbolt</a>. That’s basically the point of calling the code "trivial"!</p>
   <p>It is unambiguously a good thing every time P2786 takes a step toward P1144. But many of those steps remain to be taken.</p>
   <p><b>And EWG still refuses to directly discuss P1144 itself?</b></p>
   <p>So far, yes. I remain hopeful that one day that may change.</p>
   <p><b>Where can I learn more about trivial relocation?</b></p>
   <p>Besides <a href="https://quuxplusone.github.io/blog/tags/#relocatability">Arthur’s blog</a>,
you might also want to look at:</p>
   <ul>
    <li data-md>
     <p><a href="https://orodu.net/2023/01/15/trivially-relocatable.html">"Trivially relocatable types in C++/Subspace"</a>, by Dana Jansens</p>
    <li data-md>
     <p><a href="https://www.kdab.com/qt-and-trivial-relocation-part-5/">"Qt and trivial relocation"</a>, by Giuseppe D’Angelo, on the KDAB blog</p>
    <li data-md>
     <p><a href="https://isidorostsa.github.io/gsoc2023/">"Relocation semantics in the HPX library"</a>, by Isidoros Tsaousis</p>
    <li data-md>
     <p><a href="https://github.com/facebook/folly/blob/main/folly/docs/FBVector.md#object-relocation">"Object relocation"</a> in the Folly repository</p>
   </ul>
   <h2 class="heading settled" data-level="3" id="wording"><span class="secno">3. </span><span class="content">Proposed wording</span><a class="self-link" href="#wording"></a></h2>
   <p>The wording in this section is relative to the current working draft.</p>
   <h3 class="heading settled" data-level="3.1" id="wording-cpp.predefined"><span class="secno">3.1. </span><span class="content">[cpp.predefined]</span><a class="self-link" href="#wording-cpp.predefined"></a></h3>
   <p>Add a feature-test macro to the table in <a href="https://eel.is/c++draft/cpp.predefined#tab:cpp.predefined.ft">[cpp.predefined]</a>:</p>
   <p><small></small></p>
   <blockquote>
    <p></p>
    <small> <pre class="highlight"><c- n>__cpp_impl_three_way_comparison</c->   <c- mf>201907L</c->
<ins><c- n>__cpp_impl_trivially_relocatable</c->  <c- n>YYYYMML</c-></ins>
<c- n>__cpp_implicit_move</c->               <c- mf>202207L</c->
</pre></small>
   </blockquote>
   <h3 class="heading settled" data-level="3.2" id="wording-version.syn"><span class="secno">3.2. </span><span class="content">[version.syn]</span><a class="self-link" href="#wording-version.syn"></a></h3>
   <p>Add a feature-test macro to <a href="https://eel.is/c++draft/version.syn">[version.syn]/2</a>:</p>
   <p><small></small></p>
   <blockquote>
    <p></p>
    <small> <pre class="highlight"><c- cp>#define __cpp_lib_transparent_operators   201510L </c-><c- c1>// freestanding, also in &lt;memory>, &lt;functional></c->
<ins><c- cp>#define __cpp_lib_trivially_relocatable   YYYYMML </c-><c- c1>// freestanding, also in &lt;memory>, &lt;type_traits></c-></ins>
<c- cp>#define __cpp_lib_tuple_element_t         201402L </c-><c- c1>// freestanding, also in &lt;tuple></c->
</pre></small>
   </blockquote>
   <h3 class="heading settled" data-level="3.3" id="wording-defns.relocation"><span class="secno">3.3. </span><span class="content">[defns.relocation]</span><a class="self-link" href="#wording-defns.relocation"></a></h3>
   <p>Add a new section in <a href="http://eel.is/c++draft/intro.defs">[intro.defs]</a>:</p>
   <p><small></small></p>
   <blockquote>
    <p></p>
    <small> <ins><b>relocation operation [defns.relocation]</b></ins> <p>  <ins>the homogeneous binary operation performed by <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>relocate_at</c-></code>,
consisting of a move construction immediately followed by a destruction of the source object</ins> </p></small>
   </blockquote>
   <h3 class="heading settled" data-level="3.4" id="wording-basic.types.general"><span class="secno">3.4. </span><span class="content">[basic.types.general]</span><a class="self-link" href="#wording-basic.types.general"></a></h3>
   <p>Add a new section in <a href="http://eel.is/c++draft/basic.types.general">[basic.types.general]</a>:</p>
   <p><small></small></p>
   <blockquote><small> 9․ Arithmetic types ([basic.fundamental]), enumeration types, pointer types, pointer-to-member types ([basic.compound]), <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>nullptr_t</c-></code>, and <i>cv</i>-qualified versions of these types are collectively called <i>scalar types</i>.
Scalar types, trivially copyable class types ([class.prop]), arrays of such types, and <i>cv</i>-qualified versions
of these types are collectively called <i>trivially copyable types</i>.
Scalar types, trivial class types ([class.prop]), arrays of such types, and <i>cv</i>-qualified versions of these types
are collectively called <i>trivial types</i>. Scalar types, standard-layout class types ([class.prop]), arrays of such types,
and <i>cv</i>-qualified versions of these types are collectively called <i>standard-layout types</i>.
Scalar types, implicit-lifetime class types ([class.prop]), array types, and <i>cv</i>-qualified versions of these types
are collectively called <i>implicit-lifetime types</i>.<p></p> <p><ins>x․ Trivially copyable types, trivially relocatable class types (<a href="#wording-class.prop">[class.prop]</a>), arrays of such types,
and <i>cv</i>-qualified versions of these types are collectively called <i>trivially relocatable types</i>. </ins></p><p><ins>[<em>Note:</em> For a trivially relocatable type, the relocation operation (<a href="#wording-defns.relocation">[defns.relocation]</a>) as performed by,
for example, <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>swap_ranges</c-></code> or <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>vector</c-><c- o>::</c-><c- n>reserve</c-></code>, is tantamount
to a simple copy of the underlying bytes. <em>—end note</em>]</ins> </p><p><ins>[<em>Note:</em> It is likely that many standard library types are trivially relocatable types. <em>—end note</em>]</ins> </p><p>10․ A type is a <i>literal type</i> if it is: [...]</p> </small></blockquote>
   <h3 class="heading settled" data-level="3.5" id="wording-class.prop"><span class="secno">3.5. </span><span class="content">[class.prop]</span><a class="self-link" href="#wording-class.prop"></a></h3>
   <p class="note" role="note"><b>DRAFTING NOTE:</b> For the "if supported" wording, compare <a href="https://eel.is/c++draft/dcl.attr.nouniqueaddr#2.sentence-2">[dcl.attr.nouniqueaddr]/2</a> and <a href="https://eel.is/c++draft/cpp.cond#5.sentence-1">[cpp.cond]/5</a>. </p>
   <p class="note" role="note"><b>DRAFTING NOTE:</b> The wording proposed here deliberately echoes the existing "trivially copyable" wording.
"Copyable" and "relocatable" are siblings; every trivially copyable type is trivially relocatable by definition.
However, CWG already knows the wording for "trivially copyable" does not match library-writers' expectations;
see <a data-link-type="biblio" href="#biblio-p3279" title="CWG2463: What &apos;trivially fooable&apos; should mean">[P3279]</a> for examples and a possible direction. If that direction is taken, then we’d certainly
update the proposed wording of "trivially relocatable" to follow the new wording of "trivially copyable." </p>
   <p>Modify <a href="http://eel.is/c++draft/class.prop">[class.prop]</a> as follows:</p>
   <p><small></small></p>
   <blockquote>
    <p></p>
    <small> <p>1․ A <i>trivially copyable class</i> is a class: </p><ul><li data-md><p>that has at least one eligible copy constructor, move constructor, copy assignment operator, or move assignment operator ([special], [class.copy.ctor], [class.copy.assign]),</p> </li><li data-md><p>where each eligible copy constructor, move constructor, copy assignment operator, and move assignment operator is trivial, and</p> </li><li data-md><p>that has a trivial, non-deleted destructor ([class.dtor]).</p> </li></ul> <p>2․ A <i>trivial class</i> is a class that is trivially copyable and has one or more eligible default constructors ([class.default.ctor]), all of which are trivial.
[<em>Note:</em> In particular, a trivially copyable or trivial class does not have virtual functions or virtual base classes. <em>— end note</em>] </p><p><ins>x․ A <i>trivially relocatable class</i> is a class: </ins></p><ul><li data-md><ins>where no eligible copy constructor, move constructor, copy assignment operator, move assignment operator, or destructor is user-provided,</ins> </li><li data-md><ins>which has no virtual member functions or virtual base classes,</ins> </li><li data-md><ins>all of whose non-static data members are either of reference type or of trivially relocatable type (<a href="#wording-basic.types.general">[basic.types.general]</a>), and</ins> </li><li data-md><ins>all of whose base classes are of trivially relocatable type;</ins> </li></ul> <ins>or a class that is declared with a <code class="highlight"><c- n>trivially_relocatable</c-></code> attribute with value <code class="highlight">true</code> (<a href="#wording-dcl.attr.trivreloc">[dcl.attr.trivreloc]</a>)
if that attribute is supported by the implementation (<a href="#wording-cpp.cond">[cpp.cond]</a>).</ins> <p>3․ A class <code class="highlight"><c- n>S</c-></code> is a <i>standard-layout class</i> if it: [...] </p></small>
   </blockquote>
   <h3 class="heading settled" data-level="3.6" id="wording-dcl.attr.trivreloc"><span class="secno">3.6. </span><span class="content">[dcl.attr.trivreloc]</span><a class="self-link" href="#wording-dcl.attr.trivreloc"></a></h3>
   <p class="note" role="note"><b>DRAFTING NOTE:</b> For the "Recommended practice" wording, compare <a href="https://eel.is/c++draft/dcl.attr.nouniqueaddr#2.sentence-2">[dcl.attr.nouniqueaddr]/2</a>. </p>
   <p>Add a new section after <a href="http://eel.is/c++draft/dcl.attr.nouniqueaddr">[dcl.attr.nouniqueaddr]</a>:</p>
   <p><small></small></p>
   <blockquote>
    <p></p>
    <small> <ins>1․ The <em>attribute-token</em> <code class="highlight"><c- n>trivially_relocatable</c-></code> specifies that a class type’s relocation operation has no
visible side-effects other than a copy of the underlying bytes, as if by the library function <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>memcpy</c-></code>.
It may be applied to the definition of a class. It shall appear at most once in each <em>attribute-list</em>.
An <em>attribute-argument-clause</em> may be present and, if present, shall have the form</ins> <pre class="highlight"><ins><c- p>(</c-> <i><c- n>constant</c-><c- o>-</c-><c- n>expression</c-></i> <c- p>)</c-></ins>
</pre><ins>The <em>constant-expression</em> shall be an integral constant expression of type <code class="highlight"><c- b>bool</c-></code>.
If no <em>attribute-argument-clause</em> is present, it has the same effect as an <em>attribute-argument-clause</em> of <code class="highlight"><c- p>(</c->true<c- p>)</c-></code>.</ins> <p><ins>2․ If any definition of a class type has a <code class="highlight"><c- n>trivially_relocatable</c-></code> attribute with value <em>V</em>, then each
definition of the same class type shall have a <code class="highlight"><c- n>trivially_relocatable</c-></code> attribute with value <em>V</em>.
No diagnostic is required if definitions in different translation units have
mismatched <code class="highlight"><c- n>trivially_relocatable</c-></code> attributes.</ins> </p><p><ins>3․ If a class type is declared with the <code class="highlight"><c- n>trivially_relocatable</c-></code> attribute, and the program relies on
observable side-effects of its relocation other than a copy of the underlying bytes, the behavior is undefined.</ins> </p><p><ins>4․ <em>Recommended practice:</em> The value of a <i>has-attribute-expression</i> for
the <code class="highlight"><c- n>trivially_relocatable</c-></code> attribute should be <code class="highlight"><c- mi>0</c-></code> for a given implementation unless this attribute
can cause a class type to be trivially relocatable (<a href="#wording-class.prop">[class.prop]</a>).</ins> </p></small>
   </blockquote>
   <h3 class="heading settled" data-level="3.7" id="wording-cpp.cond"><span class="secno">3.7. </span><span class="content">[cpp.cond]</span><a class="self-link" href="#wording-cpp.cond"></a></h3>
   <p>Add a new entry to the table of supported attributes in <a href="https://eel.is/c++draft/cpp.cond">[cpp.cond]</a>:</p>
   <p><small></small></p>
   <blockquote>
    <p></p>
    <small> <pre class="highlight"><c- n>noreturn</c->              <c- mf>200809L</c->
<ins><c- n>trivially_relocatable</c-> <c- n>YYYYMML</c-></ins>
<c- n>unlikely</c->              <c- mf>201803L</c->
</pre></small>
   </blockquote>
   <h3 class="heading settled" data-level="3.8" id="wording-concepts.syn"><span class="secno">3.8. </span><span class="content">[concepts.syn]</span><a class="self-link" href="#wording-concepts.syn"></a></h3>
   <p>Modify <a href="http://eel.is/c++draft/concepts.syn">[concepts.syn]</a> as follows:</p>
   <p><small></small></p>
   <blockquote>
    <p></p>
    <small> <pre class="highlight"><i><c- c1>// [concept.copyconstructible], concept copy_constructible</c-></i>
<c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>T</c-><c- o>></c->
  <c- k>concept</c-> <c- nc>copy_constructible</c-> <c- o>=</c-> <i><c- n>see</c-> <c- n>below</c-></i><c- p>;</c->

<i><c- c1>// </c-><a href="#wording-concept.relocatable"><c- c1>[concept.relocatable]</c-></a><c- c1>, concept relocatable</c-></i>
<c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>T</c-><c- o>></c->
  <c- k>concept</c-> <c- nc>relocatable</c-> <c- o>=</c-> <i><c- n>see</c-> <c- n>below</c-></i><c- p>;</c->
</pre></small>
   </blockquote>
   <h3 class="heading settled" data-level="3.9" id="wording-concept.relocatable"><span class="secno">3.9. </span><span class="content">[concept.relocatable]</span><a class="self-link" href="#wording-concept.relocatable"></a></h3>
   <p class="note" role="note"><b>DRAFTING NOTE:</b> We intend that a type may be relocatable
regardless of whether it is copy-constructible; but, if it is copy-constructible then copy-and-destroy
must have the same semantics as move-and-destroy. We intend that a type may be relocatable regardless of
whether it is assignable; but, if it is assignable then assignment must have the same semantics as
destroy-and-copy or destroy-and-move.
The semantic requirements on assignment help us optimize <code class="highlight"><c- n>vector</c-><c- o>::</c-><c- n>insert</c-></code> and <code class="highlight"><c- n>vector</c-><c- o>::</c-><c- n>erase</c-></code>. <code class="highlight"><c- n>pmr</c-><c- o>::</c-><c- n>forward_list</c-><c- o>&lt;</c-><c- b>int</c-><c- o>></c-></code> satisfies <code class="highlight"><c- n>relocatable</c-></code>, but it models <code class="highlight"><c- n>relocatable</c-></code> only when all relevant objects have equal allocators. </p>
   <p>Add a new section after <a href="http://eel.is/c++draft/concept.copyconstructible">[concept.copyconstructible]</a>:</p>
   <p><small></small></p>
   <blockquote>
    <p></p>
    <small> <ins><b><code class="highlight"><c- n>relocatable</c-></code> concept [concept.relocatable]</b></ins> <p></p><pre class="highlight">  <ins><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>T</c-><c- o>></c-></ins>
    <ins><c- k>concept</c-> <c- nc>relocatable</c-> <c- o>=</c-> <c- n>move_constructible</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-><c- p>;</c-></ins>
</pre> <p><ins>1․ If <code class="highlight"><c- n>T</c-></code> is an object type, then let <code class="highlight"><c- n>rv</c-></code> be an rvalue of type <code class="highlight"><c- n>T</c-></code>, <code class="highlight"><c- n>lv</c-></code> an lvalue of type <code class="highlight"><c- n>T</c-></code> equal to <code class="highlight"><c- n>rv</c-></code>,
and <code class="highlight"><c- n>u2</c-></code> a distinct complete object of type <code class="highlight"><c- n>T</c-></code> equal to <code class="highlight"><c- n>rv</c-></code>. <code class="highlight"><c- n>T</c-></code> models <code class="highlight"><c- n>relocatable</c-></code> only if</ins> </p><ul><li data-md><ins>After the definition <code class="highlight"><c- n>T</c-> <c- n>u</c-> <c- o>=</c-> <c- n>rv</c-><c- p>;</c-></code>, <code class="highlight"><c- n>u</c-></code> is equal to <code class="highlight"><c- n>u2</c-></code>.</ins> </li><li data-md><ins><code class="highlight"><c- n>T</c-><c- p>(</c-><c- n>rv</c-><c- p>)</c-></code> is equal to <code class="highlight"><c- n>u2</c-></code>.</ins> </li><li data-md><ins>If the expression <code class="highlight"><c- n>u2</c-> <c- o>=</c-> <c- n>rv</c-></code> is well-formed, then the expression has the same semantics as <code class="highlight"><c- n>u2</c-><c- p>.</c-><c- o>~</c-><c- n>T</c-><c- p>();</c-> <c- o>::</c-><c- k>new</c-> <c- p>((</c-><c- b>void</c-><c- o>*</c-><c- p>)</c-><c- n>std</c-><c- o>::</c-><c- n>addressof</c-><c- p>(</c-><c- n>u2</c-><c- p>))</c-> <c- n>T</c-><c- p>(</c-><c- n>rv</c-><c- p>);</c-></code></ins> </li><li data-md><ins>If the definition <code class="highlight"><c- n>T</c-> <c- n>u</c-> <c- o>=</c-> <c- n>lv</c-><c- p>;</c-></code> is well-formed, then after the definition <code class="highlight"><c- n>u</c-></code> is equal to <code class="highlight"><c- n>u2</c-></code>.</ins> </li><li data-md><ins>If the expression <code class="highlight"><c- n>T</c-><c- p>(</c-><c- n>lv</c-><c- p>)</c-></code> is well-formed, then the expression’s result is equal to <code class="highlight"><c- n>u2</c-></code>.</ins> </li><li data-md><ins>If the expression <code class="highlight"><c- n>u2</c-> <c- o>=</c-> <c- n>lv</c-></code> is well-formed, then the expression has the same semantics as <code class="highlight"><c- n>u2</c-><c- p>.</c-><c- o>~</c-><c- n>T</c-><c- p>();</c-> <c- o>::</c-><c- k>new</c-> <c- p>((</c-><c- b>void</c-><c- o>*</c-><c- p>)</c-><c- n>std</c-><c- o>::</c-><c- n>addressof</c-><c- p>(</c-><c- n>u2</c-><c- p>))</c-> <c- n>T</c-><c- p>(</c-><c- n>lv</c-><c- p>);</c-></code></ins> </li></ul> </small>
   </blockquote>
   <h3 class="heading settled" data-level="3.10" id="wording-memory.syn"><span class="secno">3.10. </span><span class="content">[memory.syn]</span><a class="self-link" href="#wording-memory.syn"></a></h3>
   <p>Modify <a href="http://eel.is/c++draft/memory.syn">[memory.syn]</a> as follows:</p>
   <p><small></small></p>
   <blockquote>
    <p></p>
    <small> <pre class="highlight"><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>InputIterator</c-><c- p>,</c-> <c- k>class</c-> <c- nc>NoThrowForwardIterator</c-><c- o>></c->
  <c- n>NoThrowForwardIterator</c-> <c- n>uninitialized_move</c-><c- p>(</c-><c- n>InputIterator</c-> <c- n>first</c-><c- p>,</c->                  <c- c1>// freestanding</c->
                                            <c- n>InputIterator</c-> <c- n>last</c-><c- p>,</c->
                                            <c- n>NoThrowForwardIterator</c-> <c- n>result</c-><c- p>);</c->
<c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>ExecutionPolicy</c-><c- p>,</c-> <c- k>class</c-> <c- nc>ForwardIterator</c-><c- p>,</c-> <c- k>class</c-> <c- nc>NoThrowForwardIterator</c-><c- o>></c->
  <c- n>NoThrowForwardIterator</c-> <c- n>uninitialized_move</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c->               <c- c1>// see [algorithms.parallel.overloads]</c->
                                            <c- n>ForwardIterator</c-> <c- n>first</c-><c- p>,</c-> <c- n>ForwardIterator</c-> <c- n>last</c-><c- p>,</c->
                                            <c- n>NoThrowForwardIterator</c-> <c- n>result</c-><c- p>);</c->
<c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>InputIterator</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Size</c-><c- p>,</c-> <c- k>class</c-> <c- nc>NoThrowForwardIterator</c-><c- o>></c->
  <c- n>pair</c-><c- o>&lt;</c-><c- n>InputIterator</c-><c- p>,</c-> <c- n>NoThrowForwardIterator</c-><c- o>></c->
    <c- n>uninitialized_move_n</c-><c- p>(</c-><c- n>InputIterator</c-> <c- n>first</c-><c- p>,</c-> <c- n>Size</c-> <c- n>n</c-><c- p>,</c->                             <c- c1>// freestanding</c->
                         <c- n>NoThrowForwardIterator</c-> <c- n>result</c-><c- p>);</c->
<c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>ExecutionPolicy</c-><c- p>,</c-> <c- k>class</c-> <c- nc>ForwardIterator</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Size</c-><c- p>,</c->
         <c- k>class</c-> <c- nc>NoThrowForwardIterator</c-><c- o>></c->
  <c- n>pair</c-><c- o>&lt;</c-><c- n>ForwardIterator</c-><c- p>,</c-> <c- n>NoThrowForwardIterator</c-><c- o>></c->
    <c- n>uninitialized_move_n</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c->                                  <c- c1>// see [algorithms.parallel.overloads]</c->
                         <c- n>ForwardIterator</c-> <c- n>first</c-><c- p>,</c-> <c- n>Size</c-> <c- n>n</c-><c- p>,</c-> <c- n>NoThrowForwardIterator</c-> <c- n>result</c-><c- p>);</c->

<c- k>namespace</c-> <c- nn>ranges</c-> <c- p>{</c->
  <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>I</c-><c- p>,</c-> <c- k>class</c-> <c- nc>O</c-><c- o>></c->
    <c- k>using</c-> <c- n>uninitialized_move_result</c-> <c- o>=</c-> <c- n>in_out_result</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O</c-><c- o>></c-><c- p>;</c->                        <c- c1>// freestanding</c->
  <c- k>template</c-><c- o>&lt;</c-><c- n>input_iterator</c-> <c- n>I</c-><c- p>,</c-> <c- n>sentinel_for</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>S1</c-><c- p>,</c->
           <i><c- n>nothrow</c-><c- o>-</c-><c- n>forward</c-><c- o>-</c-><c- n>iterator</c-></i> <c- n>O</c-><c- p>,</c-> <i><c- n>nothrow</c-><c- o>-</c-><c- n>sentinel</c-><c- o>-</c-><c- k>for</c-></i><c- o>&lt;</c-><c- n>O</c-><c- o>></c-> <c- n>S2</c-><c- o>></c->
    <c- k>requires</c-> <c- n>constructible_from</c-><c- o>&lt;</c-><c- n>iter_value_t</c-><c- o>&lt;</c-><c- n>O</c-><c- o>></c-><c- p>,</c-> <c- n>iter_rvalue_reference_t</c-><c- o>&lt;</c-><c- n>I</c-><c- o>>></c->
      <c- n>uninitialized_move_result</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
        <c- n>uninitialized_move</c-><c- p>(</c-><c- n>I</c-> <c- n>ifirst</c-><c- p>,</c-> <c- n>S1</c-> <c- n>ilast</c-><c- p>,</c-> <c- n>O</c-> <c- n>ofirst</c-><c- p>,</c-> <c- n>S2</c-> <c- n>olast</c-><c- p>);</c->               <c- c1>// freestanding</c->
  <c- k>template</c-><c- o>&lt;</c-><c- n>input_range</c-> <c- n>IR</c-><c- p>,</c-> <i><c- n>nothrow</c-><c- o>-</c-><c- n>forward</c-><c- o>-</c-><c- n>range</c-></i> <c- n>OR</c-><c- o>></c->
    <c- k>requires</c-> <c- n>constructible_from</c-><c- o>&lt;</c-><c- n>range_value_t</c-><c- o>&lt;</c-><c- n>OR</c-><c- o>></c-><c- p>,</c-> <c- n>range_rvalue_reference_t</c-><c- o>&lt;</c-><c- n>IR</c-><c- o>>></c->
      <c- n>uninitialized_move_result</c-><c- o>&lt;</c-><c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>IR</c-><c- o>></c-><c- p>,</c-> <c- n>borrowed_iterator_t</c-><c- o>&lt;</c-><c- n>OR</c-><c- o>>></c->
        <c- n>uninitialized_move</c-><c- p>(</c-><c- n>IR</c-><c- o>&amp;&amp;</c-> <c- n>in_range</c-><c- p>,</c-> <c- n>OR</c-><c- o>&amp;&amp;</c-> <c- n>out_range</c-><c- p>);</c->                        <c- c1>// freestanding</c->

  <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>I</c-><c- p>,</c-> <c- k>class</c-> <c- nc>O</c-><c- o>></c->
    <c- k>using</c-> <c- n>uninitialized_move_n_result</c-> <c- o>=</c-> <c- n>in_out_result</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O</c-><c- o>></c-><c- p>;</c->                      <c- c1>// freestanding</c->
  <c- k>template</c-><c- o>&lt;</c-><c- n>input_iterator</c-> <c- n>I</c-><c- p>,</c->
           <i><c- n>nothrow</c-><c- o>-</c-><c- n>forward</c-><c- o>-</c-><c- n>iterator</c-></i> <c- n>O</c-><c- p>,</c-> <i><c- n>nothrow</c-><c- o>-</c-><c- n>sentinel</c-><c- o>-</c-><c- k>for</c-></i><c- o>&lt;</c-><c- n>O</c-><c- o>></c-> <c- n>S</c-><c- o>></c->
    <c- k>requires</c-> <c- n>constructible_from</c-><c- o>&lt;</c-><c- n>iter_value_t</c-><c- o>&lt;</c-><c- n>O</c-><c- o>></c-><c- p>,</c-> <c- n>iter_rvalue_reference_t</c-><c- o>&lt;</c-><c- n>I</c-><c- o>>></c->
      <c- n>uninitialized_move_n_result</c-><c- o>&lt;</c-><c- n>I</c-><c- p>,</c-> <c- n>O</c-><c- o>></c->
        <c- n>uninitialized_move_n</c-><c- p>(</c-><c- n>I</c-> <c- n>ifirst</c-><c- p>,</c-> <c- n>iter_difference_t</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>n</c-><c- p>,</c->                    <c- c1>// freestanding</c->
                             <c- n>O</c-> <c- n>ofirst</c-><c- p>,</c-> <c- n>S</c-> <c- n>olast</c-><c- p>);</c->
<c- p>}</c->

<ins><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>NoThrowInputIterator</c-><c- p>,</c-> <c- k>class</c-> <c- nc>NoThrowForwardIterator</c-><c- o>></c-></ins>
  <ins><c- n>NoThrowForwardIterator</c-> <c- n>uninitialized_relocate</c-><c- p>(</c-><c- n>NoThrowInputIterator</c-> <c- n>first</c-><c- p>,</c-></ins>
                                                <ins><c- n>NoThrowInputIterator</c-> <c- n>last</c-><c- p>,</c-></ins>
                                                <ins><c- n>NoThrowForwardIterator</c-> <c- n>result</c-><c- p>);</c-></ins>   <ins><c- c1>// freestanding</c-></ins>
<ins><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>ExecutionPolicy</c-><c- p>,</c-> <c- k>class</c-> <c- nc>NoThrowForwardIterator1</c-><c- p>,</c-> <c- k>class</c-> <c- nc>NoThrowForwardIterator2</c-><c- o>></c-></ins>
  <ins><c- n>NoThrowForwardIterator2</c-> <c- n>uninitialized_relocate</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-></ins>          <ins><c- c1>// see [algorithms.parallel.overloads]</c-></ins>
                                                 <ins><c- n>NoThrowForwardIterator1</c-> <c- n>first</c-><c- p>,</c-> <c- n>NoThrowForwardIterator1</c-> <c- n>last</c-><c- p>,</c-></ins>
                                                 <ins><c- n>NoThrowForwardIterator2</c-> <c- n>result</c-><c- p>);</c-></ins>

<ins><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>NoThrowInputIterator</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Size</c-><c- p>,</c-> <c- k>class</c-> <c- nc>NoThrowForwardIterator</c-><c- o>></c-></ins>
  <ins><c- n>pair</c-><c- o>&lt;</c-><c- n>NoThrowInputIterator</c-><c- p>,</c-> <c- n>NoThrowForwardIterator</c-><c- o>></c-></ins>
    <ins><c- n>uninitialized_relocate_n</c-><c- p>(</c-><c- n>NoThrowInputIterator</c-> <c- n>first</c-><c- p>,</c-> <c- n>Size</c-> <c- n>n</c-><c- p>,</c-></ins>
                             <ins><c- n>NoThrowForwardIterator</c-> <c- n>result</c-><c- p>);</c-></ins>                      <ins><c- c1>// freestanding</c-></ins>
<ins><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>ExecutionPolicy</c-><c- p>,</c-> <c- k>class</c-> <c- nc>NoThrowForwardIterator1</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Size</c-><c- p>,</c-></ins>
         <ins><c- k>class</c-> <c- nc>NoThrowForwardIterator2</c-><c- o>></c-></ins>
  <ins><c- n>pair</c-><c- o>&lt;</c-><c- n>NoThrowForwardIterator1</c-><c- p>,</c-> <c- n>NoThrowForwardIterator2</c-><c- o>></c-></ins>
    <ins><c- n>uninitialized_relocate_n</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-></ins>                              <ins><c- c1>// see [algorithms.parallel.overloads]</c-></ins>
                             <ins><c- n>NoThrowForwardIterator1</c-> <c- n>first</c-><c- p>,</c-> <c- n>Size</c-> <c- n>n</c-><c- p>,</c-> <c- n>NoThrowForwardIterator2</c-> <c- n>result</c-><c- p>);</c-></ins>

<ins><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>NoThrowBidirectionalIterator1</c-><c- p>,</c-> <c- k>class</c-> <c- nc>NoThrowBidirectionalIterator2</c-><c- o>></c-></ins>
  <ins><c- n>NoThrowBidirectionalIterator2</c-></ins>
    <ins><c- n>uninitialized_relocate_backward</c-><c- p>(</c-><c- n>NoThrowBidirectionalIterator1</c-> <c- n>first</c-><c- p>,</c-></ins>
                                    <ins><c- n>NoThrowBidirectionalIterator1</c-> <c- n>last</c-><c- p>,</c-></ins>
                                    <ins><c- n>NoThrowBidirectionalIterator2</c-> <c- n>result</c-><c- p>);</c-></ins>        <ins><c- c1>// freestanding</c-></ins>
<ins><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>ExecutionPolicy</c-><c- p>,</c-> <c- k>class</c-> <c- nc>NoThrowBidirectionalIterator1</c-><c- p>,</c-> <c- k>class</c-> <c- nc>NoThrowBidirectionalIterator2</c-><c- o>></c-></ins>
  <ins><c- n>NoThrowBidirectionalIterator2</c-></ins>
    <ins><c- n>uninitialized_relocate_backward</c-><c- p>(</c-><c- n>ExecutionPolicy</c-><c- o>&amp;&amp;</c-> <c- n>exec</c-><c- p>,</c-></ins>
                                    <ins><c- n>NoThrowBidirectionalIterator1</c-> <c- n>first</c-><c- p>,</c-></ins>
                                    <ins><c- n>NoThrowBidirectionalIterator1</c-> <c- n>last</c-><c- p>,</c-></ins>
                                    <ins><c- n>NoThrowBidirectionalIterator2</c-> <c- n>result</c-><c- p>);</c-></ins>        <ins><c- c1>// freestanding</c-></ins>

<c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>NoThrowForwardIterator</c-><c- p>,</c-> <c- k>class</c-> <c- nc>T</c-><c- o>></c->
  <c- b>void</c-> <c- n>uninitialized_fill</c-><c- p>(</c-><c- n>NoThrowForwardIterator</c-> <c- n>first</c-><c- p>,</c->                           <c- c1>// freestanding</c->
                          <c- n>NoThrowForwardIterator</c-> <c- n>last</c-><c- p>,</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;</c-> <c- n>x</c-><c- p>);</c->
<c- p>[...]</c->
  <c- k>template</c-><c- o>&lt;</c-><i><c- n>nothrow</c-><c- o>-</c-><c- n>input</c-><c- o>-</c-><c- n>iterator</c-></i> <c- n>I</c-><c- o>></c->
    <c- k>requires</c-> <c- n>destructible</c-><c- o>&lt;</c-><c- n>iter_value_t</c-><c- o>&lt;</c-><c- n>I</c-><c- o>>></c->
      <c- k>constexpr</c-> <c- n>I</c-> <c- n>destroy_n</c-><c- p>(</c-><c- n>I</c-> <c- n>first</c-><c- p>,</c-> <c- n>iter_difference_t</c-><c- o>&lt;</c-><c- n>I</c-><c- o>></c-> <c- n>n</c-><c- p>)</c-> <c- k>noexcept</c-><c- p>;</c->            <c- c1>// freestanding</c->
<c- p>}</c->

<ins><i><c- c1>// </c-><a href="#wording-specialized.relocate"><c- c1>[specialized.relocate]</c-></a><c- c1>, relocate</c-></i></ins>
<ins><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>T</c-><c- o>></c-></ins>
<ins><c- n>T</c-> <c- o>*</c-><c- n>relocate_at</c-><c- p>(</c-><c- n>T</c-><c- o>*</c-> <c- n>source</c-><c- p>,</c-> <c- n>T</c-><c- o>*</c-> <c- n>dest</c-><c- p>);</c-></ins>                                               <ins><c- c1>// freestanding</c-></ins>

<ins><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>T</c-><c- o>></c-></ins>
<ins><c- n>remove_cv_t</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-> <c- n>relocate</c-><c- p>(</c-><c- n>T</c-><c- o>*</c-> <c- n>source</c-><c- p>);</c-></ins>                                               <ins><c- c1>// freestanding</c-></ins>

<c- c1>// [unique.ptr], class template unique_ptr</c->
</pre></small>
   </blockquote>
   <h3 class="heading settled" data-level="3.11" id="wording-meta.type.synop"><span class="secno">3.11. </span><span class="content">[meta.type.synop]</span><a class="self-link" href="#wording-meta.type.synop"></a></h3>
   <p>Modify <a href="http://eel.is/c++draft/meta.type.synop">[meta.type.synop]</a> as follows:</p>
   <p><small></small></p>
   <blockquote>
    <p></p>
    <small> <pre class="highlight"><c- p>[...]</c->
<i><c- c1>// </c-><a href="#wording-meta.unary.prop"><c- c1>[meta.unary.prop]</c-></a><c- c1>, type properties</c-></i>
<c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>T</c-><c- o>></c-> <c- k>struct</c-> <c- nc>is_const</c-><c- p>;</c->
<c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>T</c-><c- o>></c-> <c- k>struct</c-> <c- nc>is_volatile</c-><c- p>;</c->
<c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>T</c-><c- o>></c-> <c- k>struct</c-> <c- nc>is_trivial</c-><c- p>;</c->
<c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>T</c-><c- o>></c-> <c- k>struct</c-> <c- nc>is_trivially_copyable</c-><c- p>;</c->
<ins><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>T</c-><c- o>></c-> <c- k>struct</c-> <c- nc>is_trivially_relocatable</c-><c- p>;</c-></ins>
<c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>T</c-><c- o>></c-> <c- k>struct</c-> <c- nc>is_standard_layout</c-><c- p>;</c->
<c- p>[...]</c->
</pre></small>
   </blockquote>
   <h3 class="heading settled" data-level="3.12" id="wording-meta.unary.prop"><span class="secno">3.12. </span><span class="content">[meta.unary.prop]</span><a class="self-link" href="#wording-meta.unary.prop"></a></h3>
   <p>Add a new entry to Table 47 in <a href="http://eel.is/c++draft/meta.unary.prop">[meta.unary.prop]</a>:</p>
   <p><small></small></p>
   <blockquote>
    <p></p>
    <small> <table> <tbody><tr><th>Template</th><th>Condition</th><th>Preconditions</th></tr> <tr> <td><code class="highlight"><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>T</c-><c- o>></c-> <c- k>struct</c-> <c- nc>is_trivially_copyable</c-><c- p>;</c-></code></td> <td><code class="highlight"><c- n>T</c-></code> is a trivially copyable type ([basic.types.general])</td> <td><code class="highlight"><c- n>remove_all_extents_t</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code> shall be a complete type or <i>cv</i> <code class="highlight"><c- b>void</c-></code>.</td> </tr> <tr> <td><ins><code class="highlight"><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>T</c-><c- o>></c-> <c- k>struct</c-> <c- nc>is_trivially_relocatable</c-><c- p>;</c-></code></ins></td> <td><ins><code class="highlight"><c- n>T</c-></code> is a trivially relocatable type (<a href="#wording-basic.types.general">[basic.types.general]</a>)</ins></td> <td><ins><code class="highlight"><c- n>remove_all_extents_t</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code> shall be a complete type or <i>cv</i> <code class="highlight"><c- b>void</c-></code>.</ins></td> </tr> <tr> <td><code class="highlight"><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>T</c-><c- o>></c-> <c- k>struct</c-> <c- nc>is_standard_layout</c-><c- p>;</c-></code></td> <td><code class="highlight"><c- n>T</c-></code> is a standard-layout type ([basic.types.general])</td> <td><code class="highlight"><c- n>remove_all_extents_t</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code> shall be a complete type or <i>cv</i> <code class="highlight"><c- b>void</c-></code>.</td> </tr> </tbody></table> </small>
   </blockquote>
   <h3 class="heading settled" data-level="3.13" id="wording-algorithms.requirements"><span class="secno">3.13. </span><span class="content">[algorithms.requirements]</span><a class="self-link" href="#wording-algorithms.requirements"></a></h3>
   <p>Modify <a href="https://eel.is/c++draft/algorithms.requirements">[algorithms.requirements]</a> as follows:</p>
   <p><small></small></p>
   <blockquote>
    <p></p>
    <small> <ul><li data-md><p>If an algorithm’s template parameter is named <code class="highlight"><c- n>InputIterator</c-></code>, <code class="highlight"><c- n>InputIterator1</c-></code>, <del>or</del> <code class="highlight"><c- n>InputIterator2</c-></code>, <ins>or <code class="highlight"><c- n>NoThrowInputIterator</c-></code>,</ins> the template argument shall meet the <em>Cpp17InputIterator</em> requirements ([input.iterators]).</p> </li><li data-md><p>If an algorithm’s template parameter is named <code class="highlight"><c- n>OutputIterator</c-></code>, <code class="highlight"><c- n>OutputIterator1</c-></code>, or <code class="highlight"><c- n>OutputIterator2</c-></code>, the template argument
shall meet the <code class="highlight"><c- n>Cpp17OutputIterator</c-></code> requirements ([output.iterators]).</p> </li><li data-md><p>If an algorithm’s template parameter is named <code class="highlight"><c- n>ForwardIterator</c-></code>, <code class="highlight"><c- n>ForwardIterator1</c-></code>, <code class="highlight"><c- n>ForwardIterator2</c-></code>, <del>or</del> <code class="highlight"><c- n>NoThrowForwardIterator</c-></code>, <ins><code class="highlight"><c- n>NoThrowForwardIterator1</c-></code>, or <code class="highlight"><c- n>NoThrowForwardIterator2</c-></code>,</ins> the
template argument shall meet the <em>Cpp17ForwardIterator</em> requirements ([forward.iterators]) if it is required to be a mutable iterator,
or model <code class="highlight"><c- n>forward_iterator</c-></code> ([iterator.concept.forward]) otherwise.</p> </li><li data-md><p>If an algorithm’s template parameter is
named <ins><code class="highlight"><c- n>NoThrowInputIterator</c-></code>,</ins> <code class="highlight"><c- n>NoThrowForwardIterator</c-></code>, <ins><code class="highlight"><c- n>NoThrowForwardIterator1</c-></code>, or <code class="highlight"><c- n>NoThrowForwardIterator2</c-></code>,</ins> the
template argument is also required to have the property that no exceptions are thrown
from increment, assignment, or comparison of, or indirection through, valid iterators.</p> </li><li data-md><p>If an algorithm’s template parameter is named <code class="highlight"><c- n>BidirectionalIterator</c-></code>, <code class="highlight"><c- n>BidirectionalIterator1</c-></code>, <del>or</del> <code class="highlight"><c- n>BidirectionalIterator2</c-></code>, <ins><code class="highlight"><c- n>NoThrowBidirectionalIterator1</c-></code>, or <code class="highlight"><c- n>NoThrowBidirectionalIterator2</c-></code>,</ins> the
template argument shall meet the <em>Cpp17BidirectionalIterator</em> requirements ([bidirectional.iterators])
if it is required to be a mutable iterator, or model <code class="highlight"><c- n>bidirectional_iterator</c-></code> ([iterator.concept.bidir]) otherwise.</p> </li><li data-md><ins>If an algorithm’s template parameter is named <code class="highlight"><c- n>NoThrowBidirectionalIterator1</c-></code> or <code class="highlight"><c- n>NoThrowBidirectionalIterator2</c-></code>, the
template argument is also required to have the property that no exceptions are thrown
from increment, decrement, assignment, or comparison of, or indirection through, valid iterators.</ins> </li></ul> </small>
   </blockquote>
   <h3 class="heading settled" data-level="3.14" id="wording-uninitialized.relocate"><span class="secno">3.14. </span><span class="content">[uninitialized.relocate]</span><a class="self-link" href="#wording-uninitialized.relocate"></a></h3>
   <p class="note" role="note"><b>DRAFTING NOTE:</b> Compare to <a href="https://eel.is/c++draft/uninitialized.move">[uninitialized.move]</a> and <a href="https://eel.is/c++draft/alg.copy">[alg.copy]</a>. The <i>Remarks</i> allude to blanket wording
in <a href="http://eel.is/c++draft/specialized.algorithms#general-2">[specialized.algorithms.general]/2</a>. </p>
   <p>Add a new section after <a href="http://eel.is/c++draft/uninitialized.move">[uninitialized.move]</a>:</p>
   <p><small></small></p>
   <blockquote>
    <p></p>
    <small> <ins><b><code class="highlight"><c- n>uninitialized_relocate</c-></code> [uninitialized.relocate]</b></ins> <pre class="highlight"><ins><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>NoThrowInputIterator</c-><c- p>,</c-> <c- k>class</c-> <c- nc>NoThrowForwardIterator</c-><c- o>></c-></ins>
<ins><c- n>NoThrowForwardIterator</c-> <c- n>uninitialized_relocate</c-><c- p>(</c-><c- n>NoThrowInputIterator</c-> <c- n>first</c-><c- p>,</c-> <c- n>NoThrowInputIterator</c-> <c- n>last</c-><c- p>,</c-></ins>
                                              <ins><c- n>NoThrowForwardIterator</c-> <c- n>result</c-><c- p>);</c-></ins>
</pre><p><ins>1․ <em>Effects:</em> Equivalent to:</ins> </p><pre class="highlight"><ins><c- k>try</c-> <c- p>{</c-></ins>
  <ins><c- k>for</c-> <c- p>(;</c-> <c- n>first</c-> <c- o>!=</c-> <c- n>last</c-><c- p>;</c-> <c- o>++</c-><c- n>result</c-><c- p>,</c-> <c- p>(</c-><c- b>void</c-><c- p>)</c-><c- o>++</c-><c- n>first</c-><c- p>)</c-> <c- p>{</c-></ins>
    <ins><c- o>::</c-><c- k>new</c-> <c- p>(</c-><i><c- n>voidify</c-></i><c- p>(</c-><c- o>*</c-><c- n>result</c-><c- p>))</c-></ins>
      <ins><c- k>typename</c-> <c- nc>iterator_traits</c-><c- o>&lt;</c-><c- n>NoThrowForwardIterator</c-><c- o>>::</c-><c- n>value_type</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>move</c-><c- p>(</c-><c- o>*</c-><c- n>first</c-><c- p>));</c-></ins>
    <ins><c- n>destroy_at</c-><c- p>(</c-><c- n>addressof</c-><c- p>(</c-><c- o>*</c-><c- n>first</c-><c- p>));</c-></ins>
  <ins><c- p>}</c-></ins>
  <ins><c- k>return</c-> <c- n>result</c-><c- p>;</c-></ins>
<ins><c- p>}</c-> <c- k>catch</c-> <c- p>(...)</c-> <c- p>{</c-></ins>
  <ins><c- n>destroy</c-><c- p>(</c-><c- o>++</c-><c- n>first</c-><c- p>,</c-> <c- n>last</c-><c- p>);</c-></ins>
  <ins><c- k>throw</c-><c- p>;</c-></ins>
<ins><c- p>}</c-></ins>
</pre><p><ins>except that if the iterators' common value type is trivially relocatable (<a href="#wording-basic.types.general">[basic.types.general]</a>),
side effects associated with the relocation of values do not happen.</ins> </p><p><ins>2․ <em>Remarks:</em> If an exception is thrown, all objects in both the source and destination
ranges are destroyed.</ins> </p><pre class="highlight"><ins><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>NoThrowInputIterator</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Size</c-><c- p>,</c-> <c- k>class</c-> <c- nc>NoThrowForwardIterator</c-><c- o>></c-></ins>
  <ins><c- n>pair</c-><c- o>&lt;</c-><c- n>NoThrowInputIterator</c-><c- p>,</c-> <c- n>NoThrowForwardIterator</c-><c- o>></c-></ins>
    <ins><c- n>uninitialized_relocate_n</c-><c- p>(</c-><c- n>NoThrowInputIterator</c-> <c- n>first</c-><c- p>,</c-> <c- n>Size</c-> <c- n>n</c-><c- p>,</c-> <c- n>NoThrowForwardIterator</c-> <c- n>result</c-><c- p>);</c-></ins>
</pre><p><ins>3․ <em>Effects:</em> Equivalent to:</ins> </p><pre class="highlight"><ins><c- k>try</c-> <c- p>{</c-></ins>
  <ins><c- k>for</c-> <c- p>(;</c-> <c- n>n</c-> <c- o>></c-> <c- mi>0</c-><c- p>;</c-> <c- o>++</c-><c- n>result</c-><c- p>,</c-> <c- p>(</c-><c- b>void</c-><c- p>)</c-><c- o>++</c-><c- n>first</c-><c- p>,</c-> <c- o>--</c-><c- n>n</c-><c- p>)</c-> <c- p>{</c-></ins>
    <ins><c- o>::</c-><c- k>new</c-> <c- p>(</c-><i><c- n>voidify</c-></i><c- p>(</c-><c- o>*</c-><c- n>result</c-><c- p>))</c-></ins>
      <ins><c- k>typename</c-> <c- nc>iterator_traits</c-><c- o>&lt;</c-><c- n>NoThrowForwardIterator</c-><c- o>>::</c-><c- n>value_type</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>move</c-><c- p>(</c-><c- o>*</c-><c- n>first</c-><c- p>));</c-></ins>
    <ins><c- n>destroy_at</c-><c- p>(</c-><c- n>addressof</c-><c- p>(</c-><c- o>*</c-><c- n>first</c-><c- p>));</c-></ins>
  <ins><c- p>}</c-></ins>
  <ins><c- k>return</c-> <c- p>{</c-><c- n>first</c-><c- p>,</c-> <c- n>result</c-><c- p>};</c-></ins>
<ins><c- p>}</c-> <c- k>catch</c-> <c- p>(...)</c-> <c- p>{</c-></ins>
  <ins><c- n>destroy_n</c-><c- p>(</c-><c- o>++</c-><c- n>first</c-><c- p>,</c-> <c- o>--</c-><c- n>n</c-><c- p>);</c-></ins>
  <ins><c- k>throw</c-><c- p>;</c-></ins>
<ins><c- p>}</c-></ins>
</pre><p><ins>except that if the iterators' common value type is trivially relocatable (<a href="#wording-basic.types.general">[basic.types.general]</a>),
side effects associated with the relocation of values do not happen.</ins> </p><p><ins>4․ <em>Remarks:</em> If an exception is thrown, all objects in both the source and destination
ranges are destroyed.</ins> </p><pre class="highlight"><ins><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>NoThrowBidirectionalIterator1</c-><c- p>,</c-> <c- k>class</c-> <c- nc>NoThrowBidirectionalIterator2</c-><c- o>></c-></ins>
  <ins><c- n>NoThrowBidirectionalIterator2</c-></ins>
    <ins><c- n>uninitialized_relocate_backward</c-><c- p>(</c-><c- n>NoThrowBidirectionalIterator1</c-> <c- n>first</c-><c- p>,</c-></ins>
                                    <ins><c- n>NoThrowBidirectionalIterator1</c-> <c- n>last</c-><c- p>,</c-></ins>
                                    <ins><c- n>NoThrowBidirectionalIterator2</c-> <c- n>result</c-><c- p>);</c-></ins>
</pre> <ins>5․ <em>Effects:</em> Equivalent to:</ins> <pre class="highlight"><ins><c- k>try</c-> <c- p>{</c-></ins>
  <ins><c- k>for</c-> <c- p>(;</c-> <c- n>last</c-> <c- o>!=</c-> <c- n>first</c-><c- p>;</c-> <c- p>)</c-> <c- p>{</c-></ins>
    <ins><c- o>--</c-><c- n>last</c-><c- p>;</c-></ins>
    <ins><c- o>--</c-><c- n>result</c-><c- p>;</c-></ins>
    <ins><c- o>::</c-><c- k>new</c-> <c- p>(</c-><i><c- n>voidify</c-></i><c- p>(</c-><c- o>*</c-><c- n>result</c-><c- p>))</c-></ins>
      <ins><c- k>typename</c-> <c- nc>iterator_traits</c-><c- o>&lt;</c-><c- n>NoThrowBidirectionalIterator2</c-><c- o>>::</c-><c- n>value_type</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>move</c-><c- p>(</c-><c- o>*</c-><c- n>last</c-><c- p>));</c-></ins>
    <ins><c- n>destroy_at</c-><c- p>(</c-><c- n>addressof</c-><c- p>(</c-><c- o>*</c-><c- n>last</c-><c- p>));</c-></ins>
  <ins><c- p>}</c-></ins>
  <ins><c- k>return</c-> <c- n>result</c-><c- p>;</c-></ins>
<ins><c- p>}</c-> <c- k>catch</c-> <c- p>(...)</c-> <c- p>{</c-></ins>
  <ins><c- n>destroy</c-><c- p>(</c-><c- n>first</c-><c- p>,</c-> <c- o>++</c-><c- n>last</c-><c- p>);</c-></ins>
  <ins><c- k>throw</c-><c- p>;</c-></ins>
<ins><c- p>}</c-></ins>
</pre><p><ins>except that if the iterators' common value type is trivially relocatable (<a href="#wording-basic.types.general">[basic.types.general]</a>),
side effects associated with the relocation of values do not happen.</ins> </p><p><ins>6․ <em>Remarks:</em> If an exception is thrown, all objects in both the source and destination
ranges are destroyed.</ins> </p></small>
   </blockquote>
   <h3 class="heading settled" data-level="3.15" id="wording-specialized.relocate"><span class="secno">3.15. </span><span class="content">[specialized.relocate]</span><a class="self-link" href="#wording-specialized.relocate"></a></h3>
   <p>Add a new section after <a href="http://eel.is/c++draft/specialized.destroy">[specialized.destroy]</a>:</p>
   <p><small></small></p>
   <blockquote>
    <p></p>
    <small> <ins><b><code class="highlight"><c- n>relocate</c-></code> [specialized.relocate]</b></ins> <p></p><pre class="highlight">  <ins><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>T</c-><c- o>></c-></ins>
  <ins><c- n>T</c-> <c- o>*</c-><c- n>relocate_at</c-><c- p>(</c-><c- n>T</c-><c- o>*</c-> <c- n>source</c-><c- p>,</c-> <c- n>T</c-><c- o>*</c-> <c- n>dest</c-><c- p>);</c-></ins>
</pre> <p><ins>1․ <em>Mandates:</em> <code class="highlight"><c- n>T</c-></code> is a complete non-array object type.</ins> </p><p><ins>2․ <em>Effects:</em> Equivalent to:</ins> </p><pre class="highlight"><ins><c- k>struct</c-> <c- nc>guard</c-> <c- p>{</c-> <c- n>T</c-> <c- o>*</c-><c- n>t</c-><c- p>;</c-> <c- o>~</c-><c- n>guard</c-><c- p>()</c-> <c- p>{</c-> <c- n>destroy_at</c-><c- p>(</c-><c- n>t</c-><c- p>);</c-> <c- p>}</c-> <c- p>}</c-> <c- n>g</c-><c- p>(</c-><c- n>source</c-><c- p>);</c-></ins>
<ins><c- k>return</c-> <c- o>::</c-><c- k>new</c-> <c- p>(</c-><i><c- n>voidify</c-></i><c- p>(</c-><c- o>*</c-><c- n>dest</c-><c- p>))</c-> <c- n>T</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>move</c-><c- p>(</c-><c- o>*</c-><c- n>source</c-><c- p>));</c-></ins>
</pre><p><ins>except that if <code class="highlight"><c- n>T</c-></code> is trivially relocatable (<a href="#wording-basic.types.general">[basic.types.general]</a>),
side effects associated with the relocation of the value of <code class="highlight"><c- o>*</c-><c- n>source</c-></code> do not happen.</ins> </p><pre class="highlight"><ins><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>T</c-><c- o>></c-></ins>
<ins><c- n>remove_cv_t</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-> <c- n>relocate</c-><c- p>(</c-><c- n>T</c-><c- o>*</c-> <c- n>source</c-><c- p>);</c-></ins>
</pre><p><ins>3․ <em>Mandates:</em> <code class="highlight"><c- n>T</c-></code> is a complete non-array object type.</ins> </p><p><ins>4․ <em>Effects:</em> Equivalent to:</ins> </p><pre class="highlight"><ins><c- n>remove_cv_t</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-> <c- n>t</c-> <c- o>=</c-> <c- n>std</c-><c- o>::</c-><c- n>move</c-><c- p>(</c-><c- n>source</c-><c- p>);</c-></ins>
<ins><c- n>destroy_at</c-><c- p>(</c-><c- n>source</c-><c- p>);</c-></ins>
<ins><c- k>return</c-> <c- n>t</c-><c- p>;</c-></ins>
</pre><p><ins>except that if <code class="highlight"><c- n>T</c-></code> is trivially relocatable (<a href="#wording-basic.types.general">[basic.types.general]</a>),
side effects associated with the relocation of the value of <code class="highlight"><c- o>*</c-><c- n>source</c-></code> do not happen.</ins> </p></small>
   </blockquote>
   <h2 class="heading settled" data-level="4" id="acknowledgements"><span class="secno">4. </span><span class="content">Acknowledgements</span><a class="self-link" href="#acknowledgements"></a></h2>
   <p>Thanks to Pablo Halpern for <a data-link-type="biblio" href="#biblio-n4158" title="N4158: Destructive Move (rev 1)">[N4158]</a>, to which this proposal bears a striking resemblance —​including the meaning assigned to the word "trivial," and the library-algorithm approach to avoiding the
problems with "lame duck objects" discussed in <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2002/n1377.htm#Alternative%20move%20designs">the final section</a> of <a data-link-type="biblio" href="#biblio-n1377" title="N1377: A Proposal to Add Move Semantics Support to the C++ Language">[N1377]</a>. See <a href="http://wiki.edg.com/bin/view/Wg21rapperswil2014/N4034">discussion of N4034 at Rapperswil</a> (June 2014)
and <a href="http://wiki.edg.com/bin/view/Wg21urbana-champaign/EvolutionWorkingGroup#N4158_Destructive_Move_Rev_1">discussion
of N4158 at Urbana</a> (November 2014).</p>
   <p>Significantly different approaches to this problem have previously appeared in Rodrigo Castro Campos’s <a data-link-type="biblio" href="#biblio-n2754" title="N2754: TriviallyDestructibleAfterMove and TriviallyReallocatable (rev 3)">[N2754]</a>, Denis Bider’s <a data-link-type="biblio" href="#biblio-p0023r0" title="P0023R0: Relocator: Efficiently Moving Objects">[P0023R0]</a> (introducing a core-language "relocation" operator), and
Niall Douglas’s <a data-link-type="biblio" href="#biblio-p1029r3" title="P1029R3: move = bitcopies">[P1029R3]</a> (treating trivial relocatability as an aspect of move-construction in isolation,
rather than an aspect of the class type as a whole).</p>
   <p>A less different approach is taken by Mungo Gill &amp; Alisdair Meredith’s <a data-link-type="biblio" href="#biblio-p2786" title="Trivial Relocatability For C++26">[P2786]</a>. <a data-link-type="biblio" href="#biblio-p2814r1" title="Trivial relocatability — comparing P2786 with P1144">[P2814R1]</a> compares P2786R0 against P1144R8.</p>
   <p>Thanks to Elias Kosunen, Niall Douglas, John Bandela, and Nicolas Lesser for their feedback on early drafts of P1144R0.
Thanks to Jens Maurer for his feedback on P1144R3 at Kona 2019, and to Corentin Jabot for championing
P1144R4 at Prague 2020.</p>
   <p>Many thanks to Matt Godbolt for allowing me to install my Clang fork on Compiler Explorer
(<a href="https://p1144.godbolt.org/z/oWEd_X">godbolt.org</a>). See also <a data-link-type="biblio" href="#biblio-announcing" title="Announcing &quot;trivially relocatable&quot;">[Announcing]</a>.</p>
   <p>Thanks to Nicolas Lesser and John McCall for their review comments on the original Clang pull request <a data-link-type="biblio" href="#biblio-d50119" title="Compiler support for P1144R0 __is_trivially_relocatable(T)">[D50119]</a>.
Thanks to Amirreza Ashouri for reviving the Clang effort in 2024 as <a href="https://github.com/llvm/llvm-project/pull/84621">#84621</a>, and to the dozens of GitHub users
who have starred and library maintainers who have commented in support of that review.</p>
   <p>Thanks to Howard Hinnant for appearing with me on <a data-link-type="biblio" href="#biblio-cppchat" title="cpp.chat episode 40: It works but it&apos;s undefined behavior">[CppChat]</a> in 2018, and to Jon Kalb and Phil Nash for hosting us.</p>
   <p>Thanks to Marc Glisse for his work integrating a "trivially relocatable" trait into GNU libstdc++ (see <a data-link-type="biblio" href="#biblio-deque" title="Improve relocation ... (__is_trivially_relocatable): Specialize for deque">[Deque]</a>)
and for answering my questions on <a href="https://gcc.gnu.org/bugzilla/show_bug.cgi?id=87106">GCC bug 87106</a>.</p>
   <p>Thanks to Dana Jansens for her contributions re overlapping and non-standard-layout types (see <a data-link-type="biblio" href="#biblio-subspace" title="Trivially Relocatable Types in C++/Subspace">[Subspace]</a>),
to Alisdair Meredith for our extensive discussions during the February 2023 drafting of P2786R0,
and to Giuseppe D’Angelo for extensive review comments and discussion.</p>
   <p>Thanks to Charles Salvia (<code class="highlight"><c- n>stdx</c-><c- o>::</c-><c- n>error</c-></code>), Isidoros Tsaousis-Seiras (HPX), Orvid King (Folly),
Daniel Anderson (Parlay), and Derek Mauro (Abseil) for their work integrating P1144 into their
respective libraries. Special thanks to Stéphane Janel (AMC) for doing the work completely
independently, such that I only found out after the fact. :)</p>
   <p>Thanks to Giuseppe D’Angelo for <a data-link-type="biblio" href="#biblio-p3233" title="Issues with P2786 (&apos;Trivial Relocatability For C++26&apos;)">[P3233]</a>. Thanks to
Alan de Freitas, Daniel Liam Anderson, Giuseppe D’Angelo, Hans Goudey, Hartmut Kaiser, Isidoros Tsaousis,
Jacques Lucke, Krystian Stasiowski, Shreyas Atre, Stéphane Janel, and Thiago Maciera for <a data-link-type="biblio" href="#biblio-p3236" title="Please reject P2786 and adopt P1144">[P3236]</a>.</p>
   <p>Thanks to... you? If you can help (by adding relevant support to your third-party library;
by submitting P1144-style optimizations to standard libraries; by writing a GCC patch;
by writing a blog post; in any other way), please reach out!</p>
   <h2 class="heading settled" id="polls"><span class="content">Appendix A: Straw polls</span><a class="self-link" href="#polls"></a></h2>
   <h3 class="heading settled" id="taken-polls-2024-06-28"><span class="content">Poll taken in EWG at St Louis on 2024-06-28</span><a class="self-link" href="#taken-polls-2024-06-28"></a></h3>
   <p>Pablo Halpern presented <a data-link-type="biblio" href="#biblio-p2786" title="Trivial Relocatability For C++26">[P2786]</a> along with a sketch of P2786’s roadmap to parity with P1144
(namely <a data-link-type="biblio" href="#biblio-p2967" title="Relocation has a library interface">[P2967]</a>, <a data-link-type="biblio" href="#biblio-p3239" title="A relocating swap">[P3239]</a>, and <a data-link-type="biblio" href="#biblio-d3262" title="Specifying Trivially Relocatable Types in the Standard Library">[D3262]</a>).
On the other side, Giuseppe D’Angelo presented <a data-link-type="biblio" href="#biblio-p3233" title="Issues with P2786 (&apos;Trivial Relocatability For C++26&apos;)">[P3233]</a> and <a data-link-type="biblio" href="#biblio-p3236" title="Please reject P2786 and adopt P1144">[P3236]</a>.</p>
   <table class="def">
    <tbody>
     <tr>
      <th style="width: 70%;">
      <th><strong>SF</strong>
      <th><strong>F</strong>
      <th><strong>N</strong>
      <th><strong>A</strong>
      <th><strong>SA</strong>
     <tr>
      <th><small>Given the new information received (P3233R0, P3236R1, P3278R0), we wish to un-forward P2786 from CWG and bring it back to EWG.</small>
      <th> 21 
      <th> 15 
      <th> 3 
      <th> 6 
      <th> 5 
   </table>
   <h3 class="heading settled" id="taken-polls-2023-02-10"><span class="content">Polls taken in EWGI at Issaquah on 2023-02-10</span><a class="self-link" href="#taken-polls-2023-02-10"></a></h3>
   <p>Arthur O’Dwyer presented <a data-link-type="biblio" href="#biblio-p1144r6" title="Object relocation in terms of move plus destroy">[P1144R6]</a>. Alisdair Meredith presented <a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2786r0.pdf">P2786R0</a> (which proposed a <code class="highlight"><c- p>[[</c-><c- n>maybe_trivially_relocatable</c-><c- p>]]</c-></code>-style facility, and expressed it as a contextual keyword instead
of an attribute). EWGI took the following <a href="https://wiki.edg.com/bin/view/Wg21issaquah2023/EWGIP1144R6">straw polls</a> (as well as polls on attribute syntax and on both papers' readiness for EWG).</p>
   <table class="def">
    <tbody>
     <tr>
      <th style="width: 70%;">
      <th><strong>SF</strong>
      <th><strong>F</strong>
      <th><strong>N</strong>
      <th><strong>A</strong>
      <th><strong>SA</strong>
     <tr>
      <th><small>The problem presented in P1144/P2786 is worth solving.</small>
      <th> 10 
      <th> 8 
      <th> 0 
      <th> 0 
      <th> 0 
     <tr>
      <th><small>The problem being introduced in P1144/P2786 should be solved in a more general way instead of as proposed.</small>
      <th> 3 
      <th> 0 
      <th> 5 
      <th> 6 
      <th> 4 
     <tr>
      <th><small>The annotation should "trust the user" as in P1144R6’s <code class="highlight"><c- p>[[</c-><c- n>trivially_relocatable</c-><c- p>]]</c-></code> ("sharp knife"),
               instead of diagnosing as in P1144R6’s <code class="highlight"><c- p>[[</c-><c- n>clang</c-><c- o>::</c-><c- n>maybe_trivially_relocatable</c-><c- p>]]</c-></code> and P2786R0’s <code class="highlight"><c- n>trivially_relocatable</c-></code> ("dull knife"). Three-way poll.</small>
      <th> — 
      <th> 7 
      <th> 5 
      <th> 6 
      <th> — 
     <tr>
      <th><small>Forward P1144 to EWG.</small>
      <th> 0 
      <th> 7 
      <th> 4 
      <th> 3 
      <th> 1 
   </table>
   <h3 class="heading settled" id="taken-polls-2020-02-13"><span class="content">Polls taken in EWGI at Prague on 2020-02-13</span><a class="self-link" href="#taken-polls-2020-02-13"></a></h3>
   <p>Corentin Jabot championed P1144R4. EWGI discussed P1144R4 and Niall Douglas’s <a data-link-type="biblio" href="#biblio-p1029r3" title="P1029R3: move = bitcopies">[P1029R3]</a> consecutively,
then took the following <a href="https://wiki.edg.com/bin/view/Wg21prague/P1144R4SG17">straw polls</a> (as well as a poll on the attribute syntax).</p>
   <table class="def">
    <tbody>
     <tr>
      <th style="width: 70%;">
      <th><strong>SF</strong>
      <th><strong>F</strong>
      <th><strong>N</strong>
      <th><strong>A</strong>
      <th><strong>SA</strong>
     <tr>
      <th><small>We believe that P1029 and P1144 are sufficiently different that they should be advanced separately.</small>
      <th> 7 
      <th> 3 
      <th> 2 
      <th> 0 
      <th> 0 
     <tr>
      <th><small>EWGI is ok to have the spelling as an attribute with an expression argument.</small>
      <th> 3 
      <th> 5 
      <th> 1 
      <th> 1 
      <th> 0 
     <tr>
      <th><small>EWGI thinks the author should explore P1144 as a customizable type trait.</small>
      <th> 0 
      <th> 0 
      <th> 0 
      <th> 9 
      <th> 2 
     <tr>
      <th><small>Forward P1144 to EWG.</small>
      <th> 1 
      <th> 3 
      <th> 4 
      <th> 1 
      <th> 0 
   </table>
   <p>For polls taken September–November 2018, see <a data-link-type="biblio" href="#biblio-p1144r6" title="Object relocation in terms of move plus destroy">[P1144R6]</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-announcing">[Announcing]
   <dd>Arthur O'Dwyer. <a href="https://quuxplusone.github.io/blog/2018/07/18/announcing-trivially-relocatable/"><cite>Announcing "trivially relocatable"</cite></a>. July 2018. URL: <a href="https://quuxplusone.github.io/blog/2018/07/18/announcing-trivially-relocatable/">https://quuxplusone.github.io/blog/2018/07/18/announcing-trivially-relocatable/</a>
   <dt id="biblio-cppchat">[CppChat]
   <dd>Howard Hinnant; Arthur O'Dwyer. <a href="https://www.youtube.com/watch?v=8u5Qi4FgTP8"><cite>cpp.chat episode 40: It works but it's undefined behavior</cite></a>. August 2018. URL: <a href="https://www.youtube.com/watch?v=8u5Qi4FgTP8">https://www.youtube.com/watch?v=8u5Qi4FgTP8</a>
   <dt id="biblio-d3262">[D3262]
   <dd>Alisdair Meredith. <a href="https://isocpp.org/files/papers/D3262R0.pdf"><cite>Specifying Trivially Relocatable Types in the Standard Library</cite></a>. unreleased (May 2024). URL: <a href="https://isocpp.org/files/papers/D3262R0.pdf">https://isocpp.org/files/papers/D3262R0.pdf</a>
   <dt id="biblio-d50119">[D50119]
   <dd>Arthur O'Dwyer; Nicolas Lesser; John McCall. <a href="https://reviews.llvm.org/D50119"><cite>Compiler support for P1144R0 __is_trivially_relocatable(T)</cite></a>. July 2018. URL: <a href="https://reviews.llvm.org/D50119">https://reviews.llvm.org/D50119</a>
   <dt id="biblio-deque">[Deque]
   <dd>Marc Glisse. <a href="https://github.com/gcc-mirror/gcc/commit/a9b9381580de611126c9888c1a6c12a77d9b682e"><cite>Improve relocation ... (__is_trivially_relocatable): Specialize for deque</cite></a>. November 2018. URL: <a href="https://github.com/gcc-mirror/gcc/commit/a9b9381580de611126c9888c1a6c12a77d9b682e">https://github.com/gcc-mirror/gcc/commit/a9b9381580de611126c9888c1a6c12a77d9b682e</a>
   <dt id="biblio-n1377">[N1377]
   <dd>Howard Hinnant; Peter Dimov; Dave Abrahams. <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2002/n1377.htm"><cite>N1377: A Proposal to Add Move Semantics Support to the C++ Language</cite></a>. September 2002. URL: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2002/n1377.htm">http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2002/n1377.htm</a>
   <dt id="biblio-n2754">[N2754]
   <dd>Rodrigo Castro Campos. <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2754.html"><cite>N2754: TriviallyDestructibleAfterMove and TriviallyReallocatable (rev 3)</cite></a>. September 2008. URL: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2754.html">http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2754.html</a>
   <dt id="biblio-n4158">[N4158]
   <dd>Pablo Halpern. <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4158.pdf"><cite>N4158: Destructive Move (rev 1)</cite></a>. October 2014. URL: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4158.pdf">http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4158.pdf</a>
   <dt id="biblio-p0023r0">[P0023R0]
   <dd>Denis Bider. <a href="http://open-std.org/JTC1/SC22/WG21/docs/papers/2016/p0023r0.pdf"><cite>P0023R0: Relocator: Efficiently Moving Objects</cite></a>. April 2016. URL: <a href="http://open-std.org/JTC1/SC22/WG21/docs/papers/2016/p0023r0.pdf">http://open-std.org/JTC1/SC22/WG21/docs/papers/2016/p0023r0.pdf</a>
   <dt id="biblio-p1029r3">[P1029R3]
   <dd>Niall Douglas. <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2020/p1029r3.pdf"><cite>P1029R3: move = bitcopies</cite></a>. January 2020. URL: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2020/p1029r3.pdf">http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2020/p1029r3.pdf</a>
   <dt id="biblio-p1144r6">[P1144R6]
   <dd>Arthur O'Dwyer. <a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/p1144r6.html"><cite>Object relocation in terms of move plus destroy</cite></a>. June 2022. URL: <a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/p1144r6.html">https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/p1144r6.html</a>
   <dt id="biblio-p2786">[P2786]
   <dd>Mungo Gill; Alisdair Meredith. <a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p2786r7.pdf"><cite>Trivial Relocatability For C++26</cite></a>. September 2024. URL: <a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p2786r7.pdf">https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p2786r7.pdf</a>
   <dt id="biblio-p2814r1">[P2814R1]
   <dd>Mungo Gill; Alisdair Meredith. <a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2814r1.pdf"><cite>Trivial relocatability — comparing P2786 with P1144</cite></a>. May 2023. URL: <a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2814r1.pdf">https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2814r1.pdf</a>
   <dt id="biblio-p2967">[P2967]
   <dd>Alisdair Meredith; Mungo Gill. <a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p2967r1.pdf"><cite>Relocation has a library interface</cite></a>. May 2024. URL: <a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p2967r1.pdf">https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p2967r1.pdf</a>
   <dt id="biblio-p3233">[P3233]
   <dd>Giuseppe D'Angelo. <a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3233r0.html"><cite>Issues with P2786 ('Trivial Relocatability For C++26')</cite></a>. April 2024. URL: <a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3233r0.html">https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3233r0.html</a>
   <dt id="biblio-p3236">[P3236]
   <dd>Alan de Freitas; et al. <a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3236r1.html"><cite>Please reject P2786 and adopt P1144</cite></a>. May 2024. URL: <a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3236r1.html">https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3236r1.html</a>
   <dt id="biblio-p3239">[P3239]
   <dd>Alisdair Meredith. <a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3239r0.pdf"><cite>A relocating swap</cite></a>. May 2024. URL: <a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3239r0.pdf">https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3239r0.pdf</a>
   <dt id="biblio-p3279">[P3279]
   <dd>Arthur O'Dwyer. <a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3279r0.html"><cite>CWG2463: What 'trivially fooable' should mean</cite></a>. May 2024. URL: <a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3279r0.html">https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3279r0.html</a>
   <dt id="biblio-polymorphic">[Polymorphic]
   <dd>Arthur O'Dwyer. <a href="https://quuxplusone.github.io/blog/2023/06/24/polymorphic-types-arent-trivially-relocatable/"><cite>Polymorphic types aren't trivially relocatable</cite></a>. June 2023. URL: <a href="https://quuxplusone.github.io/blog/2023/06/24/polymorphic-types-arent-trivially-relocatable/">https://quuxplusone.github.io/blog/2023/06/24/polymorphic-types-arent-trivially-relocatable/</a>
   <dt id="biblio-subspace">[Subspace]
   <dd>Dana Jansens. <a href="https://danakj.github.io/2023/01/15/trivially-relocatable.html"><cite>Trivially Relocatable Types in C++/Subspace</cite></a>. January 2023. URL: <a href="https://danakj.github.io/2023/01/15/trivially-relocatable.html">https://danakj.github.io/2023/01/15/trivially-relocatable.html</a>
  </dl>