<!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>P1144R10: 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 d5d58a306, updated Fri Jan 26 16:12:28 2024 -0800" name="generator">
  <link href="https://isocpp.org/favicon.ico" rel="icon">
<style>
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">P1144R10<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-02-14">2024-02-14</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>LEWG, EWG
     <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>We define a new verb, "relocate," equivalent to a move and a destroy.
For many C++ types, this is implementable "trivially," as a single <code class="highlight"><c- n>memcpy</c-></code>.
We propose a standard trait so library writers can detect such types.
We propose a compiler rule that propagates trivial relocatability among Rule-of-Zero types.
Finally, we propose a standard syntax for a user-defined type (e.g. <code class="highlight"><c- n>boost</c-><c- o>::</c-><c- n>container</c-><c- o>::</c-><c- n>static_vector</c-></code>) to warrant
to the implementation that it is trivially relocatable.</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">Introduction and motivation</span></a>
     <ol class="toc">
      <li>
       <a href="#applications"><span class="secno">2.1</span> <span class="content">Who optimizes on this?</span></a>
       <ol class="toc">
        <li><a href="#benefit-resize"><span class="secno">2.1.1</span> <span class="content">Contiguous reallocation</span></a>
        <li><a href="#benefit-type-erasure"><span class="secno">2.1.2</span> <span class="content">Moving in-place/SBO type-erased types like <code class="highlight"><c- n>any</c-></code> and <code class="highlight"><c- n>function</c-></code></span></a>
        <li><a href="#benefit-fixed-capacity"><span class="secno">2.1.3</span> <span class="content">Moving fixed-capacity containers like <code class="highlight"><c- n>static_vector</c-></code> and <code class="highlight"><c- n>small_vector</c-></code></span></a>
        <li><a href="#benefit-insert-erase"><span class="secno">2.1.4</span> <span class="content">Contiguous insert and erase</span></a>
        <li><a href="#benefit-swap"><span class="secno">2.1.5</span> <span class="content">Swap</span></a>
       </ol>
      <li><a href="#benefit-assertions"><span class="secno">2.2</span> <span class="content">Assertions, not assumptions</span></a>
      <li><a href="#doing-it-wrong"><span class="secno">2.3</span> <span class="content">Eliminate manual warrants, improve safety</span></a>
     </ol>
    <li>
     <a href="#design-goals"><span class="secno">3</span> <span class="content">Design goals</span></a>
     <ol class="toc">
      <li><a href="#design-non-goals"><span class="secno">3.1</span> <span class="content">Non-goals</span></a>
     </ol>
    <li>
     <a href="#wording"><span class="secno">4</span> <span class="content">Proposed wording for C++26</span></a>
     <ol class="toc">
      <li><a href="#wording-cpp.predefined"><span class="secno">4.1</span> <span class="content">Predefined macro names [cpp.predefined]</span></a>
      <li><a href="#wording-version.syn"><span class="secno">4.2</span> <span class="content">Header <code class="highlight"><c- o>&lt;</c-><c- n>version</c-><c- o>></c-></code> synopsis [version.syn]</span></a>
      <li><a href="#wording-defns.relocation"><span class="secno">4.3</span> <span class="content">Relocation operation [defns.relocation]</span></a>
      <li><a href="#wording-class.prop"><span class="secno">4.4</span> <span class="content">Trivially relocatable class [class.prop]</span></a>
      <li><a href="#wording-basic.types.general"><span class="secno">4.5</span> <span class="content">Trivially relocatable type [basic.types.general]</span></a>
      <li>
       <a href="#wording-dcl.attr.trivreloc"><span class="secno">4.6</span> <span class="content">Trivially relocatable attribute [dcl.attr.trivreloc]</span></a>
       <ol class="toc">
        <li><a href="#wording-cpp.cond"><span class="secno">4.6.1</span> <span class="content"><code class="highlight"><c- n>__has_cpp_attribute</c-></code> entry [cpp.cond]</span></a>
       </ol>
      <li><a href="#wording-concept.relocatable"><span class="secno">4.7</span> <span class="content"><code class="highlight"><c- n>relocatable</c-></code> concept [concept.relocatable]</span></a>
      <li><a href="#wording-meta.unary.prop"><span class="secno">4.8</span> <span class="content">Type trait <code class="highlight"><c- n>is_trivially_relocatable</c-></code> [meta.unary.prop]</span></a>
      <li><a href="#wording-specialized.relocate"><span class="secno">4.9</span> <span class="content"><code class="highlight"><c- n>relocate_at</c-></code> and <code class="highlight"><c- n>relocate</c-></code></span></a>
      <li><a href="#wording-algorithms.requirements"><span class="secno">4.10</span> <span class="content">Nothrow bidirectional iterator [algorithms.requirements]</span></a>
      <li><a href="#wording-uninitialized.relocate"><span class="secno">4.11</span> <span class="content"><code class="highlight"><c- n>uninitialized_relocate</c-></code>, <code class="highlight"><c- n>uninitialized_relocate_n</c-></code>, <code class="highlight"><c- n>uninitialized_relocate_backward</c-></code> [uninitialized.relocate]</span></a>
     </ol>
    <li>
     <a href="#alternatives"><span class="secno">5</span> <span class="content">Rationale and alternatives</span></a>
     <ol class="toc">
      <li><a href="#maybe-trivially-relocatable"><span class="secno">5.1</span> <span class="content">Attribute <code class="highlight"><c- p>[[</c-><c- n>maybe_trivially_relocatable</c-><c- p>]]</c-></code></span></a>
      <li><a href="#relevance-of-assignment"><span class="secno">5.2</span> <span class="content">Relevance of <code class="highlight"><c- k>operator</c-><c- o>=</c-></code></span></a>
      <li><a href="#pmr-concerns"><span class="secno">5.3</span> <span class="content">Confusing interactions with <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>pmr</c-></code></span></a>
     </ol>
    <li><a href="#acknowledgements"><span class="secno">6</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-2023-02-10"><span class="secno"></span> <span class="content">Polls taken at 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 at EWGI at Prague on 2020-02-13</span></a>
     </ol>
    <li><a href="#samples"><span class="secno"></span> <span class="content">Appendix B: Sample code</span></a>
    <li><a href="#non-trivial-samples"><span class="secno"></span> <span class="content">Appendix C: Examples of non-trivially relocatable class types</span></a>
    <li>
     <a href="#implementation"><span class="secno"></span> <span class="content">Appendix D: Implementation experience</span></a>
     <ol class="toc">
      <li><a href="#implementation-core"><span class="secno"></span> <span class="content">Core-language implementations</span></a>
      <li><a href="#implementation-lib"><span class="secno"></span> <span class="content">Library implementations</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>R10 (pre-Tokyo 2024):</p>
     <ul>
      <li data-md>
       <p>Added implementation experience with <a data-link-type="biblio" href="#biblio-abseil" title="Abseil C++ Common Libraries">[Abseil]</a>, <a data-link-type="biblio" href="#biblio-amadeus" title="AMadeus (C++) Containers">[Amadeus]</a>, <a data-link-type="biblio" href="#biblio-hpx" title="Relocation Semantics in the HPX Library">[HPX]</a>, <a data-link-type="biblio" href="#biblio-parlaylib" title="ParlayLib, a toolkit for programming parallel algorithms on shared-memory multicore machines">[ParlayLib]</a>, <a data-link-type="biblio" href="#biblio-stdxerror" title="Implementation of std::error as proposed by Herb Sutter in P0709R0">[StdxError]</a>, and <a data-link-type="biblio" href="#biblio-thrust" title="Nvidia Thrust">[Thrust]</a>.
    Added <a href="#relevance-of-assignment">§5.2 "Relevance of <code class="highlight"><c- k>operator</c-><c- o>=</c-></code>"</a>.</p>
      <li data-md>
       <p>Wording for <code class="highlight"><c- n>ExecutionPolicy</c-></code> overloads of the specialized algorithms. Explain why
    there are no <code class="highlight"><c- n>ranges</c-></code> overloads.</p>
      <li data-md>
       <p>Moved "trivially relocatable class" wording into [class.prop], and increased the similarity
    between <code class="highlight"><c- p>[[</c-><c- n>trivially_relocatable</c-><c- p>]]</c-></code> and <code class="highlight"><c- p>[[</c-><c- n>no_unique_address</c-><c- p>]]</c-></code>.</p>
     </ul>
    <li data-md>
     <p>R9 (pre-Kona 2023):</p>
     <ul>
      <li data-md>
       <p>Added feature-test macros <code class="highlight"><c- n>__cpp_impl_trivially_relocatable</c-></code> and <code class="highlight"><c- n>__cpp_lib_trivially_relocatable</c-></code>.</p>
      <li data-md>
       <p>Added <a href="#design-non-goals">§3.1 "Design non-goals"</a> and comparison to <a data-link-type="biblio" href="#biblio-p2785r3" title="Relocating prvalues">[P2785R3]</a>.</p>
      <li data-md>
       <p>Replaced <a href="#non-trivial-samples">Appendix C "Examples of non-trivially relocatable class types"</a> with a shorter summary.</p>
      <li data-md>
       <p>Removed Appendix E "Open questions" as basically redundant with <a href="#pmr-concerns">§5.3 "Confusing interactions with <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>pmr</c-></code>"</a>.
    See <a href="https://quuxplusone.github.io/blog/2023/06/03/p1144-pmr-koans/">"P1144 PMR koans"</a> (June 2023).</p>
     </ul>
    <li data-md>
     <p>R8 (pre-Varna 2023):</p>
     <ul>
      <li data-md>
       <p><a href="#wording-dcl.attr.trivreloc">dcl.attr.trivreloc</a>: Removed "If a type <code class="highlight"><c- n>T</c-></code> is declared <code class="highlight"><c- n>trivially_relocatable</c-></code>,
    and <code class="highlight"><c- n>T</c-></code> is either not move-constructible or not destructible, the program is ill-formed."
    This should have been removed in R7 along with "move-constructible, destructible."</p>
      <li data-md>
       <p><a href="#wording-meta.unary.prop">meta.unary.prop</a>: Adjusted the precondition of <code class="highlight"><c- n>is_trivially_relocatable_v</c-></code> to match <code class="highlight"><c- n>is_trivially_copyable_v</c-></code>.
    Removed <code class="highlight"><c- n>is_relocatable_v</c-></code>, <code class="highlight"><c- n>is_nothrow_relocatable_v</c-></code> for insufficient motivation (but kept <code class="highlight"><c- k>concept</c-> <c- nc>relocatable</c-></code> because it expresses semantic requirements).</p>
      <li data-md>
       <p>Marked <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>relocate</c-></code> as <code class="highlight"><c- p>[[</c-><c- n>nodiscard</c-><c- p>]]</c-></code>; changed its return type to <code class="highlight"><c- n>remove_cv_t</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code>.</p>
      <li data-md>
       <p>Rewrote <a href="#design-goals">§3 "Design goals."</a></p>
     </ul>
    <li data-md>
     <p>R7 (post-Issaquah 2023):</p>
     <ul>
      <li data-md>
       <p>Added <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>uninitialized_relocate_backward</c-></code>, the building block of <code class="highlight"><c- n>vector</c-><c- o>::</c-><c- n>insert</c-></code>.</p>
      <li data-md>
       <p>Removed "move-constructible, destructible" from the requirements in <a href="#wording-basic.types.general">basic.types.general</a>.
    Now trivially relocatable types, like trivially copyable types, can be non-relocatable.</p>
      <li data-md>
       <p>Added <a href="#applications">table §2.1</a> directly comparing this proposal to Folly, BSL, and Qt.</p>
      <li data-md>
       <p>Added straw poll results from Issaquah; removed much background and discussion
    (leaving only notes for the interested reader to consult <a data-link-type="biblio" href="#biblio-p1144r6" title="Object relocation in terms of move plus destroy">[P1144R6]</a>).</p>
     </ul>
   </ul>
   <h2 class="heading settled" data-level="2" id="intro"><span class="secno">2. </span><span class="content">Introduction and motivation</span><a class="self-link" href="#intro"></a></h2>
   <p>Given an object type <code class="highlight"><c- n>T</c-></code> and memory addresses <code class="highlight"><c- n>src</c-></code> and <code class="highlight"><c- n>dst</c-></code>,
the phrase "<b><i>relocate</i></b> a <code class="highlight"><c- n>T</c-></code> from <code class="highlight"><c- n>src</c-></code> to <code class="highlight"><c- n>dst</c-></code>" means
"<em>move-construct</em> <code class="highlight"><c- n>dst</c-></code> from <code class="highlight"><c- n>src</c-></code>, and then immediately <em>destroy</em> the object at <code class="highlight"><c- n>src</c-></code>."</p>
   <p>Any type which is both move-constructible and destructible is <b><i>relocatable</i></b>.
A type is <b><i>nothrow relocatable</i></b> if its relocation operation is noexcept, and a type
is <b><i>trivially relocatable</i></b> if its relocation operation is trivial (which,
just like trivial move-construction and trivial copy-construction, means
"tantamount to <code class="highlight"><c- n>memcpy</c-></code>").</p>
   <p>In practice, almost all relocatable types are trivially relocatable: <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>unique_ptr</c-><c- o>&lt;</c-><c- b>int</c-><c- o>></c-></code>, <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>vector</c-><c- o>&lt;</c-><c- b>int</c-><c- o>></c-></code>, <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>string</c-></code> (on libc++ and MSVC), <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>list</c-><c- o>&lt;</c-><c- b>int</c-><c- o>></c-></code> (on MSVC).
Examples of non-trivially relocatable types include <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>list</c-><c- o>&lt;</c-><c- b>int</c-><c- o>></c-></code> (on libstdc++ and libc++)
and <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>string</c-></code> (on libstdc++). See <a href="#non-trivial-samples">Appendix C: Examples of non-trivially relocatable class types</a> and <a data-link-type="biblio" href="#biblio-inpractice" title="What library types are trivially relocatable in practice?">[InPractice]</a>.</p>
   <p>P1144 allows the library programmer
to <b><i>warrant</i></b> to the compiler that a resource-management type is trivially relocatable.
Explicit warrants are rarely needed because the compiler can infer trivial relocatability for
Rule-of-Zero types. See <a href="#wording-basic.types.general">§ 4.5 Trivially relocatable type [basic.types.general]</a>.</p>
   <p>The most important thing about P1144 relocation is that it is backward compatible and does not
break either API or ABI. P1144 intends simply to legalize the well-understood tricks
that many industry codebases already do (see <a data-link-type="biblio" href="#biblio-bsl" title="bslmf::IsBitwiseMoveable: bitwise moveable trait metafunction">[BSL]</a>, <a data-link-type="biblio" href="#biblio-folly" title="Folly documentation on &quot;Object Relocation&quot;">[Folly]</a>, <a data-link-type="biblio" href="#biblio-deque" title="Improve relocation ... (__is_trivially_relocatable): Specialize for deque">[Deque]</a>, <a data-link-type="biblio" href="#biblio-abseil" title="Abseil C++ Common Libraries">[Abseil]</a>),
not to change the behavior of any existing source code (except to speed it up),
nor to require major work from standard library vendors.</p>
   <h3 class="heading settled" data-level="2.1" id="applications"><span class="secno">2.1. </span><span class="content">Who optimizes on this?</span><a class="self-link" href="#applications"></a></h3>
   <p>The following optimizations are possible according to P1144’s notion of
trivial relocatability. Here’s who does these optimizations in practice:</p>
   <table>
    <tbody>
     <tr>
      <td>
      <td> vector<br> realloc 
      <td> type<br> erasure 
      <td> fixed-cap<br> move 
      <td> vector<br> <code class="highlight"><c- n>erase</c-></code> 
      <td> vector<br> <code class="highlight"><c- n>insert</c-></code> 
      <td> <code class="highlight"><c- n>rotate</c-></code> 
      <td> <code class="highlight"><c- n>swap</c-></code> 
     <tr>
      <td> Arthur’s libc++ <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>is_trivially_relocatable_v</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code> 
      <td> <a href="https://github.com/Quuxplusone/llvm-project/blob/d0c5d3639e/libcxx/include/vector#L936-L942"><code class="highlight"><c- n>vector</c-></code></a> 
      <td> no 
      <td> N/A 
      <td> <a href="https://github.com/Quuxplusone/llvm-project/blob/e8b61de07/libcxx/include/vector#L1663-L1669"><code class="highlight"><c- n>vector</c-></code></a><br> (<a href="https://godbolt.org/z/18hvvxjE4">Godbolt</a>) 
      <td> <a href="https://github.com/Quuxplusone/llvm-project/blob/e8b61de07/libcxx/include/vector#L1722-L1732"><code class="highlight"><c- n>vector</c-></code></a><br> (<a href="https://godbolt.org/z/18hvvxjE4">Godbolt</a>) 
      <td> yes, uses <code class="highlight"><c- n>swap_ranges</c-></code><br> (<a href="https://godbolt.org/z/onxrEce6G">Godbolt</a>) 
      <td> <a href="https://github.com/Quuxplusone/llvm-project/blob/e8b61de07/libcxx/include/__algorithm/swap_ranges.h#L59-L75"><code class="highlight"><c- n>swap_ranges</c-></code></a><br> (<a href="https://godbolt.org/z/onxrEce6G">Godbolt</a>) 
     <tr>
      <td> <a data-link-type="biblio" href="#biblio-bsl" title="bslmf::IsBitwiseMoveable: bitwise moveable trait metafunction">[BSL]</a> <code class="highlight"><c- n>bslmf</c-><c- o>::</c-><c- n>IsBitwiseMoveable</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code> 
      <td> <a href="https://github.com/bloomberg/bde/blob/e15f05be6/groups/bsl/bslstl/bslstl_vector.h#L3374-L3398"><code class="highlight"><c- n>vector</c-></code></a> 
      <td> <a href="https://github.com/bloomberg/bde/blob/e15f05be6/groups/bsl/bslstl/bslstl_function.h#L116-L131">no</a> 
      <td> ? 
      <td> <a href="https://github.com/bloomberg/bde/blob/e15f05be6/groups/bsl/bslalg/bslalg_arrayprimitives.h#L3769-L3800"><code class="highlight"><c- n>vector</c-></code></a> 
      <td> <a href="https://github.com/bloomberg/bde/blob/e15f05be6/groups/bsl/bslalg/bslalg_arrayprimitives.h#L3606-L3643"><code class="highlight"><c- n>vector</c-></code></a> 
      <td> <a href="https://github.com/bloomberg/bde/blob/e15f05be6/groups/bsl/bslalg/bslalg_arrayprimitives.h#L1707-L1722"><code class="highlight"><c- n>ArrayPrimitives_Imp</c-><c- o>::</c-><c- n>rotate</c-></code></a>, unused by <code class="highlight"><c- n>bsl</c-><c- o>::</c-><c- n>rotate</c-></code> 
      <td> no 
     <tr>
      <td> <a data-link-type="biblio" href="#biblio-folly" title="Folly documentation on &quot;Object Relocation&quot;">[Folly]</a> <code class="highlight"><c- n>folly</c-><c- o>::</c-><c- n>IsRelocatable</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code> 
      <td> <a href="https://github.com/facebook/folly/blob/1d4690d0a3/folly/FBVector.h#L945-L966"><code class="highlight"><c- n>fbvector</c-></code></a> 
      <td> <a href="https://github.com/facebook/folly/blob/1d4690d0a3/folly/Function.h#L749-L755">no</a> 
      <td> <a href="https://github.com/facebook/folly/blob/b6762ac6b9/folly/small_vector.h#L554-L559"><code class="highlight"><c- n>small_vector</c-></code></a>
      <td> <a href="https://github.com/facebook/folly/blob/1d4690d0a3/folly/FBVector.h#L1232-L1259"><code class="highlight"><c- n>fbvector</c-></code></a> 
      <td> <a href="https://github.com/facebook/folly/blob/1d4690d0a3/folly/FBVector.h#L1273-L1292"><code class="highlight"><c- n>fbvector</c-></code></a> 
      <td> N/A 
      <td> N/A 
     <tr>
      <td> <a data-link-type="biblio" href="#biblio-qt" title="Qt Base">[Qt]</a> <code class="highlight"><c- n>QTypeInfo</c-><c- o>&lt;</c-><c- n>T</c-><c- o>>::</c-><c- n>isRelocatable</c-></code> 
      <td> <a href="https://github.com/qt/qtbase/blob/fbfee2d/src/corelib/tools/qarraydataops.h#L865-L872"><code class="highlight"><c- n>QList</c-></code></a> 
      <td> <a href="https://github.com/qt/qtbase/blob/fbfee2d/src/corelib/kernel/qvariant.h#L73-L94"><code class="highlight"><c- n>QVariant</c-></code></a> 
      <td> <a href="https://github.com/qt/qtbase/blob/fbfee2d/src/corelib/tools/qvarlengtharray.h#L312-L328"><code class="highlight"><c- n>QVarLengthArray</c-></code></a> 
      <td> <a href="https://github.com/qt/qtbase/blob/fbfee2d/src/corelib/tools/qarraydataops.h#L842-L863"><code class="highlight"><c- n>QList</c-></code></a> 
      <td> <a href="https://github.com/qt/qtbase/blob/fbfee2d/src/corelib/tools/qarraydataops.h#L679-L730"><code class="highlight"><c- n>QList</c-></code></a> 
      <td> <a href="https://github.com/qt/qtbase/blob/7db28fb/src/corelib/tools/qcontainertools_impl.h#L89-L107"><code class="highlight"><c- n>q_rotate</c-></code></a> 
      <td> N/A 
     <tr>
      <td> <a data-link-type="biblio" href="#biblio-abseil" title="Abseil C++ Common Libraries">[Abseil]</a> <code class="highlight"><c- n>absl</c-><c- o>::</c-><c- n>is_trivially_relocatable</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code> 
      <td> no 
      <td> N/A 
      <td> <a href="https://github.com/abseil/abseil-cpp/blob/6d17d4b/absl/container/internal/inlined_vector.h#L304-L321">partial</a><br>in <code class="highlight"><c- n>inlined_vector</c-></code> 
      <td> <a href="https://github.com/abseil/abseil-cpp/pull/1615">proposed</a> for <code class="highlight"><c- n>inlined_vector</c-></code> 
      <td> no 
      <td> N/A 
      <td> <a href="https://github.com/abseil/abseil-cpp/pull/1618">proposed</a> for <code class="highlight"><c- n>inlined_vector</c-></code> 
     <tr>
      <td> <a data-link-type="biblio" href="#biblio-amadeus" title="AMadeus (C++) Containers">[Amadeus]</a> <code class="highlight"><c- n>amc</c-><c- o>::</c-><c- n>is_trivially_relocatable</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code> 
      <td> <a href="https://github.com/AmadeusITGroup/amc/blob/efcb7be/include/amc/smallvector.hpp#L41-L48"><code class="highlight"><c- n>Vector</c-></code></a> 
      <td> N/A 
      <td> <a href="https://github.com/AmadeusITGroup/amc/blob/efcb7be/include/amc/vectorcommon.hpp#L445-L448"><code class="highlight"><c- n>StaticVector</c-></code></a> 
      <td> <a href="https://github.com/AmadeusITGroup/amc/blob/efcb7be/include/amc/vectorcommon.hpp#L176-L180"><code class="highlight"><c- n>Vector</c-></code></a> 
      <td> <a href="https://github.com/AmadeusITGroup/amc/blob/efcb7be/include/amc/vectorcommon.hpp#L292-L315"><code class="highlight"><c- n>Vector</c-></code></a> 
      <td> N/A 
      <td> <a href="https://github.com/AmadeusITGroup/amc/blob/efcb7be/include/amc/vectorcommon.hpp#L201">no</a> 
      <td>
   </table>
   <h4 class="heading settled" data-level="2.1.1" id="benefit-resize"><span class="secno">2.1.1. </span><span class="content">Contiguous reallocation</span><a class="self-link" href="#benefit-resize"></a></h4>
   <p>Trivial relocation helps anywhere we do the moral equivalent of <code class="highlight"><c- n>realloc</c-></code>,
such as in <code class="highlight"><c- n>vector</c-><c- o>&lt;</c-><c- n>R</c-><c- o>>::</c-><c- n>reserve</c-></code>.</p>
   <p><a data-link-type="biblio" href="#biblio-bench" title="Benchmark code from &quot;The Best Type Traits C++ Doesn&apos;t Have&quot;">[Bench]</a> (presented at C++Now 2018) shows a 3x speedup on <code class="highlight"><c- n>vector</c-><c- o>&lt;</c-><c- n>unique_ptr</c-><c- o>&lt;</c-><c- b>int</c-><c- o>>>::</c-><c- n>resize</c-></code>. <a href="https://www.reddit.com/r/cpp/comments/9wj4vt/trivially_relocatable_in_san_diego_call_for/e9p76i4/">This Reddit thread</a> demonstrates a similar 3x speedup using the online tool Quick-Bench.</p>
   <h4 class="heading settled" data-level="2.1.2" id="benefit-type-erasure"><span class="secno">2.1.2. </span><span class="content">Moving in-place/SBO type-erased types like <code class="highlight"><c- n>any</c-></code> and <code class="highlight"><c- n>function</c-></code></span><a class="self-link" href="#benefit-type-erasure"></a></h4>
   <p>Trivial relocation can de-duplicate the code generated by type-erasing wrappers
like <code class="highlight"><c- n>any</c-></code>, <code class="highlight"><c- n>function</c-></code>, and <code class="highlight"><c- n>move_only_function</c-></code>.
For these types, a <em>move</em> of the wrapper object is implemented in terms of a <em>relocation</em> of the contained object. (E.g., <a href="https://github.com/llvm-mirror/libcxx/blob/8fdc4918/include/any#L389-L394">libc++'s <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>any</c-></code></a>.)
In general, the <em>relocate</em> operation must have a different instantiation for each
different contained type <code class="highlight"><c- n>C</c-></code>, leading to code bloat. But every trivially relocatable <code class="highlight"><c- n>C</c-></code> of a given size can share the same instantiation.</p>
   <h4 class="heading settled" data-level="2.1.3" id="benefit-fixed-capacity"><span class="secno">2.1.3. </span><span class="content">Moving fixed-capacity containers like <code class="highlight"><c- n>static_vector</c-></code> and <code class="highlight"><c- n>small_vector</c-></code></span><a class="self-link" href="#benefit-fixed-capacity"></a></h4>
   <p>The move-constructor of <code class="highlight"><c- n>fixed_capacity_vector</c-><c- o>&lt;</c-><c- n>R</c-><c- p>,</c-><c- n>N</c-><c- o>></c-></code> can be implemented naïvely as an element-by-element <em>move</em> (leaving the source vector’s elements in their moved-from state),
or efficiently as an element-by-element <em>relocate</em> (leaving the source vector empty).
For detailed analysis, see <a data-link-type="biblio" href="#biblio-fixedcapacityvector" title="P1144 case study: Moving a `fixed_capacity_vector`">[FixedCapacityVector]</a>.</p>
   <p><code class="highlight"><c- n>boost</c-><c- o>::</c-><c- n>container</c-><c- o>::</c-><c- n>static_vector</c-><c- o>&lt;</c-><c- n>R</c-><c- p>,</c-><c- n>N</c-><c- o>></c-></code> currently implements the
naïve element-by-element-move strategy, but after LEWG feedback, <a data-link-type="biblio" href="#biblio-p0843r5" title="static_vector">[P0843R5]</a> <code class="highlight"><c- n>static_vector</c-></code> does <a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/p0843r5.html#Move-semantics">permit</a> the faster relocation strategy.</p>
   <h4 class="heading settled" data-level="2.1.4" id="benefit-insert-erase"><span class="secno">2.1.4. </span><span class="content">Contiguous insert and erase</span><a class="self-link" href="#benefit-insert-erase"></a></h4>
   <p>Trivial relocation can be used anywhere we shift a contiguous range left or right,
such as in <code class="highlight"><c- n>vector</c-><c- o>::</c-><c- n>erase</c-></code> (i.e., destroy the erased elements and "close the window"
by memmoving left) and <code class="highlight"><c- n>vector</c-><c- o>::</c-><c- n>insert</c-></code> (i.e., "make a window" by memmoving right and
then construct the new elements in place). <a data-link-type="biblio" href="#biblio-folly" title="Folly documentation on &quot;Object Relocation&quot;">[Folly]</a>'s <code class="highlight"><c- n>fbvector</c-></code> does
this optimization; see <a href="https://github.com/facebook/folly/blob/1d4690d0a3/folly/FBVector.h#L1273-L1308"><code class="highlight"><c- n>fbvector</c-><c- o>::</c-><c- n>make_window</c-></code></a>.
Bloomberg’s <a data-link-type="biblio" href="#biblio-bsl" title="bslmf::IsBitwiseMoveable: bitwise moveable trait metafunction">[BSL]</a> also does this optimization.</p>
   <h4 class="heading settled" data-level="2.1.5" id="benefit-swap"><span class="secno">2.1.5. </span><span class="content">Swap</span><a class="self-link" href="#benefit-swap"></a></h4>
   <p>Given a reliable way of detecting trivial relocatability,
we can optimize any routine that uses the moral equivalent of <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>swap</c-></code>, such as <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>rotate</c-></code>, <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>partition</c-></code>, or <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>sort</c-></code>.</p>
   <p>Optimizing <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>swap</c-></code> produces massive code-size improvements for all swap-based
algorithms, including <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>sort</c-></code> and <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>rotate</c-></code>. 
See <a data-link-type="biblio" href="#biblio-cppnow" title="Trivially Relocatable (C++Now 2019)">[CppNow]</a> <a href="https://www.youtube.com/watch?v=SGdfPextuAU&amp;t=19m56s">@19:56–21:22</a>,
and see <a href="https://p1144.godbolt.org/z/PPYhcYd8d">this Godbolt</a>. <a href="https://quick-bench.com/q/suAss7ElmwgLDbOJQGnlEseheSQ">This Quick-Bench</a> shows a 25% speedup
in <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>rotate</c-></code> when it is allowed to use bitwise swap on a Rule-of-Zero type.</p>
   <h3 class="heading settled" data-level="2.2" id="benefit-assertions"><span class="secno">2.2. </span><span class="content">Assertions, not assumptions</span><a class="self-link" href="#benefit-assertions"></a></h3>
   <p>Some data structures might reasonably assert the trivial relocatability of
their elements, just as they sometimes assert the stronger property of trivial <em>copyability</em> today.
This might help them guarantee reasonable performance, or guarantee exception-safety.</p>
   <p>For an example of how <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>is_trivially_relocatable</c-></code> is being used this way in practice,
see <a data-link-type="biblio" href="#biblio-stdxerror" title="Implementation of std::error as proposed by Herb Sutter in P0709R0">[StdxError]</a>.</p>
   <h3 class="heading settled" data-level="2.3" id="doing-it-wrong"><span class="secno">2.3. </span><span class="content">Eliminate manual warrants, improve safety</span><a class="self-link" href="#doing-it-wrong"></a></h3>
   <p>Many real-world codebases contain templates which require
trivial relocatability of their template parameters, but cannot today <em>verify</em> trivial relocatability. For example, until 2012 <a data-link-type="biblio" href="#biblio-folly" title="Folly documentation on &quot;Object Relocation&quot;">[Folly]</a> <a href="https://github.com/facebook/folly/blob/93b0f543f20b8ef3a4c1e34591370011e2dc7168/folly/FBVector.h#L337-L348">required</a> the programmer to warrant the trivial relocatability of any type stored in a <code class="highlight"><c- n>folly</c-><c- o>::</c-><c- n>fbvector</c-></code>:</p>
<pre class="language-cpp highlight"><c- k>class</c-> <c- nc>Widget</c-> <c- p>{</c->
    <c- n>std</c-><c- o>::</c-><c- n>vector</c-><c- o>&lt;</c-><c- b>int</c-><c- o>></c-> <c- n>lst_</c-><c- p>;</c->
<c- p>};</c->

<c- n>folly</c-><c- o>::</c-><c- n>fbvector</c-><c- o>&lt;</c-><c- n>Widget</c-><c- o>></c-> <c- n>vec</c-><c- p>;</c->  <c- c1>// FAIL AT COMPILE TIME for lack of warrant</c->
</pre>
   <p>This merely encouraged the programmer to add the warrant and continue. An incorrect
warrant was discovered only at runtime, via undefined behavior. See <a data-link-type="biblio" href="#biblio-cppnow" title="Trivially Relocatable (C++Now 2019)">[CppNow]</a> <a href="https://www.youtube.com/watch?v=SGdfPextuAU&amp;t=27m26s">@27:26–31:47</a>;
for real-world examples see Folly issues <a href="https://github.com/facebook/folly/issues/889">#889</a>, <a href="https://github.com/facebook/folly/issues/35">#35</a>, <a href="https://github.com/facebook/folly/issues/316">#316</a>, <a href="https://github.com/facebook/folly/issues/498">#498</a>.</p>
<pre class="language-cpp highlight"><c- k>class</c-> <c- nc>Gadget</c-> <c- p>{</c->
    <c- n>std</c-><c- o>::</c-><c- n>list</c-><c- o>&lt;</c-><c- b>int</c-><c- o>></c-> <c- n>lst_</c-><c- p>;</c->
<c- p>};</c->
<c- c1>// sigh, add the warrant on autopilot</c->
<c- k>template</c-><c- o>&lt;></c-> <c- k>struct</c-> <c- nc>folly</c-><c- o>::</c-><c- n>IsRelocatable</c-><c- o>&lt;</c-><c- n>Gadget</c-><c- o>></c-> <c- o>:</c-> <c- n>std</c-><c- o>::</c-><c- n>true_type</c-> <c- p>{};</c->

<c- n>folly</c-><c- o>::</c-><c- n>fbvector</c-><c- o>&lt;</c-><c- n>Gadget</c-><c- o>></c-> <c- n>vec</c-><c- p>;</c->  <c- c1>// CRASH AT RUNTIME due to fraudulent warrant</c->
</pre>
   <blockquote>
    <p class="note" role="note"><span class="marker">Note:</span> Folly’s <code class="highlight"><c- n>fbvector</c-></code> was <a href="https://github.com/facebook/folly/commit/8dd82d48dd46f43f2ea9b4ed49634a2d3f7ecb43">patched</a> in December 2012 to accept both trivially relocatable and non-trivially relocatable types,
in line with <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>vector</c-></code>. Since then, the effect of an incorrect warrant
remains the same — UB and crash — but a missing warrant simply disables the optimization.</p>
   </blockquote>
   <p>If this proposal is adopted, then Folly can start using <code class="highlight"><c- k>static_assert</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>is_trivially_relocatable_v</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-><c- p>)</c-></code> resp. <code class="highlight"><c- k>if</c-> <c- k>constexpr</c-> <c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>is_trivially_relocatable_v</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-><c- p>)</c-></code> in the implementation of <code class="highlight"><c- n>fbvector</c-></code>, and the programmer can stop writing explicit warrants.
Finally, the programmer can start writing assertions of correctness, which aids maintainability and
can even find real bugs. <a href="https://p1144.godbolt.org/z/7b8893sjr">Example:</a></p>
<pre class="language-cpp highlight"><c- k>class</c-> <c- nc>Widget</c-> <c- p>{</c->
    <c- n>std</c-><c- o>::</c-><c- n>vector</c-><c- o>&lt;</c-><c- b>int</c-><c- o>></c-> <c- n>lst_</c-><c- p>;</c->
<c- p>};</c->
<c- k>static_assert</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>is_trivially_relocatable_v</c-><c- o>&lt;</c-><c- n>Widget</c-><c- o>></c-><c- p>);</c->  <c- c1>// correctly SUCCEEDS</c->

<c- k>class</c-> <c- nc>Gadget</c-> <c- p>{</c->
    <c- n>std</c-><c- o>::</c-><c- n>list</c-><c- o>&lt;</c-><c- b>int</c-><c- o>></c-> <c- n>lst_</c-><c- p>;</c->
<c- p>};</c->
<c- k>static_assert</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>is_trivially_relocatable_v</c-><c- o>&lt;</c-><c- n>Gadget</c-><c- o>></c-><c- p>);</c->  <c- c1>// correctly ERRORS</c->
</pre>
   <p>The improvement in user experience and safety in real-world codebases
(<a data-link-type="biblio" href="#biblio-folly" title="Folly documentation on &quot;Object Relocation&quot;">[Folly]</a>, <a data-link-type="biblio" href="#biblio-bsl" title="bslmf::IsBitwiseMoveable: bitwise moveable trait metafunction">[BSL]</a>, <a data-link-type="biblio" href="#biblio-qt" title="Qt Base">[Qt]</a>, <a data-link-type="biblio" href="#biblio-hpx" title="Relocation Semantics in the HPX Library">[HPX]</a>, <a data-link-type="biblio" href="#biblio-amadeus" title="AMadeus (C++) Containers">[Amadeus]</a>, <a data-link-type="biblio" href="#biblio-abseil" title="Abseil C++ Common Libraries">[Abseil]</a>, etc.)
is the most important benefit to be gained by this proposal.</p>
   <h2 class="heading settled" data-level="3" id="design-goals"><span class="secno">3. </span><span class="content">Design goals</span><a class="self-link" href="#design-goals"></a></h2>
   <p>Briefly: We want to support all five of the following use-cases (<a href="https://godbolt.org/z/W8e6ansPf">Godbolt</a>).</p>
<pre class="language-cpp highlight"><c- k>static_assert</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>is_trivially_relocatable_v</c-><c- o>&lt;</c-><c- n>std</c-><c- o>::</c-><c- n>unique_ptr</c-><c- o>&lt;</c-><c- b>int</c-><c- o>>></c-><c- p>);</c-> <c- c1>// #1</c->

<c- k>struct</c-> <c- nc>RuleOfZero</c-> <c- p>{</c-> <c- n>std</c-><c- o>::</c-><c- n>unique_ptr</c-><c- o>&lt;</c-><c- b>int</c-><c- o>></c-> <c- n>p_</c-><c- p>;</c-> <c- p>};</c->
<c- k>static_assert</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>is_trivially_relocatable_v</c-><c- o>&lt;</c-><c- n>RuleOfZero</c-><c- o>></c-><c- p>);</c-> <c- c1>// #2</c->

<c- k>struct</c-> <c- p>[[</c-><c- n>trivially_relocatable</c-><c- p>]]</c-> <c- n>RuleOf3</c-> <c- p>{</c->
    <c- n>RuleOf3</c-><c- p>(</c-><c- n>RuleOf3</c-><c- o>&amp;&amp;</c-><c- p>);</c->
    <c- n>RuleOf3</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>=</c-><c- p>(</c-><c- n>RuleOf3</c-><c- o>&amp;&amp;</c-><c- p>);</c->
    <c- o>~</c-><c- n>RuleOf3</c-><c- p>();</c->
<c- p>};</c->
<c- k>static_assert</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>is_trivially_relocatable_v</c-><c- o>&lt;</c-><c- n>RuleOf3</c-><c- o>></c-><c- p>);</c-> <c- c1>// #3</c->

<c- k>struct</c-> <c- p>[[</c-><c- n>trivially_relocatable</c-><c- p>]]</c-> <c- n>Wrap0</c-> <c- p>{</c->
    <c- n>boost</c-><c- o>::</c-><c- n>container</c-><c- o>::</c-><c- n>static_vector</c-><c- o>&lt;</c-><c- b>int</c-><c- p>,</c-> <c- mi>10</c-><c- o>></c-> <c- n>v_</c-><c- p>;</c->
    <c- k>static_assert</c-><c- p>(</c-><c- o>!</c-><c- n>std</c-><c- o>::</c-><c- n>is_trivially_relocatable_v</c-><c- o>&lt;</c-><c- k>decltype</c-><c- p>(</c-><c- n>v_</c-><c- p>)</c-><c- o>></c-><c- p>);</c->
        <c- c1>// it's not annotated, but we know it's actually trivial</c->
<c- p>};</c->
<c- k>static_assert</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>is_trivially_relocatable_v</c-><c- o>&lt;</c-><c- n>Wrap0</c-><c- o>></c-><c- p>);</c-> <c- c1>// #4</c->

<c- k>struct</c-> <c- p>[[</c-><c- n>trivially_relocatable</c-><c- p>]]</c-> <c- n>Wrap3</c-> <c- p>{</c->
    <c- n>Wrap3</c-><c- p>(</c-><c- n>Wrap3</c-><c- o>&amp;&amp;</c-><c- p>);</c->
    <c- n>Wrap3</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>=</c-><c- p>(</c-><c- n>Wrap3</c-><c- o>&amp;&amp;</c-><c- p>);</c->
    <c- o>~</c-><c- n>Wrap3</c-><c- p>();</c->
    <c- b>int</c-> <c- n>i_</c-><c- p>;</c->
    <c- n>boost</c-><c- o>::</c-><c- n>interprocess</c-><c- o>::</c-><c- n>offset_ptr</c-><c- o>&lt;</c-><c- b>int</c-><c- o>></c-> <c- n>p_</c-> <c- o>=</c-> <c- o>&amp;</c-><c- n>i_</c-><c- p>;</c->
    <c- k>static_assert</c-><c- p>(</c-><c- o>!</c-><c- n>std</c-><c- o>::</c-><c- n>is_trivially_relocatable_v</c-><c- o>&lt;</c-><c- k>decltype</c-><c- p>(</c-><c- n>p_</c-><c- p>)</c-><c- o>></c-><c- p>);</c->
        <c- c1>// it's not trivial, but we preserve our invariant correctly</c->
<c- p>};</c->
<c- k>static_assert</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>is_trivially_relocatable_v</c-><c- o>&lt;</c-><c- n>Wrap3</c-><c- o>></c-><c- p>);</c-> <c- c1>// #5</c->
</pre>
   <h3 class="heading settled" data-level="3.1" id="design-non-goals"><span class="secno">3.1. </span><span class="content">Non-goals</span><a class="self-link" href="#design-non-goals"></a></h3>
   <p class="note" role="note"><span class="marker">Note:</span> This section was new in P1144R9.</p>
   <p>We propose special support for trivially relocatable types, but no particular support for
types that are relocatable in other ways. The two most-frequently-asked scenarios are:</p>
   <ul>
    <li data-md>
     <p>"Never-empty types," e.g. <code class="highlight"><c- n>gsl</c-><c- o>::</c-><c- n>not_null</c-><c- o>&lt;</c-><c- n>unique_ptr</c-><c- o>&lt;</c-><c- b>int</c-><c- o>>></c-></code>. Such types are not movable (because by design
    they never enter a moved-from state), but they are swappable and could in theory be
    relocatable (but not via move-and-destroy, since they cannot be moved).
    P1144 supports the physical possibility that <code class="highlight"><c- n>is_trivially_relocatable_v</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- o>!</c-><c- n>is_relocatable_v</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code>,
    but keeps the status quo w.r.t. library support for such types;
    e.g. you can’t <code class="highlight"><c- n>resize</c-></code>, <code class="highlight"><c- n>insert</c-></code>, or <code class="highlight"><c- n>erase</c-></code> a <code class="highlight"><c- n>vector</c-></code> of such types.
    P1144’s <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>relocate_at</c-></code> rejects such types.</p>
    <li data-md>
     <p>Types that are "efficiently but non-trivially relocatable," e.g. libc++'s <code class="highlight"><c- n>tuple</c-><c- o>&lt;</c-><c- n>string</c-><c- p>,</c-> <c- n>list</c-><c- o>&lt;</c-><c- b>int</c-><c- o>>></c-></code>,
    where the ideal relocation operation would trivially relocate the string and
    move-and-destroy the list; this is not trivial, but still faster than move-and-destroy’ing
    the whole <code class="highlight"><c- n>tuple</c-></code>. P1144 keeps the status quo w.r.t. such types, and doesn’t
    provide any way to optimize their relocation.
    See <a href="https://quuxplusone.github.io/blog/2018/10/26/cheaply-but-not-trivially-relocatable/">"Cheaply relocatable, but not trivially relocatable"</a> (October 2018).</p>
   </ul>
   <p>The most promising active proposal for "non-trivial relocation" is <a data-link-type="biblio" href="#biblio-p2785r3" title="Relocating prvalues">[P2785R3]</a>. It proposes a
"relocation constructor" like this:</p>
<pre class="language-cpp highlight"><c- k>struct</c-> <c- nc>A</c-> <c- p>{</c->
    <c- n>A</c-><c- p>(</c-><c- n>A</c-><c- p>)</c-> <c- o>=</c-> <c- k>default</c-><c- p>;</c->
<c- p>};</c->
</pre>
   <p>which the compiler deduces is trivial iff all of <code class="highlight"><c- n>A</c-></code>’s members are trivially relocatable.
This solves both of the above "non-goal" scenarios.
However, <a data-link-type="biblio" href="#biblio-p2785r3" title="Relocating prvalues">[P2785R3]</a> fails to support our positive goals <code class="highlight"><c- n>Wrap0</c-></code> and <code class="highlight"><c- n>Wrap3</c-></code>, which are
trivially relocatable despite having some <em>non-trivial</em> members. In other words, P1144 is
forward-compatible with (does not close the door to) <a data-link-type="biblio" href="#biblio-p2785r3" title="Relocating prvalues">[P2785R3]</a>; and vice versa,
adopting <a data-link-type="biblio" href="#biblio-p2785r3" title="Relocating prvalues">[P2785R3]</a> would not solve two of P1144’s five advertised use-cases. WG21 might
well want to adopt both proposals. But P1144 solves "the 99% problem"; P1144 might
not leave enough performance on the table to motivate the further adoption of <a data-link-type="biblio" href="#biblio-p2785r3" title="Relocating prvalues">[P2785R3]</a>.</p>
   <p>Notably, P1144R10 is almost entirely a subset of <a data-link-type="biblio" href="#biblio-p2785r3" title="Relocating prvalues">[P2785R3]</a>; the only significant difference
is that <a data-link-type="biblio" href="#biblio-p2785r3" title="Relocating prvalues">[P2785R3]</a> doesn’t propose the <code class="highlight"><c- p>[[</c-><c- n>trivially_relocatable</c-><c- p>]]</c-></code> warrant itself.
(P2785 proposes that to make a type trivially relocatable, you <code class="highlight"><c- o>=</c-><c- k>default</c-></code> its relocation constructor. P1144 can’t do that, and anyway wants to support <code class="highlight"><c- n>Wrap0</c-></code> and <code class="highlight"><c- n>Wrap3</c-></code>.)</p>
   <p><small></small></p>
   <small> <table> <tbody><tr><th>P1144</th><th>P2785R3</th></tr> <tr><td><code class="highlight"><c- p>[[</c-><c- n>trivially_relocatable</c-><c- p>]]</c-></code></td><td></td></tr> <tr><td></td><td><code class="highlight"><c- n>T</c-><c- p>(</c-><c- n>T</c-><c- p>)</c-> <c- o>=</c-> <c- k>default</c-><c- p>;</c-></code></td></tr> <tr><td></td><td><code class="highlight"><c- n>T</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>=</c-><c- p>(</c-><c- n>T</c-><c- p>)</c-> <c- o>=</c-> <c- k>default</c-><c- p>;</c-></code></td></tr> <tr><td>QoI <code class="highlight"><c- p>[[</c-><c- n>trivially_relocatable</c-><c- p>]]</c-></code><br>on STL containers</td><td>Mandate relocation ctors<br>for all STL containers</td></tr> <tr><td></td><td><code class="highlight"><c- n>T</c-> <c- n>t</c-> <c- o>=</c-> <c- n>reloc</c-> <c- n>u</c-><c- p>;</c-></code> (ends <code class="highlight"><c- n>u</c-></code>’s lifetime)</td></tr> <tr><td><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>is_trivially_relocatable_v</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code></td><td><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>is_trivially_relocatable_v</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code></td></tr> <tr><td><code class="highlight"><c- k>concept</c-> <c- nc>std</c-><c- o>::</c-><c- n>relocatable</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code></td><td></td></tr> <tr><td><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>relocate_at</c-><c- p>(</c-><c- n>psrc</c-><c- p>,</c-> <c- n>pdst</c-><c- p>);</c-></code></td><td><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>construct_at</c-><c- p>(</c-><c- n>pdst</c-><c- p>,</c-> <c- n>reloc</c-> <c- o>*</c-><c- n>psrc</c-><c- p>);</c-></code></td></tr> <tr><td><code class="highlight"><c- n>T</c-> <c- n>t</c-> <c- o>=</c-> <c- n>std</c-><c- o>::</c-><c- n>relocate</c-><c- p>(</c-><c- n>psrc</c-><c- p>);</c-></code></td><td><code class="highlight"><c- n>T</c-> <c- n>t</c-> <c- o>=</c-> <c- n>std</c-><c- o>::</c-><c- n>destroy_relocate</c-><c- p>(</c-><c- n>psrc</c-><c- p>);</c-></code></td></tr> <tr><td><code class="highlight"><c- n>FwdIt</c-> <c- n>std</c-><c- o>::</c-><c- n>uninitialized_relocate</c-><c- p>(</c-><br>  <c- n>InIt</c-><c- p>,</c-> <c- n>InIt</c-><c- p>,</c-> <c- n>FwdIt</c-><c- p>)</c-></code></td><td><code class="highlight"><c- n>FwdIt</c-> <c- n>std</c-><c- o>::</c-><c- n>uninitialized_relocate</c-><c- p>(</c-><br>  <c- n>InIt</c-><c- p>,</c-> <c- n>InIt</c-><c- p>,</c-> <c- n>FwdIt</c-><c- p>)</c-></code></td></tr> <tr><td><code class="highlight"><c- n>pair</c-><c- o>&lt;</c-><c- n>InIt</c-><c- p>,</c-> <c- n>FwdIt</c-><c- o>></c-> <c- n>std</c-><c- o>::</c-><c- n>uninitialized_relocate_n</c-><c- p>(</c-><br>  <c- n>InIt</c-><c- p>,</c-> <c- n>Size</c-><c- p>,</c-> <c- n>FwdIt</c-><c- p>)</c-></code></td><td><code class="highlight"><c- n>pair</c-><c- o>&lt;</c-><c- n>InIt</c-><c- p>,</c-> <c- n>FwdIt</c-><c- o>></c-> <c- n>std</c-><c- o>::</c-><c- n>uninitialized_relocate_n</c-><c- p>(</c-><br>  <c- n>InIt</c-><c- p>,</c-> <c- n>Size</c-><c- p>,</c-> <c- n>FwdIt</c-><c- p>)</c-></code></td></tr> <tr><td><code class="highlight"><c- n>Bidi2</c-> <c- n>std</c-><c- o>::</c-><c- n>uninitialized_relocate_backward</c-><c- p>(</c-><br>  <c- n>Bidi1</c-><c- p>,</c-> <c- n>Bidi1</c-><c- p>,</c-> <c- n>Bidi2</c-><c- p>)</c-></code></td><td></td></tr> <tr><td></td><td><code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>relocate_t</c-></code>, <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>relocate</c-></code> tag type</td></tr> <tr><td></td><td><code class="highlight"><c- n>vector</c-><c- o>&lt;</c-><c- n>T</c-><c- o>>::</c-><c- n>relocate_out</c-><c- p>(</c-><br>  <c- n>const_iterator</c-><c- p>,</c-> <c- n>const_iterator</c-><c- p>,</c-> <c- n>OutIt</c-><c- p>)</c-> <c- n>etc</c-><c- p>.</c-></code></td></tr> <tr><td></td><td><code class="highlight"><c- n>T</c-> <c- n>queue</c-><c- o>&lt;</c-><c- n>T</c-><c- o>>::</c-><c- n>pop</c-><c- p>(</c-><c- n>relocate_t</c-><c- p>)</c-></code> etc.</td></tr> </tbody></table> </small> 
   <h2 class="heading settled" data-level="4" id="wording"><span class="secno">4. </span><span class="content">Proposed wording for C++26</span><a class="self-link" href="#wording"></a></h2>
   <p>The wording in this section is relative to the current working draft.</p>
   <p class="note" role="note"><span class="marker">Note:</span> There is no difficulty in changing the attribute syntax to a contextual-keyword syntax;
the only difference is aesthetic. We can defer that decision to the last minute. This wording
is patterned on the precedent set by <code class="highlight"><c- p>[[</c-><c- n>no_unique_address</c-><c- p>]]</c-></code>.</p>
   <p class="note" role="note"><span class="marker">Note:</span> Our feature-test macros follow the pattern set by <code class="highlight"><c- n>__cpp_impl_coroutine</c-></code>+<code class="highlight"><c- n>__cpp_lib_coroutine</c-></code> and <code class="highlight"><c- n>__cpp_impl_three_way_comparison</c-></code>+<code class="highlight"><c- n>__cpp_lib_three_way_comparison</c-></code>.</p>
   <h3 class="heading settled" data-level="4.1" id="wording-cpp.predefined"><span class="secno">4.1. </span><span class="content">Predefined macro names [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="4.2" id="wording-version.syn"><span class="secno">4.2. </span><span class="content">Header <code class="highlight"><c- o>&lt;</c-><c- n>version</c-><c- o>></c-></code> synopsis [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="4.3" id="wording-defns.relocation"><span class="secno">4.3. </span><span class="content">Relocation operation [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="4.4" id="wording-class.prop"><span class="secno">4.4. </span><span class="content">Trivially relocatable class [class.prop]</span><a class="self-link" href="#wording-class.prop"></a></h3>
   <p class="note" role="note"><span class="marker">Note:</span> 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>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 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="4.5" id="wording-basic.types.general"><span class="secno">4.5. </span><span class="content">Trivially relocatable type [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 ([defns.relocation]) 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 intended that most standard library types be 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="4.6" id="wording-dcl.attr.trivreloc"><span class="secno">4.6. </span><span class="content">Trivially relocatable attribute [dcl.attr.trivreloc]</span><a class="self-link" href="#wording-dcl.attr.trivreloc"></a></h3>
   <p class="note" role="note"><span class="marker">Note:</span> 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>
   <h4 class="heading settled" data-level="4.6.1" id="wording-cpp.cond"><span class="secno">4.6.1. </span><span class="content"><code class="highlight"><c- n>__has_cpp_attribute</c-></code> entry [cpp.cond]</span><a class="self-link" href="#wording-cpp.cond"></a></h4>
   <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="4.7" id="wording-concept.relocatable"><span class="secno">4.7. </span><span class="content"><code class="highlight"><c- n>relocatable</c-></code> concept [concept.relocatable]</span><a class="self-link" href="#wording-concept.relocatable"></a></h3>
   <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 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>
   <p class="note" role="note"><span class="marker">Note:</span> 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>
   <h3 class="heading settled" data-level="4.8" id="wording-meta.unary.prop"><span class="secno">4.8. </span><span class="content">Type trait <code class="highlight"><c- n>is_trivially_relocatable</c-></code> [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="4.9" id="wording-specialized.relocate"><span class="secno">4.9. </span><span class="content"><code class="highlight"><c- n>relocate_at</c-></code> and <code class="highlight"><c- n>relocate</c-></code></span><a class="self-link" href="#wording-specialized.relocate"></a></h3>
   <p class="note" role="note"><span class="marker">Note:</span> These functions have both been implemented in my libc++ fork; for <code class="highlight"><c- n>relocate</c-></code>, see <a href="https://p1144.godbolt.org/z/MqPjWfe3e">this Godbolt</a> and <a data-link-type="biblio" href="#biblio-stdrelocateiscute" title="std::relocate&apos;s implementation is cute">[StdRelocateIsCute]</a>. My implementation of their "as-if-by-memcpy" codepaths relies on
Clang’s <code class="highlight"><c- n>__builtin_memmove</c-></code>; vendors can use any vendor-specific means to implement them.
The wording also deliberately permits a low-quality implementation with no such codepath at all.
See <a data-link-type="biblio" href="#biblio-cppnow" title="Trivially Relocatable (C++Now 2019)">[CppNow]</a> <a href="https://www.youtube.com/watch?v=SGdfPextuAU&amp;t=45m23s">@45:23–48:39</a>.</p>
   <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><ins>except that if <code class="highlight"><c- n>T</c-></code> is trivially relocatable ([basic.types.general]), side effects
associated with the relocation of the value of <code class="highlight"><c- o>*</c-><c- n>source</c-></code> might not happen.</ins> <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- p>[[</c-><c- n>nodiscard</c-><c- p>]]</c-> <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;&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><ins>except that if <code class="highlight"><c- n>T</c-></code> is trivially relocatable ([basic.types]), side effects
associated with the relocation of the object’s value might not happen.</ins> </small>
   </blockquote>
   <h3 class="heading settled" data-level="4.10" id="wording-algorithms.requirements"><span class="secno">4.10. </span><span class="content">Nothrow bidirectional iterator [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>ForwardIterator</c-></code>, <code class="highlight"><c- n>ForwardIterator1</c-></code>, <code class="highlight"><c- n>ForwardIterator2</c-></code>, or <code class="highlight"><c- n>NoThrowForwardIterator</c-></code>,
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 <code class="highlight"><c- n>NoThrowForwardIterator</c-></code>, 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>or <code class="highlight"><c- n>NoThrowBidirectionalIterator</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>NoThrowBidirectionalIterator</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="4.11" id="wording-uninitialized.relocate"><span class="secno">4.11. </span><span class="content"><code class="highlight"><c- n>uninitialized_relocate</c-></code>, <code class="highlight"><c- n>uninitialized_relocate_n</c-></code>, <code class="highlight"><c- n>uninitialized_relocate_backward</c-></code> [uninitialized.relocate]</span><a class="self-link" href="#wording-uninitialized.relocate"></a></h3>
   <p class="note" role="note"><span class="marker">Note:</span> 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 class="note" role="note"><span class="marker">Note:</span> I don’t propose <code class="highlight"><c- n>ranges</c-><c- o>::</c-><c- n>uninitialized_relocate</c-></code>, because if it worked like <code class="highlight"><c- n>ranges</c-><c- o>::</c-><c- n>uninitialized_move</c-></code> then it would take two ranges (of possibly different lengths). On success, it would relocate-out-of only <code class="highlight"><c- n>distance</c-><c- p>(</c-><c- n>OR</c-><c- p>)</c-></code> elements of <code class="highlight"><c- n>IR</c-></code>; but if an exception were thrown, it would destroy all the elements of <code class="highlight"><c- n>IR</c-></code>.
That’s a bad contract. Therefore, we omit the <code class="highlight"><c- n>ranges</c-></code> overloads until someone presents a suitable design.</p>
   <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>InputIterator</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>InputIterator</c-> <c- n>first</c-><c- p>,</c-></ins>
                                                <ins><c- n>InputIterator</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>ForwardIterator</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>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>ForwardIterator</c-> <c- n>first</c-><c- p>,</c-> <c- n>ForwardIterator</c-> <c- n>last</c-><c- p>,</c-></ins>
                                                <ins><c- n>NoThrowForwardIterator</c-> <c- n>result</c-><c- p>);</c-></ins>

<ins><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-></ins>
  <ins><c- n>pair</c-><c- o>&lt;</c-><c- n>InputIterator</c-><c- p>,</c-> <c- n>NoThrowForwardIterator</c-><c- o>></c-></ins>
    <ins><c- n>uninitialized_relocate_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-></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>ForwardIterator</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Size</c-><c- p>,</c-></ins>
         <ins><c- k>class</c-> <c- nc>NoThrowForwardIterator</c-><c- o>></c-></ins>
  <ins><c- n>pair</c-><c- o>&lt;</c-><c- n>ForwardIterator</c-><c- p>,</c-> <c- n>NoThrowForwardIterator</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>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-></ins>

<ins><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>BidirectionalIterator</c-><c- p>,</c-> <c- k>class</c-> <c- nc>NoThrowBidirectionalIterator</c-><c- o>></c-></ins>
  <ins><c- n>NoThrowBidirectionalIterator</c-></ins>
    <ins><c- n>uninitialized_relocate_backward</c-><c- p>(</c-><c- n>BidirectionalIterator</c-> <c- n>first</c-><c- p>,</c-> <c- n>BidirectionalIterator</c-> <c- n>last</c-><c- p>,</c-></ins>
                                    <ins><c- n>NoThrowBidirectionalIterator</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>BidirectionalIterator</c-><c- p>,</c-> <c- k>class</c-> <c- nc>NoThrowBidirectionalIterator</c-><c- o>></c-></ins>
  <ins><c- n>NoThrowBidirectionalIterator</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>BidirectionalIterator</c-> <c- n>first</c-><c- p>,</c-> <c- n>BidirectionalIterator</c-> <c- n>last</c-><c- p>,</c-></ins>
                                    <ins><c- n>NoThrowBidirectionalIterator</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->

</pre></small>
   </blockquote>
   <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>InputIterator</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>InputIterator</c-> <c- n>first</c-><c- p>,</c-> <c- n>InputIterator</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><ins>except that if the iterators' common value type is trivially relocatable, side effects
associated with the relocation of the object’s value might not happen.</ins> <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>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-></ins>
  <ins><c- n>pair</c-><c- o>&lt;</c-><c- n>InputIterator</c-><c- p>,</c-> <c- n>NoThrowForwardIterator</c-><c- o>></c-></ins>
    <ins><c- n>uninitialized_relocate_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- 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><ins>except that if the iterators' common value type is trivially relocatable, side effects
associated with the relocation of the object’s value might not happen.</ins> <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>BidirectionalIterator</c-><c- p>,</c-> <c- k>class</c-> <c- nc>NoThrowBidirectionalIterator</c-><c- o>></c-></ins>
  <ins><c- n>NoThrowBidirectionalIterator</c-></ins>
    <ins><c- n>uninitialized_relocate_backward</c-><c- p>(</c-><c- n>BidirectionalIterator</c-> <c- n>first</c-><c- p>,</c-> <c- n>BidirectionalIterator</c-> <c- n>last</c-><c- p>,</c-></ins>
                                    <ins><c- n>NoThrowBidirectionalIterator</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>NoThrowBidirectionalIterator</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><ins>except that if the iterators' common value type is trivially relocatable, side effects
associated with the relocation of the object’s value might not happen.</ins> <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>
   <h2 class="heading settled" data-level="5" id="alternatives"><span class="secno">5. </span><span class="content">Rationale and alternatives</span><a class="self-link" href="#alternatives"></a></h2>
   <h3 class="heading settled" data-level="5.1" id="maybe-trivially-relocatable"><span class="secno">5.1. </span><span class="content">Attribute <code class="highlight"><c- p>[[</c-><c- n>maybe_trivially_relocatable</c-><c- p>]]</c-></code></span><a class="self-link" href="#maybe-trivially-relocatable"></a></h3>
   <p>My Clang implementation, currently available on Godbolt, supports both <code class="highlight"><c- p>[[</c-><c- n>trivially_relocatable</c-><c- p>]]</c-></code> and another attribute called <code class="highlight"><c- p>[[</c-><c- n>clang</c-><c- o>::</c-><c- n>maybe_trivially_relocatable</c-><c- p>]]</c-></code>,
as suggested by John McCall in 2018 and also explored by <a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2786r0.pdf">P2786R0</a> in 2023.
Where <code class="highlight"><c- p>[[</c-><c- n>trivially_relocatable</c-><c- p>]]</c-></code> is a "sharp knife" that always cuts what you aim it at, <code class="highlight"><c- p>[[</c-><c- n>maybe_trivially_relocatable</c-><c- p>]]</c-></code> is a "dull knife" that refuses to cut certain materials.</p>
   <ul>
    <li data-md>
     <p><code class="highlight"><c- p>[[</c-><c- n>maybe_trivially_relocatable</c-><c- p>]]</c-></code> fails to support <a href="#design-goals">§ 3 Design goals</a> examples #4 and #5.</p>
    <li data-md>
     <p>See <a href="https://quuxplusone.github.io/blog/2023/03/10/sharp-knife-dull-knife/">"Should the compiler sometimes reject a <code class="highlight"><c- p>[[</c-><c- n>trivially_relocatable</c-><c- p>]]</c-></code> warrant?"</a> (2023-03-10).</p>
    <li data-md>
     <p>See <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p1144r4.html#maybe-trivially-relocatable">P1144R4 §6.2</a>.</p>
   </ul>
   <p>In Issaquah (February 2023), <a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2786r0.pdf">P2786R0</a> suggested a "dull knife" design similar to <code class="highlight"><c- p>[[</c-><c- n>clang</c-><c- o>::</c-><c- n>maybe_trivially_relocatable</c-><c- p>]]</c-></code>.
EWGI took a three-way straw poll on <code class="highlight"><c- p>[[</c-><c- n>trivially_relocatable</c-><c- p>]]</c-></code> versus <code class="highlight"><c- p>[[</c-><c- n>maybe_trivially_relocatable</c-><c- p>]]</c-></code>,
with an inconclusive 7–5–6 vote (the author of P1144 voting "For" and the three representatives of P2786
voting "Against"; i.e. the vote sans authors was 6–5–3).</p>
   <h3 class="heading settled" data-level="5.2" id="relevance-of-assignment"><span class="secno">5.2. </span><span class="content">Relevance of <code class="highlight"><c- k>operator</c-><c- o>=</c-></code></span><a class="self-link" href="#relevance-of-assignment"></a></h3>
   <p>Here’s how current implementations define "is trivially relocatable":</p>
   <p><small></small></p>
   <small> <ul><li data-md><p>Mainline Clang <code class="highlight"><c- n>__is_trivially_relocatable</c-><c- p>(</c-><c- n>T</c-><c- p>)</c-></code>: Trivially move-constructible and trivially destructible, or has <code class="highlight"><c- p>[[</c-><c- n>clang</c-><c- o>::</c-><c- n>trivial_abi</c-><c- p>]]</c-></code></p> </li><li data-md><p>Arthur’s Clang (P1144) <code class="highlight"><c- n>__is_trivially_relocatable</c-><c- p>(</c-><c- n>T</c-><c- p>)</c-></code>: Trivially copyable, or has <code class="highlight"><c- p>[[</c-><c- n>clang</c-><c- o>::</c-><c- n>trivial_abi</c-><c- p>]]</c-></code>, or has <code class="highlight"><c- p>[[</c-><c- n>trivially_relocatable</c-><c- p>]]</c-></code></p> </li><li data-md><p>Facebook <a data-link-type="biblio" href="#biblio-folly" title="Folly documentation on &quot;Object Relocation&quot;">[Folly]</a>'s <code class="highlight"><c- n>folly</c-><c- o>::</c-><c- n>IsRelocatable</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code>: <code class="highlight"><c- n>is_trivially_copyable</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code> or has member typedef <code class="highlight"><c- n>T</c-><c- o>::</c-><c- n>IsRelocatable</c-></code></p> </li><li data-md><p>Bloomberg <a data-link-type="biblio" href="#biblio-bsl" title="bslmf::IsBitwiseMoveable: bitwise moveable trait metafunction">[BSL]</a>'s <code class="highlight"><c- n>bslmf</c-><c- o>::</c-><c- n>IsBitwiseMoveable</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code>: Has a conversion to <code class="highlight"><c- n>bslmf</c-><c- o>::</c-><c- n>NestedTraitDeclaration</c-><c- o>&lt;</c-><c- n>T</c-><c- p>,</c-> <c- n>bslmf</c-><c- o>::</c-><c- n>IsBitwiseMoveable</c-><c- p>,</c-> true<c- o>></c-></code>,
or has a conversion to <code class="highlight"><c- n>bslmf</c-><c- o>::</c-><c- n>NestedTraitDeclaration</c-><c- o>&lt;</c-><c- n>T</c-><c- p>,</c-> <c- n>bslmf</c-><c- o>::</c-><c- n>IsBitwiseCopyable</c-><c- p>,</c-> true<c- o>></c-></code>, or <code class="highlight"><c- n>is_trivially_copyable</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code>,
or <code class="highlight"><c- k>sizeof</c-><c- p>(</c-><c- n>T</c-><c- p>)</c-> <c- o>==</c-> <c- mi>1</c-></code></p> </li><li data-md><p>Google <a data-link-type="biblio" href="#biblio-abseil" title="Abseil C++ Common Libraries">[Abseil]</a>'s <code class="highlight"><c- n>absl</c-><c- o>::</c-><c- n>is_trivially_relocatable</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code>: <code class="highlight"><c- n>is_trivially_copyable</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code>, or <code class="highlight"><c- n>__is_trivially_relocatable</c-><c- p>(</c-><c- n>T</c-><c- p>)</c-></code> on Linux Clang (not Windows or Apple);
after <a href="https://github.com/abseil/abseil-cpp/pull/1625">#1625</a> it’ll be "<code class="highlight"><c- n>is_trivially_copyable</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code>"</p> </li><li data-md><p><a data-link-type="biblio" href="#biblio-amadeus" title="AMadeus (C++) Containers">[Amadeus]</a> AMC’s <code class="highlight"><c- n>amc</c-><c- o>::</c-><c- n>is_trivially_relocatable</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code>: <code class="highlight"><c- n>is_trivially_copyable</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code> or has member typedef <code class="highlight"><c- n>T</c-><c- o>::</c-><c- n>trivially_relocatable</c-></code></p> </li><li data-md><p>Nvidia <a data-link-type="biblio" href="#biblio-thrust" title="Nvidia Thrust">[Thrust]</a>'s <code class="highlight"><c- n>thrust</c-><c- o>::</c-><c- n>is_trivially_relocatable</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code>: <code class="highlight"><c- n>is_trivially_copyable</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code>, or <code class="highlight"><c- n>proclaim_trivially_relocatable</c-></code> is specialized for <code class="highlight"><c- n>T</c-></code></p> </li><li data-md><p><a data-link-type="biblio" href="#biblio-hpx" title="Relocation Semantics in the HPX Library">[HPX]</a>'s <code class="highlight"><c- n>hpx</c-><c- o>::</c-><c- n>experimental</c-><c- o>::</c-><c- n>is_trivially_relocatable</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code>: <code class="highlight"><c- n>is_trivially_copyable</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code>, or the trait is specialized for <code class="highlight"><c- n>T</c-></code></p> </li><li data-md><p><a data-link-type="biblio" href="#biblio-parlaylib" title="ParlayLib, a toolkit for programming parallel algorithms on shared-memory multicore machines">[ParlayLib]</a>'s <code class="highlight"><c- n>parlay</c-><c- o>::</c-><c- n>is_trivially_relocatable</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code>: currently "<code class="highlight"><c- n>is_trivially_move_constructible_v</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- n>is_trivially_destructible_v</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code>,"
but after <a href="https://github.com/cmuparlay/parlaylib/pull/67">#67</a> it’ll be "<code class="highlight"><c- n>is_trivially_copyable</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code>, or the trait is specialized for <code class="highlight"><c- n>T</c-></code>"</p> </li></ul> </small>
   <p><small></small></p>
   <p>Notice that all library implementors (except ParlayLib trunk and Abseil on Linux Clang due to the Clang builtin’s
current behavior) agree that a type with trivial move-constructor, trivial destructor, <em>and non-trivial assignment operator</em> is considered non-trivially relocatable. That is, the assignment operator is relevant!</p>
   <p>P1144 preserves that behavior, and justifies it by pointing out that relocation
can replace assignment in <code class="highlight"><c- n>vector</c-><c- o>::</c-><c- n>erase</c-></code> and <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>swap</c-></code>, among other algorithms. Existing codebases (most notably <a data-link-type="biblio" href="#biblio-folly" title="Folly documentation on &quot;Object Relocation&quot;">[Folly]</a>, <a data-link-type="biblio" href="#biblio-amadeus" title="AMadeus (C++) Containers">[Amadeus]</a>, and <a data-link-type="biblio" href="#biblio-bsl" title="bslmf::IsBitwiseMoveable: bitwise moveable trait metafunction">[BSL]</a>)
have written a lot of code that branches on <code class="highlight"><c- n>is_trivially_relocatable</c-></code>, taking an optimized codepath when <code class="highlight"><c- n>is_trivially_relocatable</c-></code> and an unoptimized codepath otherwise. P1144 carefully proposes a definition for <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>is_trivially_relocatable</c-></code> that keeps
those codebases safe, and that never reports a type <code class="highlight"><c- n>T</c-></code> as <code class="highlight"><c- n>is_trivially_relocatable</c-></code> when it’s not physically safe
to use <code class="highlight"><c- n>T</c-></code> with such an optimized codepath.</p>
   <p>Here’s a worked example showing why <a data-link-type="biblio" href="#biblio-bsl" title="bslmf::IsBitwiseMoveable: bitwise moveable trait metafunction">[BSL]</a> pays attention to the assignment operator:</p>
   <p><small></small></p>
   <small> <pre class="language-cpp highlight"><c- cp>#include</c-> &lt;bsl_vector.h>
<c- k>using</c-> <c- k>namespace</c-> <c- nn>BloombergLP</c-><c- o>::</c-><c- nn>bslmf</c-><c- p>;</c->

<c- k>struct</c-> <c- nc>T</c-> <c- o>:</c-> <c- n>NestedTraitDeclaration</c-><c- o>&lt;</c-><c- n>T</c-><c- p>,</c-> <c- n>IsBitwiseMoveable</c-><c- o>></c-> <c- p>{</c->
    <c- b>int</c-> <c- n>i_</c-><c- p>;</c->
    <c- n>T</c-><c- p>(</c-><c- b>int</c-> <c- n>i</c-><c- p>)</c-> <c- o>:</c-> <c- n>i_</c-><c- p>(</c-><c- n>i</c-><c- p>)</c-> <c- p>{}</c->
    <c- n>T</c-><c- p>(</c-><c- k>const</c-> <c- n>T</c-><c- o>&amp;</c-><c- p>)</c-> <c- o>=</c-> <c- k>default</c-><c- p>;</c->
    <c- b>void</c-> <c- k>operator</c-><c- o>=</c-><c- p>(</c-><c- k>const</c-> <c- n>T</c-><c- o>&amp;</c-><c- p>)</c-> <c- k>noexcept</c-> <c- p>{</c-> <c- n>puts</c-><c- p>(</c-><c- s>"Called operator="</c-><c- p>);</c-> <c- p>}</c->
    <c- o>~</c-><c- n>T</c-><c- p>()</c-> <c- o>=</c-> <c- k>default</c-><c- p>;</c->
<c- p>};</c->
<c- b>int</c-> <c- nf>main</c-><c- p>()</c-> <c- p>{</c->
    <c- n>bsl</c-><c- o>::</c-><c- n>vector</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-> <c- n>v</c-> <c- o>=</c-> <c- p>{</c-><c- mi>1</c-><c- p>,</c-><c- mi>2</c-><c- p>};</c->
    <c- n>v</c-><c- p>.</c-><c- n>erase</c-><c- p>(</c-><c- n>v</c-><c- p>.</c-><c- n>begin</c-><c- p>());</c->
      <c- c1>// prints nothing; bsl::vector::erase is optimized</c->
<c- p>}</c->

<c- k>struct</c-> <c- nc>U</c-> <c- p>{</c->
    <c- b>int</c-> <c- n>i_</c-><c- p>;</c->
    <c- n>U</c-><c- p>(</c-><c- b>int</c-> <c- n>i</c-><c- p>)</c-> <c- o>:</c-> <c- n>i_</c-><c- p>(</c-><c- n>i</c-><c- p>)</c-> <c- p>{}</c->
    <c- n>U</c-><c- p>(</c-><c- k>const</c-> <c- n>U</c-><c- o>&amp;</c-><c- p>)</c-> <c- o>=</c-> <c- k>default</c-><c- p>;</c->
    <c- b>void</c-> <c- k>operator</c-><c- o>=</c-><c- p>(</c-><c- k>const</c-> <c- n>U</c-><c- o>&amp;</c-><c- p>)</c-> <c- k>noexcept</c-> <c- p>{</c-> <c- n>puts</c-><c- p>(</c-><c- s>"Called operator="</c-><c- p>);</c-> <c- p>}</c->
    <c- o>~</c-><c- n>U</c-><c- p>()</c-> <c- o>=</c-> <c- k>default</c-><c- p>;</c->
<c- p>};</c->
<c- b>int</c-> <c- nf>main</c-><c- p>()</c-> <c- p>{</c->
    <c- n>bsl</c-><c- o>::</c-><c- n>vector</c-><c- o>&lt;</c-><c- n>U</c-><c- o>></c-> <c- n>v</c-> <c- o>=</c-> <c- p>{</c-><c- mi>1</c-><c- p>,</c-><c- mi>2</c-><c- p>};</c->
    <c- n>v</c-><c- p>.</c-><c- n>erase</c-><c- p>(</c-><c- n>v</c-><c- p>.</c-><c- n>begin</c-><c- p>());</c->
      <c- c1>// prints "Called operator="; BSL believes that a non-defaulted</c->
      <c- c1>// assignment operator makes U non-trivially relocatable.</c->
      <c- c1>// P1144 agrees. std::is_trivially_relocatable_v&lt;U></c->
      <c- c1>// must remain false, so as not to change the</c->
      <c- c1>// behavior of bsl::vector&lt;U>.</c->
<c- p>}</c->
</pre></small>
   <p><small></small></p>
   <h3 class="heading settled" data-level="5.3" id="pmr-concerns"><span class="secno">5.3. </span><span class="content">Confusing interactions with <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>pmr</c-></code></span><a class="self-link" href="#pmr-concerns"></a></h3>
   <p class="note" role="note"><span class="marker">Note:</span> See <a href="https://quuxplusone.github.io/blog/2023/06/03/p1144-pmr-koans/">"P1144 PMR koans"</a> (June 2023)
for additional analysis of the problem cases.</p>
   <p class="note" role="note"><span class="marker">Note:</span> This section was added in P1144R5, revised in R7, R8, and R10.
Here I assume libc++, where <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>string</c-></code> is trivially relocatable.</p>
   <p>P1144 treats move as an optimization of copy; thus we assume that it always ought to be
safe to replace "copy and destroy" with "move and destroy" (and thus with "relocate").
This is informed by Arthur’s experience standardizing "implicit move" in <a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p1155r3.html">P1155</a> (C++20) and <a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/p2266r3.html">P2266</a> (C++23).
"Implicit move" affects <code class="highlight"><c- n>pmr</c-></code> types because their copy differs from their move. <a href="https://godbolt.org/z/sGKhxbsrK">Example</a>:</p>
   <p><small></small></p>
   <small> <pre class="language-cpp highlight"><c- k>struct</c-> <c- nc>ByValueSink</c-> <c- p>{</c->
    <c- n>ByValueSink</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>pmr</c-><c- o>::</c-><c- n>vector</c-><c- o>&lt;</c-><c- b>int</c-><c- o>></c-> <c- n>v</c-><c- p>)</c-> <c- o>:</c-> <c- n>v_</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>move</c-><c- p>(</c-><c- n>v</c-><c- p>))</c-> <c- p>{}</c->
    <c- n>std</c-><c- o>::</c-><c- n>pmr</c-><c- o>::</c-><c- n>vector</c-><c- o>&lt;</c-><c- b>int</c-><c- o>></c-> <c- n>v_</c-><c- p>;</c->
<c- p>};</c->

<c- n>ByValueSink</c-> <c- nf>f</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>pmr</c-><c- o>::</c-><c- n>memory_resource</c-> <c- o>*</c-><c- n>mr</c-><c- p>)</c-> <c- p>{</c->
    <c- k>auto</c-> <c- n>v</c-> <c- o>=</c-> <c- n>std</c-><c- o>::</c-><c- n>pmr</c-><c- o>::</c-><c- n>vector</c-><c- o>&lt;</c-><c- b>int</c-><c- o>></c-><c- p>(</c-><c- n>mr</c-><c- p>);</c->
    <c- k>return</c-> <c- n>v</c-><c- p>;</c->
      <c- c1>// C++17, Clang 12-: Copies (changes allocator)</c->
      <c- c1>// C++20, GCC, Clang 13+: Moves (preserves allocator)</c->
<c- p>}</c->
</pre></small>
   <p><small></small></p>
   <p>We didn’t care about this when fiddling with implicit move; P1144 implicitly believes we shouldn’t
care about it now. (This position might be debatable, but it’s definitely part of the worldview that
led to P1144’s specific proposed semantics, so it’s good to have this background in mind.)</p>
   <p>Some types invariably model <code class="highlight"><c- n>relocatable</c-></code>; that is, their assignment is naturally tantamount to construct-and-destroy.
But for <code class="highlight"><c- n>pmr</c-></code> types and polymorphic types, assignment is <em>not</em> tantamount to construct-and-destroy, <em>except</em> under certain conditions. For <code class="highlight"><c- n>pmr</c-></code> types, the condition is "both objects have the same
allocator." For polymorphic types, the condition is "both objects have the same dynamic type."</p>
<pre class="language-cpp highlight"><c- n>std</c-><c- o>::</c-><c- n>vector</c-><c- o>&lt;</c-><c- n>Derived</c-><c- o>></c-> <c- n>dv</c-> <c- o>=</c-> <c- p>{</c-> <c- o>~~~</c-> <c- p>};</c->
<c- n>dv</c-><c- p>.</c-><c- n>erase</c-><c- p>(</c-><c- n>dv</c-><c- p>.</c-><c- n>begin</c-><c- p>());</c->
  <c- c1>// Every object in the vector certainly has the same dynamic type.</c->

<c- n>std</c-><c- o>::</c-><c- n>pmr</c-><c- o>::</c-><c- n>vector</c-><c- o>&lt;</c-><c- n>std</c-><c- o>::</c-><c- n>pmr</c-><c- o>::</c-><c- n>string</c-><c- o>></c-> <c- n>pv</c-> <c- o>=</c-> <c- p>{</c-> <c- o>~~~</c-> <c- p>};</c->
<c- n>pv</c-><c- p>.</c-><c- n>erase</c-><c- p>(</c-><c- n>pv</c-><c- p>.</c-><c- n>begin</c-><c- p>());</c->
  <c- c1>// Every string in the vector certainly has the same allocator.</c->

<c- n>Derived</c-> <c- n>da</c-><c- p>[</c-><c- mi>5</c-><c- p>]</c-> <c- o>=</c-> <c- p>{</c-> <c- o>~~~</c-> <c- p>};</c->
<c- n>std</c-><c- o>::</c-><c- n>rotate</c-><c- p>(</c-><c- n>da</c-><c- p>,</c-> <c- n>da</c-><c- o>+</c-><c- mi>2</c-><c- p>,</c-> <c- n>da</c-><c- o>+</c-><c- mi>5</c-><c- p>);</c->
  <c- c1>// Every object in the contiguous range certainly has the same dynamic type.</c->

<c- n>std</c-><c- o>::</c-><c- n>pmr</c-><c- o>::</c-><c- n>string</c-> <c- n>pa</c-><c- p>[</c-><c- mi>5</c-><c- p>]</c-> <c- o>=</c-> <c- p>{</c-> <c- o>~~~</c-> <c- p>};</c->
<c- n>std</c-><c- o>::</c-><c- n>rotate</c-><c- p>(</c-><c- n>pa</c-><c- p>,</c-> <c- n>pa</c-><c- o>+</c-><c- mi>2</c-><c- p>,</c-> <c- n>pa</c-><c- o>+</c-><c- mi>5</c-><c- p>);</c->
  <c- c1>// Objects in the contiguous range might have different allocators?</c->
</pre>
   <p>P1144 aims to permit efficient insertion and erasure in <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>vector</c-></code>. <a href="https://p1144.godbolt.org/z/vv5q69q44">Example:</a></p>
<pre class="language-cpp highlight"><c- n>std</c-><c- o>::</c-><c- n>vector</c-><c- o>&lt;</c-><c- n>std</c-><c- o>::</c-><c- n>string</c-><c- o>></c-> <c- n>vs</c-><c- p>(</c-><c- mi>501</c-><c- p>);</c->
<c- n>vs</c-><c- p>.</c-><c- n>erase</c-><c- p>(</c-><c- n>vs</c-><c- p>.</c-><c- n>begin</c-><c- p>());</c->
</pre>
   <p>This <code class="highlight"><c- n>erase</c-></code> requires us to shift down 500 <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>string</c-></code> objects. We can do this
by 500 calls to <code class="highlight"><c- n>string</c-><c- o>::</c-><c- k>operator</c-><c- o>=</c-></code> followed by one call to <code class="highlight"><c- o>~</c-><c- n>string</c-></code>, or by
one call to <code class="highlight"><c- o>~</c-><c- n>string</c-></code> followed by a <code class="highlight"><c- n>memmove</c-></code>, as in <a data-link-type="biblio" href="#biblio-bsl" title="bslmf::IsBitwiseMoveable: bitwise moveable trait metafunction">[BSL]</a> (also <a data-link-type="biblio" href="#biblio-folly" title="Folly documentation on &quot;Object Relocation&quot;">[Folly]</a>, <a data-link-type="biblio" href="#biblio-amadeus" title="AMadeus (C++) Containers">[Amadeus]</a>;
see <a href="#applications">table §2.1</a>). We want to permit BSL’s implementation.
That’s why the definition of <code class="highlight"><c- k>concept</c-> <c- nc>relocatable</c-></code> in <a href="#wording-concept.relocatable">§4.8</a> places semantic requirements on <code class="highlight"><c- n>T</c-></code>’s assignment operators (if they exist) as well as on <code class="highlight"><c- n>T</c-></code>’s constructors and destructors.</p>
   <p>If <code class="highlight"><c- n>pmr</c-><c- o>::</c-><c- n>string</c-></code> is considered trivially relocatable, this will trickle down into all Rule-of-Zero
types with a <code class="highlight"><c- n>pmr</c-><c- o>::</c-><c- n>string</c-></code> member. (<a href="https://godbolt.org/z/nhf38n33G">Godbolt.</a>)</p>
<pre class="language-cpp highlight"><c- k>static_assert</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>is_trivially_relocatable_v</c-><c- o>&lt;</c-><c- n>std</c-><c- o>::</c-><c- n>pmr</c-><c- o>::</c-><c- n>string</c-><c- o>></c-><c- p>);</c->
  <c- c1>// Before: not true, of course</c->
  <c- c1>// After: suppose this is true</c->
<c- k>struct</c-> <c- nc>A</c-> <c- p>{</c->
  <c- n>std</c-><c- o>::</c-><c- n>pmr</c-><c- o>::</c-><c- n>string</c-> <c- n>ps</c-><c- p>;</c->
<c- p>};</c->
<c- k>static_assert</c-><c- p>(</c-><c- n>std</c-><c- o>::</c-><c- n>is_trivially_relocatable_v</c-><c- o>&lt;</c-><c- n>A</c-><c- o>></c-><c- p>);</c->
  <c- c1>// After: then this will also be true, by the Rule of Zero</c->
<c- n>std</c-><c- o>::</c-><c- n>vector</c-><c- o>&lt;</c-><c- n>A</c-><c- o>></c-> <c- n>v</c-><c- p>;</c->
<c- n>v</c-><c- p>.</c-><c- n>push_back</c-><c- p>({</c-><c- n>std</c-><c- o>::</c-><c- n>pmr</c-><c- o>::</c-><c- n>string</c-><c- p>(</c-><c- s>"one"</c-><c- p>,</c-> <c- o>&amp;</c-><c- n>mr1</c-><c- p>)});</c->
<c- n>v</c-><c- p>.</c-><c- n>push_back</c-><c- p>({</c-><c- n>std</c-><c- o>::</c-><c- n>pmr</c-><c- o>::</c-><c- n>string</c-><c- p>(</c-><c- s>"two"</c-><c- p>,</c-> <c- o>&amp;</c-><c- n>mr2</c-><c- p>)});</c->
<c- n>v</c-><c- p>.</c-><c- n>erase</c-><c- p>(</c-><c- n>v</c-><c- p>.</c-><c- n>begin</c-><c- p>());</c->
  <c- c1>// Before: Well-defined behavior, acts as-if by assignment</c->
  <c- c1>// After: Do we somehow make this a precondition violation?</c->
<c- n>assert</c-><c- p>(</c-><c- n>v</c-><c- p>[</c-><c- mi>0</c-><c- p>].</c-><c- n>ps</c-><c- p>.</c-><c- n>get_allocator</c-><c- p>().</c-><c- n>resource</c-><c- p>()</c-> <c- o>==</c-> <c- o>&amp;</c-><c- n>mr1</c-><c- p>);</c->
  <c- c1>// Before: Succeeds</c->
  <c- c1>// After: Might fail (and on a quality implementation, *will* fail)</c->
</pre>
   <p>If we (1) advertise <code class="highlight"><c- n>pmr</c-><c- o>::</c-><c- n>string</c-></code> as <code class="highlight"><c- n>is_trivially_relocatable</c-></code>; (2) propagate
trivial relocatability in the core language as both P1144 and P2786 propose to do; and
(3) optimize vector insert and erase for trivially relocatable types; then we inevitably
arrive here. Arthur’s solution is to impose preconditions on user-defined types
used within certain parts of the STL: Just as their destructors are forbidden to (dynamically)
throw exceptions, and their copy constructors are forbidden to (dynamically) make things that aren’t copies,
their assignment operators ought to be forbidden to (dynamically) violate <code class="highlight"><c- k>concept</c-> <c- nc>relocatable</c-></code>’s semantic requirements.</p>
   <p>The proximate conclusion, as far as P1144 is concerned, is that <code class="highlight"><c- n>pmr</c-><c- o>::</c-><c- n>string</c-></code> should not be warranted trivially relocatable by any library vendor <em>unless</em> they’re
willing to place preconditions on how the user can use it in STL containers and algorithms
(which probably wouldn’t be conforming, before further evolution in this space).</p>
   <p>The further evolution is out of scope for P1144, but see <a data-link-type="biblio" href="#biblio-p2959r0" title="Relocation within containers">[P2959R0]</a> for further elaboration
of the problem, and <a data-link-type="biblio" href="#biblio-p3055r1" title="Relax wording to permit relocation optimizations in the STL">[P3055R1]</a> for a proposed solution.</p>
   <h2 class="heading settled" data-level="6" id="acknowledgements"><span class="secno">6. </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 paper 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-p2786r2" title="Trivial relocatability options">[P2786R2]</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>Thanks to Nicolas Lesser and John McCall for their review comments on the Clang implementation <a data-link-type="biblio" href="#biblio-d50119" title="Compiler support for P1144R0 __is_trivially_relocatable(T)">[D50119]</a>.</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 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>, 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,
to Giuseppe D’Angelo and Thiago Maceira for contributing the Qt entries in <a href="#applications">table §2.1</a>,
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.</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-2023-02-10"><span class="content">Polls taken at 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> — 
   </table>
   <h3 class="heading settled" id="taken-polls-2020-02-13"><span class="content">Polls taken at 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>
   <h2 class="heading settled" id="samples"><span class="content">Appendix B: Sample code</span><a class="self-link" href="#samples"></a></h2>
   <p>See <a data-link-type="biblio" href="#biblio-p1144r6" title="Object relocation in terms of move plus destroy">[P1144R6]</a>'s Appendix B for reference implementations of <code class="highlight"><c- n>relocate</c-></code>, <code class="highlight"><c- n>relocate_at</c-></code>, and
P1144R6’s version of the <code class="highlight"><c- n>uninitialized_relocate</c-></code> library algorithm, plus
a conditionally trivially relocatable <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>optional</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code>.</p>
   <h2 class="heading settled" id="non-trivial-samples"><span class="content">Appendix C: Examples of non-trivially relocatable class types</span><a class="self-link" href="#non-trivial-samples"></a></h2>
   <p>See <a data-link-type="biblio" href="#biblio-p1144r6" title="Object relocation in terms of move plus destroy">[P1144R6]</a>'s Appendix C for compilable examples of types that are <em>not</em> trivially relocatable,
for each of the following reasons:</p>
   <ul>
    <li data-md>
     <p>Class contains pointer to self (e.g. libstdc++'s <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>string</c-></code>)</p>
    <li data-md>
     <p>Allocated memory contains pointer to self (e.g. libstdc++'s <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>list</c-></code>)</p>
    <li data-md>
     <p>Class invariant depends on <code class="highlight"><c- k>this</c-></code> (e.g. <a href="https://www.boost.org/doc/libs/1_67_0/doc/html/interprocess/offset_ptr.html"><code class="highlight"><c- n>boost</c-><c- o>::</c-><c- n>interprocess</c-><c- o>::</c-><c- n>offset_ptr</c-></code></a>)</p>
    <li data-md>
     <p>Program invariant depends on <code class="highlight"><c- k>this</c-></code> (e.g. a global registry of <code class="highlight"><c- n>Widget</c-></code> addresses)</p>
    <li data-md>
     <p>Polymorphic object effectively relies on offset-into-self (see also <a data-link-type="biblio" href="#biblio-polymorphic" title="Polymorphic types aren&apos;t trivially relocatable">[Polymorphic]</a>)</p>
   </ul>
   <h2 class="heading settled" id="implementation"><span class="content">Appendix D: Implementation experience</span><a class="self-link" href="#implementation"></a></h2>
   <h3 class="heading settled" id="implementation-core"><span class="content">Core-language implementations</span><a class="self-link" href="#implementation-core"></a></h3>
   <p>Clang trunk provides a compiler builtin <code class="highlight"><c- n>__is_trivially_relocatable</c-><c- p>(</c-><c- n>T</c-><c- p>)</c-></code> (see <a data-link-type="biblio" href="#biblio-d114732" title="[clang] Mark trivial_abi types as trivially relocatable">[D114732]</a>), which is largely the same as the trait proposed in this paper.
There remain slight differences; the only major one is that Clang still incorrectly reports
types with user-provided assignment operators (and, on Windows, destructors) as "trivially relocatable."
See the recently fixed <a href="https://github.com/llvm/llvm-project/issues/67498">Clang #67498</a> and <a href="https://github.com/llvm/llvm-project/issues/77091">Clang #77091</a>, as well as <a href="https://github.com/abseil/abseil-cpp/commit/6b4af2497bf3ec56b070fdd6d8c2cf5996c17dbe">Abseil 6b4af24</a>.</p>
   <p>As of February 2024, Clang trunk has no equivalent of the <code class="highlight"><c- p>[[</c-><c- n>trivially_relocatable</c-><c- p>]]</c-></code> attribute, so <code class="highlight"><c- n>__is_trivially_relocatable</c-><c- p>(</c-><c- n>T</c-><c- p>)</c-></code> is true only when <code class="highlight"><c- n>T</c-></code> is
trivially copyable and/or trivial for purposes of calls. But Clang’s current status
is compatible with P1144, modulo the few unintentional differences listed in the
previous paragraph.</p>
   <p><a href="https://github.com/Quuxplusone/llvm-project/tree/trivially-relocatable">Arthur’s fork of Clang</a> implements
all of P1144 (since 2018), and has been kept up-to-date with the latest P1144. See it in action <a href="https://p1144.godbolt.org/z/jf67zx5hq">on godbolt.org</a>, under the name "x86-64 clang (experimental P1144)."</p>
   <h3 class="heading settled" id="implementation-lib"><span class="content">Library implementations</span><a class="self-link" href="#implementation-lib"></a></h3>
   <p>Since 2018, <a href="https://github.com/Quuxplusone/llvm-project/tree/trivially-relocatable">Arthur maintains a fork of libc++</a> with a fully optimizing implementation of P1144. See it in action <a href="https://p1144.godbolt.org/z/KasGGoE64">on godbolt.org</a>, under the name "x86-64 clang (experimental P1144)."
(<a href="https://p1144.godbolt.org/z/t28saC">Here</a> is another example showing P1144’s interaction with fancy allocators.)</p>
   <p>Since 2023, <a href="https://github.com/Quuxplusone/gcc/tree/trivially-relocatable">Arthur maintains a fork of libstdc++</a> with a conforming implementation of P1144, although it omits some optimizations. For example, <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>relocate</c-></code> never
lowers to <code class="highlight"><c- n>memcpy</c-></code>, and (as of February 2024) <code class="highlight"><c- n>vector</c-></code> reallocation never relocates. See it in action <a href="https://p1144.godbolt.org/z/zTvKPzxer">on godbolt.org</a>, under the name "x86-64 clang (experimental P1144),"
by passing <code class="highlight"><c- o>-</c-><c- n>stdlib</c-><c- o>=</c-><c- n>libstdc</c-><c- o>++</c-></code> on the command line.</p>
   <p>Since at least December 2018, Nvidia’s <a data-link-type="biblio" href="#biblio-thrust" title="Nvidia Thrust">[Thrust]</a> implements <code class="highlight"><c- n>is_trivially_relocatable</c-></code>, but uses it only as
a detail of device-to-device copy. No relevant algorithms or container optimizations are provided.</p>
   <p>Since October 2020, Carnegie Mellon’s <a data-link-type="biblio" href="#biblio-parlaylib" title="ParlayLib, a toolkit for programming parallel algorithms on shared-memory multicore machines">[ParlayLib]</a> implements <code class="highlight"><c- n>uninitialized_relocate</c-><c- p>{,</c-><c- n>_n</c-><c- p>}</c-></code> in the <code class="highlight"><c- n>parlay</c-></code> namespace.</p>
   <p>Since 2021, <a data-link-type="biblio" href="#biblio-amadeus" title="AMadeus (C++) Containers">[Amadeus]</a> AMC provides perhaps the most comprehensively optimizing <code class="highlight"><c- n>Vector</c-></code>, <code class="highlight"><c- n>SmallVector</c-></code>, and <code class="highlight"><c- n>StaticVector</c-></code> implementations, as well as P1144-compatible <code class="highlight"><c- n>uninitialized_relocate</c-><c- p>{,</c-><c- n>_n</c-><c- p>}</c-></code> and <code class="highlight"><c- n>relocate_at</c-></code> in the <code class="highlight"><c- n>amc</c-></code> namespace.</p>
   <p>Since September 2023, Stellar <a data-link-type="biblio" href="#biblio-hpx" title="Relocation Semantics in the HPX Library">[HPX]</a> implements <code class="highlight"><c- n>relocate_at</c-></code> and <code class="highlight"><c- n>uninitialized_relocate</c-><c- p>{,</c-><c- n>_n</c-><c- p>}</c-></code> in the <code class="highlight"><c- n>hpx</c-><c- o>::</c-><c- n>experimental</c-></code> namespace. This was a GSoC project.</p>
   <p><a data-link-type="biblio" href="#biblio-qt" title="Qt Base">[Qt]</a> implements <code class="highlight"><c- n>q_uninitialized_relocate_n</c-></code> in the <code class="highlight"><c- n>QtPrivate</c-></code> namespace, but (unlike P1144’s <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>uninitialized_relocate_n</c-></code>)
does not support overlap; it optimizes to <code class="highlight"><c- n>memcpy</c-></code>. Qt also provides <code class="highlight"><c- n>q_relocate_overlap_n</c-></code>, which optimizes to <code class="highlight"><c- n>memmove</c-></code>.</p>
   <p>Since November 2018, libstdc++ optimizes <code class="highlight"><c- n>vector</c-><c- o>::</c-><c- n>reserve</c-></code> for types that manually specialize <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>__is_bitwise_relocatable</c-></code>.
(<a href="https://godbolt.org/z/f7971hEcG">Godbolt.</a>)
As of February 2024, the only libstdc++ library type for which <code class="highlight"><c- n>__is_bitwise_relocatable</c-></code> has
been specialized is <code class="highlight"><c- n>deque</c-></code>. See <a data-link-type="biblio" href="#biblio-deque" title="Improve relocation ... (__is_trivially_relocatable): Specialize for deque">[Deque]</a>.</p>
   <p><a data-link-type="biblio" href="#biblio-parlaylib" title="ParlayLib, a toolkit for programming parallel algorithms on shared-memory multicore machines">[ParlayLib]</a>, <a data-link-type="biblio" href="#biblio-hpx" title="Relocation Semantics in the HPX Library">[HPX]</a>, <a data-link-type="biblio" href="#biblio-thrust" title="Nvidia Thrust">[Thrust]</a>, <a data-link-type="biblio" href="#biblio-qt" title="Qt Base">[Qt]</a>, <a data-link-type="biblio" href="#biblio-folly" title="Folly documentation on &quot;Object Relocation&quot;">[Folly]</a>, and <a data-link-type="biblio" href="#biblio-bsl" title="bslmf::IsBitwiseMoveable: bitwise moveable trait metafunction">[BSL]</a> all provide "type traits" that are intended
to be manually specialized by the client programmer. When compiled with a P1144-compliant compiler, <a data-link-type="biblio" href="#biblio-hpx" title="Relocation Semantics in the HPX Library">[HPX]</a> and <a data-link-type="biblio" href="#biblio-parlaylib" title="ParlayLib, a toolkit for programming parallel algorithms on shared-memory multicore machines">[ParlayLib]</a> do not require (in fact, they forbid) the client programmer to specialize
these type traits.</p>
   <p>See <a href="#applications">table §2.1</a> for more details on most of these library implementations.</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-abseil">[Abseil]
   <dd>Aaron Jacobs; et al.. <a href="https://github.com/abseil/abseil-cpp"><cite>Abseil C++ Common Libraries</cite></a>. March 2023. URL: <a href="https://github.com/abseil/abseil-cpp">https://github.com/abseil/abseil-cpp</a>
   <dt id="biblio-amadeus">[Amadeus]
   <dd>Stephane Janel. <a href="https://github.com/AmadeusITGroup/amc"><cite>AMadeus (C++) Containers</cite></a>. April 2021. URL: <a href="https://github.com/AmadeusITGroup/amc">https://github.com/AmadeusITGroup/amc</a>
   <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-bench">[Bench]
   <dd>Arthur O'Dwyer. <a href="https://github.com/Quuxplusone/from-scratch/blob/095b246d/cppnow2018/benchmark-relocatable.cc"><cite>Benchmark code from "The Best Type Traits C++ Doesn't Have"</cite></a>. April 2018. URL: <a href="https://github.com/Quuxplusone/from-scratch/blob/095b246d/cppnow2018/benchmark-relocatable.cc">https://github.com/Quuxplusone/from-scratch/blob/095b246d/cppnow2018/benchmark-relocatable.cc</a>
   <dt id="biblio-bsl">[BSL]
   <dd>Bloomberg. <a href="https://github.com/bloomberg/bde/blob/962f7aa/groups/bsl/bslmf/bslmf_isbitwisemoveable.h#L8-L48"><cite>bslmf::IsBitwiseMoveable: bitwise moveable trait metafunction</cite></a>. 2013–2022. URL: <a href="https://github.com/bloomberg/bde/blob/962f7aa/groups/bsl/bslmf/bslmf_isbitwisemoveable.h#L8-L48">https://github.com/bloomberg/bde/blob/962f7aa/groups/bsl/bslmf/bslmf_isbitwisemoveable.h#L8-L48</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-cppnow">[CppNow]
   <dd>Arthur O'Dwyer. <a href="https://www.youtube.com/watch?v=SGdfPextuAU"><cite>Trivially Relocatable (C++Now 2019)</cite></a>. May 2019. URL: <a href="https://www.youtube.com/watch?v=SGdfPextuAU">https://www.youtube.com/watch?v=SGdfPextuAU</a>
   <dt id="biblio-d114732">[D114732]
   <dd>Devin Jeanpierre. <a href="https://reviews.llvm.org/D114732"><cite>[clang] Mark trivial_abi types as trivially relocatable</cite></a>. November 2021. URL: <a href="https://reviews.llvm.org/D114732">https://reviews.llvm.org/D114732</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-fixedcapacityvector">[FixedCapacityVector]
   <dd>Arthur O'Dwyer. <a href="https://quuxplusone.github.io/blog/2019/02/22/p1144-fixed-capacity-vector/"><cite>P1144 case study: Moving a `fixed_capacity_vector`</cite></a>. URL: <a href="https://quuxplusone.github.io/blog/2019/02/22/p1144-fixed-capacity-vector/">https://quuxplusone.github.io/blog/2019/02/22/p1144-fixed-capacity-vector/</a>
   <dt id="biblio-folly">[Folly]
   <dd>Facebook. <a href="https://github.com/facebook/folly/blob/master/folly/docs/FBVector.md#object-relocation"><cite>Folly documentation on "Object Relocation"</cite></a>. URL: <a href="https://github.com/facebook/folly/blob/master/folly/docs/FBVector.md#object-relocation">https://github.com/facebook/folly/blob/master/folly/docs/FBVector.md#object-relocation</a>
   <dt id="biblio-hpx">[HPX]
   <dd>Isidoros Tsaousis-Seiras. <a href="https://isidorostsa.github.io/gsoc2023/"><cite>Relocation Semantics in the HPX Library</cite></a>. August 2023. URL: <a href="https://isidorostsa.github.io/gsoc2023/">https://isidorostsa.github.io/gsoc2023/</a>
   <dt id="biblio-inpractice">[InPractice]
   <dd>Arthur O'Dwyer. <a href="https://quuxplusone.github.io/blog/2019/02/20/p1144-what-types-are-relocatable/"><cite>What library types are trivially relocatable in practice?</cite></a>. February 2019. URL: <a href="https://quuxplusone.github.io/blog/2019/02/20/p1144-what-types-are-relocatable/">https://quuxplusone.github.io/blog/2019/02/20/p1144-what-types-are-relocatable/</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-p0843r5">[P0843R5]
   <dd>Gonzalo Brito Gadeschi. <a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/p0843r5.html"><cite>static_vector</cite></a>. July 2022. URL: <a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/p0843r5.html">https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/p0843r5.html</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-p2785r3">[P2785R3]
   <dd>Sébastien Bini; Ed Catmur. <a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2785r3.html"><cite>Relocating prvalues</cite></a>. June 2023. URL: <a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2785r3.html">https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2785r3.html</a>
   <dt id="biblio-p2786r2">[P2786R2]
   <dd>Mungo Gill; Alisdair Meredith. <a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2786r2.pdf"><cite>Trivial relocatability options</cite></a>. June 2023. URL: <a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2786r2.pdf">https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2786r2.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-p2959r0">[P2959R0]
   <dd><a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2959r0.html"><cite>Relocation within containers</cite></a>. October 2023. URL: <a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2959r0.html">https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2959r0.html</a>
   <dt id="biblio-p3055r1">[P3055R1]
   <dd>Arthur O'Dwyer. <a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3055r1.html"><cite>Relax wording to permit relocation optimizations in the STL</cite></a>. February 2024. URL: <a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3055r1.html">https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3055r1.html</a>
   <dt id="biblio-parlaylib">[ParlayLib]
   <dd>Daniel Anderson; Guy Blelloch. <a href="https://github.com/cmuparlay/parlaylib/blob/4579f39/include/parlay/relocation.h"><cite>ParlayLib, a toolkit for programming parallel algorithms on shared-memory multicore machines</cite></a>. October 2020. URL: <a href="https://github.com/cmuparlay/parlaylib/blob/4579f39/include/parlay/relocation.h">https://github.com/cmuparlay/parlaylib/blob/4579f39/include/parlay/relocation.h</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-qt">[Qt]
   <dd><a href="https://github.com/qt/qtbase/"><cite>Qt Base</cite></a>. February 2023. URL: <a href="https://github.com/qt/qtbase/">https://github.com/qt/qtbase/</a>
   <dt id="biblio-stdrelocateiscute">[StdRelocateIsCute]
   <dd>Arthur O'Dwyer. <a href="https://quuxplusone.github.io/blog/2022/05/18/std-relocate/"><cite>std::relocate's implementation is cute</cite></a>. May 2022. URL: <a href="https://quuxplusone.github.io/blog/2022/05/18/std-relocate/">https://quuxplusone.github.io/blog/2022/05/18/std-relocate/</a>
   <dt id="biblio-stdxerror">[StdxError]
   <dd>Charles Salvia. <a href="https://github.com/charles-salvia/std_error/"><cite>Implementation of std::error as proposed by Herb Sutter in P0709R0</cite></a>. October 2023. URL: <a href="https://github.com/charles-salvia/std_error/">https://github.com/charles-salvia/std_error/</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>
   <dt id="biblio-thrust">[Thrust]
   <dd>Bryce Adelstein Lelbach; Michał Dominiak. <a href="https://github.com/NVIDIA/cccl/blob/main/thrust/thrust/type_traits/is_trivially_relocatable.h"><cite>Nvidia Thrust</cite></a>. December 2018. URL: <a href="https://github.com/NVIDIA/cccl/blob/main/thrust/thrust/type_traits/is_trivially_relocatable.h">https://github.com/NVIDIA/cccl/blob/main/thrust/thrust/type_traits/is_trivially_relocatable.h</a>
  </dl>