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

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

	body {
		counter-reset: example figure issue;

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

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

		/* Colors */
		color: black;
		background: white top left fixed no-repeat;
		background-size: 25px auto;
	}


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	h1, h2, h3 {
		color: #005A9C;
		background: transparent;
	}

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

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

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

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

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

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

	p {
		margin: 1em 0;
	}

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

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

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

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

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

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

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

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

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


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

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

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

	del { color: red;  text-decoration: line-through; }
	ins { color: #080; text-decoration: underline;    }

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

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

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

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

	pre, code, samp {
		font-family: Menlo, Consolas, "DejaVu Sans Mono", Monaco, monospace;
		font-size: .9em;
		page-break-inside: avoid;
		hyphens: none;
		text-transform: none;
	}
	pre code,
	code code {
		font-size: 100%;
	}

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

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

  /* Do something nice. */

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

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

	/* We hyperlink a lot, so make it less intrusive */
	a[href] {
		color: #034575;
		text-decoration: none;
		border-bottom: 1px solid #707070;
		/* Need a bit of extending for it to look okay */
		padding: 0 1px 0;
		margin: 0 -1px 0;
	}
	a:visited {
		border-bottom-color: #BBB;
	}

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

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

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

	img {
		border-style: none;
	}

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

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

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

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

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

	.issue,
	.note,
	.example,
	.advisement,
	.assertion,
	blockquote {
		margin: 1em auto;
	}
	.note  > p:first-child,
	.issue > p:first-child,
	blockquote > :first-child {
		margin-top: 0;
	}
	blockquote > :last-child {
		margin-bottom: 0;
	}

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

	blockquote {
		border-color: silver;
	}

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

	.issue {
		border-color: #E05252;
		background: #FBE9E9;
		counter-increment: issue;
		overflow: auto;
	}
	.issue::before, .issue > .marker {
		text-transform: uppercase;
		color: #AE1E1E;
		padding-right: 1em;
		text-transform: uppercase;
	}
	/* Add .issue::before { content: "Issue " counter(issue) " "; } for autogen numbers,
	   or use class="marker" to mark up the issue number in source. */

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

	.example {
		border-color: #E0CB52;
		background: #FCFAEE;
		counter-increment: example;
		overflow: auto;
		clear: both;
	}
	.example::before, .example > .marker {
		text-transform: uppercase;
		color: #827017;
		min-width: 7.5em;
		display: block;
	}
	/* Add .example::before { content: "Example " counter(example) " "; } for autogen numbers,
	   or use class="marker" to mark up the example number in source. */

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

	.note {
		border-color: #52E052;
		background: #E9FBE9;
		overflow: auto;
	}

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

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

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

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

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

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

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

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

	.annoying-warning:not(details),
	details.annoying-warning:not([open]) > summary,
	details.annoying-warning[open] {
		background: #fdd;
		color: red;
		font-weight: bold;
		padding: .75em 1em;
		border: thick red;
		border-style: solid;
		border-radius: 1em;
	}
	.annoying-warning :last-child {
		margin-bottom: 0;
	}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


/*
Alternate table alignment rules

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

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

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

Possible extra rowspan handling

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

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

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


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

	.toc a {
		/* More spacing; use padding to make it part of the click target. */
		padding-top: 0.1rem;
		/* Larger, more consistently-sized click target */
		display: block;
		/* Reverse color scheme */
		color: black;
		border-color: #3980B5;
		border-bottom-width: 3px !important;
		margin-bottom: 0px !important;
	}
	.toc a:visited {
		border-color: #054572;
	}
	.toc a:not(:focus):not(:hover) {
		/* Allow colors to cascade through from link styling */
		border-bottom-color: transparent;
	}

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

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

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

		/* Section numbers in a column of their own */
		.toc .secno {
			float: left;
			width: 4rem;
			white-space: nowrap;
		}

		.toc li {
			clear: both;
		}

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

		/* Tighten up indentation in narrow ToCs */
		@media (max-width: 30em) {
			:not(li) > .toc              { margin-left:  4rem; }
			.toc .secno                  { margin-left: -4rem; }
			.toc > li li li              { margin-left:  1rem; }
			.toc > li li li .secno       { margin-left: -5rem; }
			.toc > li li li li .secno    { margin-left: -6rem; }
			.toc > li li li li li .secno { margin-left: -7rem; }
		}
	/* } */

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


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

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

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

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

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

	table.index tr:hover td:not([rowspan]),
	table.index tr:hover th:not([rowspan]) {
		background: #f7f8f9;
	}

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

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

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

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

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



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

	.figure .caption, .sidefigure .caption, figcaption {
		/* in case figure is overlarge, limit caption to 50em */
		max-width: 50rem;
		margin-left: auto;
		margin-right: auto;
	}
	.overlarge > table {
		/* limit preferred width of table */
		max-width: 50em;
		margin-left: auto;
		margin-right: auto;
	}

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

	@media not print {
		.overlarge {
			overflow-x: auto;
			/* See Lea Verou's explanation background-attachment:
			 * http://lea.verou.me/2012/04/background-attachment-local/
			 *
			background: top left  / 4em 100% linear-gradient(to right,  #ffffff, rgba(255, 255, 255, 0)) local,
			            top right / 4em 100% linear-gradient(to left, #ffffff, rgba(255, 255, 255, 0)) local,
			            top left  / 1em 100% linear-gradient(to right,  #c3c3c5, rgba(195, 195, 197, 0)) scroll,
			            top right / 1em 100% linear-gradient(to left, #c3c3c5, rgba(195, 195, 197, 0)) scroll,
			            white;
			background-repeat: no-repeat;
			*/
		}
	}
</style>
<style type="text/css">
    table, th, td {
      border: 1px solid black;
      border-collapse: collapse;
      vertical-align: top;
    }
    th, td {
      border-left: none;
      border-right: none;
      padding: 0px 10px;
    }
    th {
      text-align: center;
    }
  </style>
  <meta content="Bikeshed version 6abc9f98f620481a5031cd9b44944d60af9b79b9" name="generator">
  <link href="wg21.link/P0009r7" rel="canonical">
  <link href="https://isocpp.org/favicon.ico" rel="icon">
<style>/* style-md-lists */

/* This is a weird hack for me not yet following the commonmark spec
   regarding paragraph and lists. */
[data-md] > :first-child {
    margin-top: 0;
}
[data-md] > :last-child {
    margin-bottom: 0;
}</style>
<style>/* style-counters */

body {
    counter-reset: example figure issue;
}
.issue {
    counter-increment: issue;
}
.issue:not(.no-marker)::before {
    content: "Issue " counter(issue);
}

.example {
    counter-increment: example;
}
.example:not(.no-marker)::before {
    content: "Example " counter(example);
}
.invalid.example:not(.no-marker)::before,
.illegal.example:not(.no-marker)::before {
    content: "Invalid Example" counter(example);
}

figcaption {
    counter-increment: figure;
}
figcaption:not(.no-marker)::before {
    content: "Figure " counter(figure) " ";
}</style>
<style>/* style-syntax-highlighting */

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

.heading, .issue, .note, .example, li, dt {
    position: relative;
}
a.self-link {
    position: absolute;
    top: 0;
    left: calc(-1 * (3.5rem - 26px));
    width: calc(3.5rem - 26px);
    height: 2em;
    text-align: center;
    border: none;
    transition: opacity .2s;
    opacity: .5;
}
a.self-link:hover {
    opacity: 1;
}
.heading > a.self-link {
    font-size: 83%;
}
li > a.self-link {
    left: calc(-1 * (3.5rem - 26px) - 2em);
}
dfn > a.self-link {
    top: auto;
    left: auto;
    opacity: 0;
    width: 1.5em;
    height: 1.5em;
    background: gray;
    color: white;
    font-style: normal;
    transition: opacity .2s, background-color .2s, color .2s;
}
dfn:hover > a.self-link {
    opacity: 1;
}
dfn > a.self-link:hover {
    color: black;
}

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

.css.css, .property.property, .descriptor.descriptor {
    color: #005a9c;
    font-size: inherit;
    font-family: inherit;
}
.css::before, .property::before, .descriptor::before {
    content: "‘";
}
.css::after, .property::after, .descriptor::after {
    content: "’";
}
.property, .descriptor {
    /* Don't wrap property and descriptor names */
    white-space: nowrap;
}
.type { /* CSS value <type> */
    font-style: italic;
}
pre .property::before, pre .property::after {
    content: "";
}
[data-link-type="property"]::before,
[data-link-type="propdesc"]::before,
[data-link-type="descriptor"]::before,
[data-link-type="value"]::before,
[data-link-type="function"]::before,
[data-link-type="at-rule"]::before,
[data-link-type="selector"]::before,
[data-link-type="maybe"]::before {
    content: "‘";
}
[data-link-type="property"]::after,
[data-link-type="propdesc"]::after,
[data-link-type="descriptor"]::after,
[data-link-type="value"]::after,
[data-link-type="function"]::after,
[data-link-type="at-rule"]::after,
[data-link-type="selector"]::after,
[data-link-type="maybe"]::after {
    content: "’";
}

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

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

[data-link-type=biblio] {
    white-space: pre;
}</style>
 <body class="h-entry">
  <div class="head">
   <p data-fill-with="logo"></p>
   <h1 class="p-name no-ref" id="title">P0009R7<br><code class="highlight"><span class="n">mdspan</span></code>: A Non-Owning Multidimensional Array Reference</h1>
   <h2 class="no-num no-toc no-ref heading settled" id="subtitle"><span class="content">Draft Proposal, <time class="dt-updated" datetime="2018-06-24">24 June 2018</time></span></h2>
   <div data-fill-with="spec-metadata">
    <dl>
     <dt>This version:
     <dd><a class="u-url" href="wg21.link/P0009r7">wg21.link/P0009r7</a>
     <dt>Issue Tracking:
     <dd><a href="https://github.com/ORNL/cpp-proposals-pub">GitHub</a>
     <dt>Authors:
     <dd>
      <dd class="editor p-author h-card vcard"><a class="p-name fn u-email email" href="mailto:hedwards@nvidia.com">H. Carter Edwards</a>
     <dd>
      <dd class="editor p-author h-card vcard"><a class="p-name fn u-email email" href="mailto:blelbach@nvidia.com">Bryce Adelstein Lelbach</a>
     <dd>
      <dd class="editor p-author h-card vcard"><a class="p-name fn u-email email" href="mailto:dsunder@sandia.gov">Daniel Sunderland</a>
     <dd>
      <dd class="editor p-author h-card vcard"><a class="p-name fn u-email email" href="mailto:dshollm@sandia.gov">David Hollman</a>
     <dd>
      <dd class="editor p-author h-card vcard"><a class="p-name fn u-email email" href="mailto:crtrott@sandia.gov">Christian Trott</a>
     <dd>
      <dd class="editor p-author h-card vcard"><a class="p-name fn u-email email" href="mailto:mbianco@cscs.ch">Mauro Bianco</a>
     <dd>
      <dd class="editor p-author h-card vcard"><a class="p-name fn u-email email" href="mailto:ben.sander@amd.com">Ben Sander</a>
     <dd>
      <dd class="editor p-author h-card vcard"><a class="p-name fn u-email email" href="mailto:athanasios.iliopoulos@nrl.navy.mil">Athanasios Iliopoulos</a>
     <dd>
      <dd class="editor p-author h-card vcard"><a class="p-name fn u-email email" href="mailto:john.michopoulos@nrl.navy.mil">John Michopoulos</a>
     <dd>
      <dd class="editor p-author h-card vcard"><a class="p-name fn u-email email" href="mailto:mhoemme@sandia.gov">Mark Hoemmen</a>
     <dt>Audience:
     <dd>LWG
     <dt>Project:
     <dd>ISO JTC1/SC22/WG21: Programming Language C++
     <dt>Source:
     <dd><a href="https://github.com/ORNL/cpp-proposals-pub/blob/master/P0009/P0009.bs">github.com/ORNL/cpp-proposals-pub/blob/master/P0009/P0009.bs</a>
    </dl>
   </div>
   <div data-fill-with="warning"></div>
   <hr title="Separator for header">
  </div>
  <nav data-fill-with="table-of-contents" id="toc">
   <h2 class="no-num no-toc no-ref" id="contents">Table of Contents</h2>
   <ol class="toc" role="directory">
    <li>
     <a href="#revision-history"><span class="secno">1</span> <span class="content">Revision History</span></a>
     <ol class="toc">
      <li><a href="#p0009r7-post-2018-06-rapperswil-mailing"><span class="secno">1.1</span> <span class="content">P0009r7: Post 2018-06-Rapperswil Mailing</span></a>
      <li><a href="#p0009r6--pre-2018-06-rapperswil-mailing"><span class="secno">1.2</span> <span class="content">P0009r6 : Pre 2018-06-Rapperswil Mailing</span></a>
      <li><a href="#p0009r5--pre-2018-03-jacksonville-mailing"><span class="secno">1.3</span> <span class="content">P0009r5 : Pre 2018-03-Jacksonville Mailing</span></a>
      <li><a href="#p0009r4--pre-2017-11-albuquerque-mailing"><span class="secno">1.4</span> <span class="content">P0009r4 : Pre 2017-11-Albuquerque Mailing</span></a>
      <li><a href="#p0009r3--post-2016-06-oulu-mailing"><span class="secno">1.5</span> <span class="content">P0009r3 : Post 2016-06-Oulu Mailing</span></a>
      <li><a href="#p0009r2--pre-2016-06-oulu-mailing"><span class="secno">1.6</span> <span class="content">P0009r2 : Pre 2016-06-Oulu Mailing</span></a>
      <li><a href="#p0009r1--pre-2016-02-jacksonville-mailing"><span class="secno">1.7</span> <span class="content">P0009r1 : Pre 2016-02-Jacksonville Mailing</span></a>
      <li><a href="#p0009r0--pre-2015-10-kona-mailing"><span class="secno">1.8</span> <span class="content">P0009r0 : Pre 2015-10-Kona Mailing</span></a>
      <li><a href="#related-activity"><span class="secno">1.9</span> <span class="content">Related Activity</span></a>
     </ol>
    <li><a href="#description"><span class="secno">2</span> <span class="content">Description</span></a>
    <li><a href="#editing-notes"><span class="secno">3</span> <span class="content">Editing Notes</span></a>
    <li><a href="#wording"><span class="secno">4</span> <span class="content">Wording</span></a>
    <li><a href="#next-steps"><span class="secno">5</span> <span class="content">Next Steps</span></a>
    <li><a href="#related-work"><span class="secno">6</span> <span class="content">Related Work</span></a>
    <li><a href="#todo"><span class="secno">7</span> <span class="content">TODO</span></a>
    <li>
     <a href="#references"><span class="secno"></span> <span class="content">References</span></a>
     <ol class="toc">
      <li><a href="#informative"><span class="secno"></span> <span class="content">Informative References</span></a>
     </ol>
   </ol>
  </nav>
  <main>
   <h2 class="heading settled" data-level="1" id="revision-history"><span class="secno">1. </span><span class="content">Revision History</span><a class="self-link" href="#revision-history"></a></h2>
   <h3 class="heading settled" data-level="1.1" id="p0009r7-post-2018-06-rapperswil-mailing"><span class="secno">1.1. </span><span class="content">P0009r7: Post 2018-06-Rapperswil Mailing</span><a class="self-link" href="#p0009r7-post-2018-06-rapperswil-mailing"></a></h3>
   <ul>
    <li data-md="">
     <p>wording reworked based on guidance: <a href="wiki.edge.com/bin/view/Wg21rapperswil2018/LWGSatAM">LWG review at 2018-06-Rapperswil</a></p>
    <li data-md="">
     <p>usage of <code class="highlight"><span class="n">span</span></code> requires reference to C++20 working draft</p>
    <li data-md="">
     <p>namespace for library TS <code class="highlight"><span class="n">std</span><span class="o">::</span><span class="n">experimental</span><span class="o">::</span><span class="n">fundamentals_v3</span></code></p>
   </ul>
   <h3 class="heading settled" data-level="1.2" id="p0009r6--pre-2018-06-rapperswil-mailing"><span class="secno">1.2. </span><span class="content">P0009r6 : Pre 2018-06-Rapperswil Mailing</span><a class="self-link" href="#p0009r6--pre-2018-06-rapperswil-mailing"></a></h3>
   <p>P0009r5 was not taken up at 2018-03-Jacksonville meeting. Related <a href="http://wiki.edg.com/bin/view/Wg21jacksonville2018/P0900">LEWG
review of P0900 at 2018-03-Jacksonville
meeting</a></p>
   <p><strong>LEWG Poll</strong>: We want the ability to customize the access to elements
of span (ability to restrict, etc):</p>
<pre class="language-c++ highlight"><span class="n">span</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span> <span class="n">N</span><span class="p">,</span> <span class="n">Accessor</span><span class="o">=</span><span class="p">...</span><span class="o">></span>
</pre>
   <table>
    <thead>
     <tr>
      <th>SF
      <th>F
      <th>N
      <th>A
      <th>SA
    <tbody>
     <tr>
      <td> 1 
      <td> 1 
      <td> 1 
      <td> 2 
      <td> 8 
   </table>
   <p><strong>LEWG Poll</strong>: We want the customization of <code class="highlight"><span class="n">basic_mdspan</span></code> to be two
concepts <code class="highlight"><span class="n">Mapper</span></code> and <code class="highlight"><span class="n">Accessor</span></code> (akin to <code class="highlight"><span class="n">Allocator</span></code> design).</p>
<pre class="language-c++ highlight"><span class="n">basic_mdspan</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span> <span class="n">Extents</span><span class="p">,</span> <span class="n">Mapper</span><span class="p">,</span> <span class="n">Accessor</span><span class="o">></span>
<span class="n">mdspan</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span> <span class="n">N</span><span class="p">...</span><span class="o">></span>
</pre>
   <table>
    <thead>
     <tr>
      <th>SF
      <th>F
      <th>N
      <th>A
      <th>SA
    <tbody>
     <tr>
      <td> 3 
      <td> 4 
      <td> 5 
      <td> 1 
      <td> 0 
   </table>
   <p><strong>LEWG Poll</strong>: We want the customization of <code class="highlight"><span class="n">basic_mdspan</span></code> to be an
arbitrary (and potentially user-extensible) list of properties.</p>
<pre class="language-c++ highlight"><span class="n">basic_mdspan</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span> <span class="n">Extents</span><span class="p">,</span> <span class="n">Properties</span><span class="p">...</span><span class="o">></span>
</pre>
   <table>
    <thead>
     <tr>
      <th>SF
      <th>F
      <th>N
      <th>A
      <th>SA
    <tbody>
     <tr>
      <td> 1 
      <td> 2 
      <td> 2 
      <td> 6 
      <td> 2 
   </table>
   <p><strong>Changes from P0009r5 due to related LEWG reviews</strong>:</p>
   <ul>
    <li data-md="">
     <p>Replaced variadic property list with <em>extents</em>, <em>layout mapping</em>,
and <em>accessor</em> properties.</p>
    <li data-md="">
     <p>Incorporated <a href="https://wg21.link/P0454r1">P0454r1</a>.</p>
     <ul>
      <li data-md="">
       <p>Added accessor policy concept.</p>
      <li data-md="">
       <p>Renamed <code class="highlight"><span class="n">mdspan</span></code> to <code class="highlight"><span class="n">basic_mdspan</span></code>.</p>
      <li data-md="">
       <p>Added a <code class="highlight"><span class="n">mdspan</span></code> alias to <code class="highlight"><span class="n">basic_mdspan</span></code>.</p>
     </ul>
   </ul>
   <h3 class="heading settled" data-level="1.3" id="p0009r5--pre-2018-03-jacksonville-mailing"><span class="secno">1.3. </span><span class="content">P0009r5 : Pre 2018-03-Jacksonville Mailing</span><a class="self-link" href="#p0009r5--pre-2018-03-jacksonville-mailing"></a></h3>
   <p><a href="http://wiki.edg.com/bin/view/Wg21albuquerque/P0009">LEWG review of P0009r4 at 2017-11-Albuquerque
meeting</a></p>
   <p><strong>LEWG Poll</strong>: We should be able to index with <code class="highlight"><span class="n">span</span><span class="o">&lt;</span><span class="kt">int</span> <span class="n">type</span><span class="p">[</span><span class="n">N</span><span class="p">]</span><span class="o">></span></code> (in
addition to array).</p>
   <table>
    <thead>
     <tr>
      <th>SF
      <th>F
      <th>N
      <th>A
      <th>SA
    <tbody>
     <tr>
      <td> 2 
      <td>11
      <td> 1 
      <td> 1 
      <td> 0 
   </table>
   <p>Against comment - there is not a proven needs for this feature.</p>
   <p><strong>LEWG Poll</strong>: We should be able to index with 1d <code class="highlight"><span class="n">mdspan</span></code>.</p>
   <table>
    <thead>
     <tr>
      <th>SF
      <th>F
      <th>N
      <th>A
      <th>SA
    <tbody>
     <tr>
      <td> 0 
      <td> 8 
      <td> 7 
      <td> 0 
      <td> 0 
   </table>
   <p><strong>LEWG Poll</strong>: We should put the requirement on "rank() &lt;= N" back to
"rank()==N".</p>
   <p><em>Unanimous consent</em></p>
   <p><strong>LEWG Poll</strong>: With the editorial changes from small group, plus the
above polls, forward this to LWG for Fundamentals v3.</p>
   <p><em>Unanimous consent</em></p>
   <p><strong>Changes from P0009r4</strong>:</p>
   <ul>
    <li data-md="">
     <p>Removed nullptr constructor.</p>
    <li data-md="">
     <p>Added constexpr to indexing operator.</p>
    <li data-md="">
     <p>Indexing operator requires that <code class="highlight"><span class="n">rank</span><span class="p">()</span><span class="o">==</span><span class="k">sizeof</span><span class="p">...(</span><span class="n">indices</span><span class="p">)</span></code>.</p>
    <li data-md="">
     <p>Fixed typos in examples and moved them to appendix.</p>
    <li data-md="">
     <p>Converted note on how extentions to access properties may cause
reference to be a proxy type to an "see below" to make it
normative.</p>
   </ul>
   <h3 class="heading settled" data-level="1.4" id="p0009r4--pre-2017-11-albuquerque-mailing"><span class="secno">1.4. </span><span class="content">P0009r4 : Pre 2017-11-Albuquerque Mailing</span><a class="self-link" href="#p0009r4--pre-2017-11-albuquerque-mailing"></a></h3>
   <p><a href="http://wiki.edg.com/bin/view/Wg21kona2017/P0009">LEWG review at 2017-03-Kona meeting</a></p>
   <p><a href="http://wiki.edg.com/bin/view/Wg21kona2017/P0546">LEWG review of P0546r1 at 2017-03-Kona meeting</a></p>
   <p><strong>LEWG Poll</strong>: Should we have a single template that covers both single
and multi-dimensional spans?</p>
   <table>
    <thead>
     <tr>
      <th>SF
      <th>F
      <th>N
      <th>A
      <th>SA
    <tbody>
     <tr>
      <td> 1 
      <td> 6 
      <td> 2 
      <td> 6 
      <td> 3 
   </table>
   <p><strong>Changes from P0009r3</strong>:</p>
   <ul>
    <li data-md="">
     <p>Align with P0122r5 span<a href="https://wg21.link/P0122r5">proposal</a>.</p>
    <li data-md="">
     <p>Rename to <code class="highlight"><span class="n">mdspan</span></code>, multidimensional span, to align with <code class="highlight"><span class="n">span</span></code>.</p>
    <li data-md="">
     <p>Move preferred array extents mechanism to appendix.</p>
    <li data-md="">
     <p>Expose codomain as a <code class="highlight"><span class="n">span</span></code>.</p>
    <li data-md="">
     <p>Add layout mapping concept.</p>
   </ul>
   <h3 class="heading settled" data-level="1.5" id="p0009r3--post-2016-06-oulu-mailing"><span class="secno">1.5. </span><span class="content">P0009r3 : Post 2016-06-Oulu Mailing</span><a class="self-link" href="#p0009r3--post-2016-06-oulu-mailing"></a></h3>
   <p><a href="http://wiki.edg.com/bin/view/Wg21oulu/P0009">LEWG review at 2016-06-Oulu</a></p>
   <p>LEWG did not like the name <code class="highlight"><span class="n">array_ref</span></code>, and suggested the following
alternatives: - <code class="highlight"><span class="n">sci_span</span></code> - <code class="highlight"><span class="n">numeric_span</span></code> - <code class="highlight"><span class="n">multidimensional_span</span></code> - <code class="highlight"><span class="n">multidim_span</span></code> - <code class="highlight"><span class="n">mdspan</span></code> - <code class="highlight"><span class="n">md_span</span></code> - <code class="highlight"><span class="n">vla_span</span></code> - <code class="highlight"><span class="n">multispan</span></code> - <code class="highlight"><span class="n">multi_span</span></code></p>
   <p><strong>LEWG Poll</strong>: Are member <code class="highlight"><span class="n">begin</span><span class="p">()</span></code>/<code class="highlight"><span class="n">end</span><span class="p">()</span></code> still good?</p>
   <table>
    <thead>
     <tr>
      <th>SF
      <th>F
      <th>N
      <th>A
      <th>SA
    <tbody>
     <tr>
      <td>0
      <td> 2 
      <td> 4 
      <td> 3 
      <td> 1 
   </table>
    <strong>LEWG Poll</strong>: Want this proposal to provide range-producing functions
outside <code class="highlight"><span class="n">array_ref</span></code>? 
   <table>
    <thead>
     <tr>
      <th>SF
      <th>F
      <th>N
      <th>A
      <th>SA
    <tbody>
     <tr>
      <td> 0 
      <td> 1 
      <td> 3 
      <td> 2 
      <td> 3 
   </table>
   <p><strong>LEWG Poll</strong>: Want a separate proposal to explore iteration design
space?</p>
   <table>
    <thead>
     <tr>
      <th>SF
      <th>F
      <th>N
      <th>A
      <th>SA
    <tbody>
     <tr>
      <td> 9 
      <td> 1 
      <td> 0 
      <td> 0 
      <td> 0 
   </table>
   <p><strong>Changes from P0009r2</strong>:</p>
   <ul>
    <li data-md="">
     <p>Removed iterator support; a future paper will be written on the
subject.</p>
    <li data-md="">
     <p>Noted difference between multidimensional array versus language’s
array-of-array-of-array...</p>
    <li data-md="">
     <p>Clearly describe requirements for the embedded type aliases
(<code class="highlight"><span class="n">element_type</span></code>, <code class="highlight"><span class="n">reference</span></code>, etc).</p>
    <li data-md="">
     <p>Expanded description of how the variadic properties list would
work.</p>
    <li data-md="">
     <p>Stopped allowing <code class="highlight"><span class="n">array_ref</span><span class="o">&lt;</span><span class="n">T</span><span class="p">[</span><span class="n">N</span><span class="p">]</span><span class="o">></span></code> in addition to <code class="highlight"><span class="n">array_ref</span><span class="o">&lt;</span><span class="n">extents</span><span class="o">&lt;</span><span class="n">N</span><span class="o">>></span></code>.</p>
    <li data-md="">
     <p>Clarified domain, codomain, and domain -> codomain mapping
specifications.</p>
    <li data-md="">
     <p>Consistently use <em>extent</em> and <em>extents</em> for the multidimensional
index space.</p>
   </ul>
   <h3 class="heading settled" data-level="1.6" id="p0009r2--pre-2016-06-oulu-mailing"><span class="secno">1.6. </span><span class="content">P0009r2 : Pre 2016-06-Oulu Mailing</span><a class="self-link" href="#p0009r2--pre-2016-06-oulu-mailing"></a></h3>
   <p><a href="http://wiki.edg.com/bin/view/Wg21jacksonville/P0009">LEWG review at 2016-02-Jacksonville</a>.</p>
   <p><strong>Changes from P0009r1</strong>:</p>
   <ul>
    <li data-md="">
     <p>Adding details for extensibility of layout mapping.</p>
    <li data-md="">
     <p>Move motivation, examples, and relaxed incomplete array type
proposal to separate papers.</p>
     <ul>
      <li data-md="">
       <p><a href="https://wg21.link/P0331">P0331: Motivation and Examples for Polymorphic
Multidimensional Array</a>.</p>
      <li data-md="">
       <p><a href="https://wg21.link/P0332">P0332: Relaxed Incomplete Multidimensional Array Type
Declaration</a>.</p>
     </ul>
   </ul>
   <h3 class="heading settled" data-level="1.7" id="p0009r1--pre-2016-02-jacksonville-mailing"><span class="secno">1.7. </span><span class="content">P0009r1 : Pre 2016-02-Jacksonville Mailing</span><a class="self-link" href="#p0009r1--pre-2016-02-jacksonville-mailing"></a></h3>
   <p><a href="http://wiki.edg.com/bin/view/Wg21kona2015/P0009">LEWG review at 2015-10-Kona</a>.</p>
   <p><strong>LEWG Poll</strong>: What should this feature be called?</p>
   <table>
    <thead>
     <tr>
      <th>Name
      <th>#
    <tbody>
     <tr>
      <td><code class="highlight"><span class="n">view</span></code>
      <td> 5 
     <tr>
      <td><code class="highlight"><span class="n">span</span></code>
      <td> 9 
     <tr>
      <td><code class="highlight"><span class="n">array_ref</span></code>
      <td> 6 
     <tr>
      <td><code class="highlight"><span class="n">slice</span></code>
      <td> 6 
     <tr>
      <td><code class="highlight"><span class="n">array_view</span></code>
      <td> 6 
     <tr>
      <td><code class="highlight"><span class="n">ref</span></code>
      <td> 0 
     <tr>
      <td><code class="highlight"><span class="n">array_span</span></code>
      <td> 7 
     <tr>
      <td><code class="highlight"><span class="n">basic_span</span></code>
      <td> 1 
     <tr>
      <td><code class="highlight"><span class="n">object_span</span></code>
      <td> 3 
     <tr>
      <td><code class="highlight"><span class="n">field</span></code>
      <td> 0 
   </table>
   <p><strong>LEWG Poll</strong>: Do we want 0-length static extents?</p>
   <table>
    <thead>
     <tr>
      <th>SF
      <th>F
      <th>N
      <th>A
      <th>SA
    <tbody>
     <tr>
      <td> 3 
      <td> 4 
      <td> 2 
      <td> 3 
      <td> 0 
   </table>
   <p><strong>LEWG POLL</strong>: Do we want the language to support syntaxes like <code class="highlight"><span class="n">X</span><span class="p">[</span><span class="mi">3</span><span class="p">][][][</span><span class="mi">5</span><span class="p">]</span></code>?</p>
   <table>
    <thead>
     <tr>
      <th>Syntax
      <th>#
    <tbody>
     <tr>
      <td><code class="highlight"><span class="n">view</span><span class="o">&lt;</span><span class="kt">int</span><span class="p">[</span><span class="mi">3</span><span class="p">][</span><span class="mi">0</span><span class="p">][][</span><span class="mi">5</span><span class="p">],</span> <span class="n">property1</span><span class="o">></span></code>
      <td>12
     <tr>
      <td><code class="highlight"><span class="n">view</span><span class="o">&lt;</span><span class="kt">int</span><span class="p">,</span> <span class="n">dimension</span><span class="o">&lt;</span><span class="mi">3</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="n">dynamic_extent</span><span class="p">,</span> <span class="mi">5</span><span class="o">></span><span class="p">,</span> <span class="n">property1</span><span class="o">></span></code>
      <td> 4 
     <tr>
      <td><code class="highlight"><span class="n">view</span><span class="o">&lt;</span><span class="kt">int</span><span class="p">[</span><span class="mi">3</span><span class="p">][</span><span class="mi">0</span><span class="p">][</span><span class="n">dynamic_extent</span><span class="p">][</span><span class="mi">5</span><span class="p">],</span> <span class="n">property1</span><span class="o">></span></code>
      <td> 5 
     <tr>
      <td><code class="highlight"><span class="n">view</span><span class="o">&lt;</span><span class="kt">int</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="n">dynamic_extent</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="n">property1</span><span class="o">></span></code>
      <td> 4 
     <tr>
      <td><code class="highlight"><span class="n">view</span><span class="o">&lt;</span><span class="kt">int</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="n">dynamic_extent</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="n">properties</span><span class="o">&lt;</span><span class="n">property1</span><span class="o">>></span></code>
      <td> 2 
     <tr>
      <td><code class="highlight"><span class="n">view</span><span class="o">&lt;</span><span class="n">arr</span><span class="o">&lt;</span><span class="kt">int</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="n">dynamic_extent</span><span class="p">,</span> <span class="mi">5</span><span class="o">></span><span class="p">,</span> <span class="n">property1</span><span class="o">></span></code>
      <td> 4 
     <tr>
      <td><code class="highlight"><span class="n">view</span><span class="o">&lt;</span><span class="kt">int</span><span class="p">[</span><span class="mi">3</span><span class="p">][</span><span class="mi">0</span><span class="p">][][</span><span class="mi">5</span><span class="p">],</span> <span class="n">properties</span><span class="o">&lt;</span><span class="n">property1</span><span class="o">>></span></code>
      <td> 9 
   </table>
   <p><strong>LEWG POLL</strong>: Do we want the variadic property list in template args
(either raw or in <code class="highlight"><span class="n">properties</span><span class="o">&lt;></span></code>)? Note there is no precedence for this
in the library.</p>
   <table>
    <thead>
     <tr>
      <th>SF
      <th>F
      <th>N
      <th>A
      <th>SA
    <tbody>
     <tr>
      <td> 3 
      <td> 6 
      <td> 3 
      <td> 0 
      <td> 0 
   </table>
   <p><strong>LEWG POLL</strong>: Do we want the per-view bounds-checking knob?</p>
   <table>
    <thead>
     <tr>
      <th>SF
      <th>F
      <th>N
      <th>A
      <th>SA
    <tbody>
     <tr>
      <td> 3 
      <td> 4 
      <td> 1 
      <td> 2 
      <td> 1 
   </table>
   <p><strong>Changes from P0009r0</strong>:</p>
   <ul>
    <li data-md="">
     <p>Renamed <code class="highlight"><span class="n">view</span></code> to <code class="highlight"><span class="n">array_ref</span></code>.</p>
    <li data-md="">
     <p>How are users allowed to add properties? Needs elaboration in
paper.</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">view</span><span class="o">&lt;</span><span class="kt">int</span><span class="p">[][][]</span><span class="o">>::</span><span class="n">layout</span></code> should be named.</p>
    <li data-md="">
     <p>Rename <code class="highlight"><span class="n">is_regular</span></code> (possibly to <code class="highlight"><span class="n">is_affine</span></code>) to avoid overloading
the term with the <code class="highlight"><span class="n">Regular</span></code> concept.</p>
    <li data-md="">
     <p>Make static span(), operator(), constructor, etc variadic.</p>
    <li data-md="">
     <p>Demonstrate the need for improper access in the paper.</p>
    <li data-md="">
     <p>In <code class="highlight"><span class="k">operator</span><span class="p">()</span></code>, take integral types by value.</p>
   </ul>
   <h3 class="heading settled" data-level="1.8" id="p0009r0--pre-2015-10-kona-mailing"><span class="secno">1.8. </span><span class="content">P0009r0 : Pre 2015-10-Kona Mailing</span><a class="self-link" href="#p0009r0--pre-2015-10-kona-mailing"></a></h3>
   <p>Original non-owning multidimensional array reference (<code class="highlight"><span class="n">view</span></code>) paper with
motivation, specification, and examples.</p>
   <h3 class="heading settled" data-level="1.9" id="related-activity"><span class="secno">1.9. </span><span class="content">Related Activity</span><a class="self-link" href="#related-activity"></a></h3>
   <p>Related <a href="http://wiki.edg.com/bin/view/Wg21albuquerque/P0546">LEWG review of P0546r1 at 2017-11-Albuquerque meeting</a></p>
   <p><strong>LEWG Poll</strong>: <code class="highlight"><span class="n">span</span></code> should specify the dynamic extent as the element
type of the first template parameter rather than the (current) second
template parameter</p>
   <table>
    <thead>
     <tr>
      <th>SF
      <th>F
      <th>N
      <th>A
      <th>SA
    <tbody>
     <tr>
      <td> 5 
      <td> 3 
      <td> 2 
      <td> 2 
      <td> 0 
   </table>
   <p><strong>LEWG Poll</strong>: <code class="highlight"><span class="n">span</span></code> should support the addition of access properties
variadic template parameters</p>
   <table>
    <thead>
     <tr>
      <th>SF
      <th>F
      <th>N
      <th>A
      <th>SA
    <tbody>
     <tr>
      <td>0
      <td>10
      <td> 1 
      <td> 5 
      <td> 0 
   </table>
   <p>Authors agreed to bring a separate paper
(<a data-link-type="biblio" href="#biblio-p0900r0">[P0900r0]</a>) discussing how the variadic
properties will work.</p>
   <h2 class="heading settled" data-level="2" id="description"><span class="secno">2. </span><span class="content">Description</span><a class="self-link" href="#description"></a></h2>
   <p>The proposed polymorphic multidimensional array reference (<code class="highlight"><span class="n">mdspan</span></code>)
defines types and functions for mapping indices from the <strong>domain</strong>, a <strong>multidimensional index space</strong>, to the <strong>codomain</strong>, elements of a
contiguous span of objects. A multidimensional index space is defined as
the Cartesian product of integer extents, <code class="highlight"><span class="p">[</span><span class="mf">0.</span><span class="p">.</span><span class="n">N0</span><span class="p">)</span> <span class="o">*</span> <span class="p">[</span><span class="mf">0.</span><span class="p">.</span><span class="n">N1</span><span class="p">)</span> <span class="o">*</span> <span class="p">[</span><span class="mf">0.</span><span class="p">.</span><span class="n">N2</span><span class="p">)</span></code>....
An <code class="highlight"><span class="n">mdspan</span></code> has two policies: the <strong>layout mapping</strong> and the <strong>accessor</strong>. The layout mapping specifies the formula, and
properties of the formula, for mapping a multi-index from the domain to
an element in the codomain. The accessor is an extension point that
allows modification of how elements are accessed. For example, the
Accessors paper (P0367) proposed a rich set of potential access
properties.</p>
   <p><strong>A multidimensional array is not an array-of-array-of-array-of-array...</strong></p>
   <p>The multidimensional array abstraction has been fundamental to numerical
computations for over five decades. However, the C/C++ language provides
only a one-dimensional array abstraction which can be composed into
array-of-array-of-array... types. While such types have some similarity
to multidimensional arrays, they do not provide adequate multidimensional
array functionality of this proposal. Two critical functionality
differences are (1) multiple dynamic extents and (2) polymorphic mapping
of multi-indices to element objects.</p>
   <p><strong>Optimized Implementation of Layout Mapping</strong></p>
   <p>The layout mapping of a multi-index is intended to be an O(1) <code class="highlight"><span class="k">constexpr</span></code> operation that is trivially inlined and optimized. Note that Fortran
compilers' optimizations include loop invariant code motion, including
partial evaluation of multi-index layout mappings when indices are
loop-invariant.</p>
   <h2 class="heading settled" data-level="3" id="editing-notes"><span class="secno">3. </span><span class="content">Editing Notes</span><a class="self-link" href="#editing-notes"></a></h2>
   <p>The proposed changes are relative to the working draft of the standard
as of <a href="http://wg21.link/n4750">N4750</a>.</p>
   <p>The � character is used to denote a placeholder section number, table number,
or paragraph number which the editor shall determine.</p>
   <p>Add the header <code class="highlight"><span class="o">&lt;</span><span class="n">mdspan</span><span class="o">></span></code> to table 16 in <strong>[headers]</strong>.</p>
   <p>Add the header <code class="highlight"><span class="o">&lt;</span><span class="n">mdspan</span><span class="o">></span></code> to Table 76 in 26.1 <strong>[containers.general]</strong> below
the listing for <code class="highlight"><span class="o">&lt;</span><span class="n">span</span><span class="o">></span></code>.</p>
   <h2 class="heading settled" data-level="4" id="wording"><span class="secno">4. </span><span class="content">Wording</span><a class="self-link" href="#wording"></a></h2>
   <blockquote>
     Text in blockquotes is not proposed wording 
    <p>The � character is used to denote a placeholder section number which the editor
shall determine.</p>
   </blockquote>
   <blockquote> Copy <strong>[views]</strong> <em>subclause (currently 26.7 in n4750)</em> which contains
the wording for <code class="highlight"><span class="n">span</span></code> and <code class="highlight"><span class="n">dynamic_extent</span></code> which is needed for <code class="highlight"><span class="n">basic_mdspan</span></code> </blockquote>
   <hr>
   <p><br> <em>Add the following paragraphs to</em> *<em>[views.general]</em>:</p>
   <p>�. The header <code class="highlight"><span class="o">&lt;</span><span class="n">mdspan</span><span class="o">></span></code> defines the view <code class="highlight"><span class="n">basic_mdspan</span></code>, the type alias <code class="highlight"><span class="n">mdspan</span></code>,
and other facilities for interacting with these views.  
The <code class="highlight"><span class="n">basic_mdspan</span></code> class template maps a multi-index within a multi-index <em>domain</em> to a reference an element in the <em>codomain</em> <code class="highlight"><span class="n">span</span></code>.</p>
   <p>�. The <code class="highlight"><span class="n">subspan</span></code> function generates a <code class="highlight"><span class="n">basic_mdspan</span></code> with a domain
contained within the input <code class="highlight"><span class="n">basic_mdspan</span></code> domain and codomain contained
within the input <code class="highlight"><span class="n">basic_mdspan</span></code> codomain.</p>
   <hr>
   <p><br> <em>Add the following subclauses to the end of the</em> <strong>[views]</strong> <em>subclause (currently 26.7 in n4750)</em>:</p>
   <p><br> <b>26.7.� Header <code class="highlight"><span class="o">&lt;</span><span class="n">mdspan</span><span class="o">></span></code> synopsis [mdspan.syn]</b></p>
<pre class="language-c++ highlight"><span class="n">namespace</span> <span class="n">std</span> <span class="p">{</span>
<span class="n">namespace</span> <span class="n">experimental</span> <span class="p">{</span>
<span class="n">namespace</span> <span class="n">fundamentals_v3</span> <span class="p">{</span>
  <span class="c1">// [mdspan.extents], class template extents</span>
<span class="c1"></span>  <span class="n">template</span><span class="o">&lt;</span><span class="kt">ptrdiff_t</span><span class="p">...</span> <span class="n">StaticExtents</span><span class="o">></span>
    <span class="n">class</span> <span class="n">extents</span><span class="p">;</span>

  <span class="c1">// [mdspan.layout], Layout mapping policies</span>
<span class="c1"></span>  <span class="n">class</span> <span class="n">layout_left</span><span class="p">;</span>
  <span class="n">class</span> <span class="n">layout_right</span><span class="p">;</span>
  <span class="n">class</span> <span class="n">layout_stride</span><span class="p">;</span>

  <span class="c1">// [mdspan.accessor.basic], class template accessor_basic</span>
<span class="c1"></span>  <span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">ElementType</span><span class="o">></span>
  <span class="n">class</span> <span class="n">accessor_basic</span><span class="p">;</span>

  <span class="c1">// [mdspan.basic], class template mdspan</span>
<span class="c1"></span>  <span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">ElementType</span><span class="p">,</span>
           <span class="n">class</span> <span class="n">Extents</span><span class="p">,</span>
           <span class="n">class</span> <span class="n">LayoutPolicy</span> <span class="o">=</span> <span class="n">layout_right</span><span class="p">,</span>
           <span class="n">class</span> <span class="n">Accessor</span> <span class="o">=</span> <span class="n">accessor_basic</span><span class="o">&lt;</span><span class="n">ElementType</span><span class="o">>></span>
    <span class="n">class</span> <span class="n">basic_mdspan</span><span class="p">;</span>

  <span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">T</span><span class="p">,</span> <span class="kt">ptrdiff_t</span><span class="p">...</span> <span class="n">Extents</span><span class="o">></span>
    <span class="n">using</span> <span class="n">mdspan</span> <span class="o">=</span> <span class="n">basic_mdspan</span><span class="o">&lt;</span><span class="n">T</span><span class="p">,</span> <span class="n">extents</span><span class="o">&lt;</span><span class="n">Extents</span><span class="p">...</span><span class="o">>></span><span class="p">;</span>

  <span class="c1">// [mdspan.extents.compare], extents comparison operators</span>
<span class="c1"></span>  <span class="n">template</span><span class="o">&lt;</span><span class="kt">ptrdiff_t</span><span class="p">...</span> <span class="n">LHS</span><span class="p">,</span> <span class="kt">ptrdiff_t</span><span class="p">...</span> <span class="n">RHS</span><span class="o">></span>
    <span class="n">constexpr</span> <span class="kt">bool</span> <span class="n">operator</span><span class="o">==</span><span class="p">(</span><span class="k">const</span> <span class="n">extents</span><span class="o">&lt;</span><span class="n">LHS</span><span class="p">...</span><span class="o">>&amp;</span> <span class="n">lhs</span><span class="p">,</span> <span class="k">const</span> <span class="n">extents</span><span class="o">&lt;</span><span class="n">RHS</span><span class="p">...</span><span class="o">>&amp;</span> <span class="n">rhs</span><span class="p">)</span> <span class="n">noexcept</span><span class="p">;</span>
  <span class="n">template</span><span class="o">&lt;</span><span class="kt">ptrdiff_t</span><span class="p">...</span> <span class="n">LHS</span><span class="p">,</span> <span class="kt">ptrdiff_t</span><span class="p">...</span> <span class="n">RHS</span><span class="o">></span>
    <span class="n">constexpr</span> <span class="kt">bool</span> <span class="n">operator</span><span class="o">!=</span><span class="p">(</span><span class="k">const</span> <span class="n">extents</span><span class="o">&lt;</span><span class="n">LHS</span><span class="p">...</span><span class="o">>&amp;</span> <span class="n">lhs</span><span class="p">,</span> <span class="k">const</span> <span class="n">extents</span><span class="o">&lt;</span><span class="n">RHS</span><span class="p">...</span><span class="o">>&amp;</span> <span class="n">rhs</span><span class="p">)</span> <span class="n">noexcept</span><span class="p">;</span>

  <span class="c1">// [mdspan.subspan], subspan creation</span>
<span class="c1"></span>  <span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">ElementType</span><span class="p">,</span> <span class="n">class</span> <span class="n">Extents</span><span class="p">,</span> <span class="n">class</span> <span class="n">LayoutPolicy</span><span class="p">,</span>
           <span class="n">class</span> <span class="n">Accessor</span><span class="p">,</span> <span class="n">class</span><span class="p">...</span> <span class="n">SliceSpecifiers</span><span class="o">></span>
    <span class="n">basic_mdspan</span><span class="o">&lt;</span><span class="n">ElementType</span><span class="p">,</span> <span class="cm">/* see-below */</span><span class="o">></span>
      <span class="n">subspan</span><span class="p">(</span><span class="k">const</span> <span class="n">basic_mdspan</span><span class="o">&lt;</span><span class="n">ElementType</span><span class="p">,</span> <span class="n">Extents</span><span class="p">,</span> <span class="n">LayoutPolicy</span><span class="p">,</span> <span class="n">Accessor</span><span class="o">>&amp;</span><span class="p">,</span> <span class="n">SliceSpecifiers</span><span class="p">...)</span> <span class="n">noexcept</span><span class="p">;</span>

  <span class="c1">// tag supporting subspan</span>
<span class="c1"></span>  <span class="k">struct</span> <span class="n">all_type</span> <span class="p">{</span> <span class="n">explicit</span> <span class="n">all_type</span><span class="p">()</span> <span class="o">=</span> <span class="k">default</span><span class="p">;</span> <span class="p">};</span>
  <span class="kr">inline</span> <span class="n">constexpr</span> <span class="n">all_type</span> <span class="n">all</span> <span class="o">=</span> <span class="n">all_type</span><span class="p">{};</span>
<span class="p">}}}</span>
</pre>
   <p><b>26.7.� Class template <code class="highlight"><span class="n">extents</span></code> [mdspan.extents]</b></p>
   <p><b>26.7.�.1 Overview [mdspan.extents.overview]</b></p>
   <ol>
    <li data-md="">
     <p>An <code class="highlight"><span class="n">extents</span></code> object defines a <em>multidimensional index space</em> which is the Cartesian product of integers extents <code class="highlight"><span class="p">[</span><span class="mf">0.</span><span class="p">.</span><span class="n">N0</span><span class="p">)</span> <span class="o">*</span> <span class="p">[</span><span class="mf">0.</span><span class="p">.</span><span class="n">N1</span><span class="p">)</span> <span class="o">*</span></code>....</p>
    <li data-md="">
     <p>The <em>dynamic extents</em> of an <code class="highlight"><span class="n">extents</span></code> object correspond to the <code class="highlight"><span class="n">StaticExtents</span></code> template parameters that are equal to <code class="highlight"><span class="n">dynamic_extent</span></code>.  Let <em>DynamicRank[i]</em> denote the index of the <em>i</em>th such extent in the <code class="highlight"><span class="n">StaticExtents</span></code> template parameter pack, and let <em>DynamicIndex[r]</em> indicate the number of such extents in the first <em>r</em> entries of the <code class="highlight"><span class="n">StaticExtents</span></code> parameter pack</p>
    <li data-md="">
     <p>An <code class="highlight"><span class="n">extents</span></code> object is expected to store dynamic extents. <em>[Note:</em> An implementation should not consume storage for static extents. <em>— end note]</em></p>
    <li data-md="">
     <p>If any of <code class="highlight"><span class="n">StaticExtents</span></code> are negative and not equal to <code class="highlight"><span class="n">dynamic_extent</span></code>, the program is ill-formed.</p>
   </ol>
<pre class="highlight"><span class="k">namespace</span> <span class="n">std</span> <span class="p">{</span>
<span class="k">namespace</span> <span class="n">experimental</span> <span class="p">{</span>
<span class="k">namespace</span> <span class="n">fundamentals_v3</span> <span class="p">{</span>

<span class="k">template</span><span class="o">&lt;</span><span class="kt">ptrdiff_t</span><span class="p">...</span> <span class="n">StaticExtents</span><span class="o">></span>
<span class="k">class</span> <span class="nc">extents</span> <span class="p">{</span>
<span class="k">public</span><span class="o">:</span>
  <span class="c1">// types</span>
<span class="c1"></span>  <span class="k">using</span> <span class="n">index_type</span> <span class="o">=</span> <span class="kt">ptrdiff_t</span><span class="p">;</span>

  <span class="c1">// [mdspan.extents.cons], Constructors and assignment</span>
<span class="c1"></span>  <span class="k">constexpr</span> <span class="nf">extents</span><span class="p">()</span> <span class="k">noexcept</span><span class="p">;</span>
  <span class="k">constexpr</span> <span class="nf">extents</span><span class="p">(</span><span class="k">const</span> <span class="n">extents</span><span class="o">&amp;</span><span class="p">)</span> <span class="k">noexcept</span><span class="p">;</span>
  <span class="k">constexpr</span> <span class="nf">extents</span><span class="p">(</span><span class="n">extents</span><span class="o">&amp;&amp;</span><span class="p">)</span> <span class="k">noexcept</span><span class="p">;</span>
  <span class="k">template</span><span class="o">&lt;</span><span class="n">class</span><span class="p">...</span> <span class="n">IndexType</span><span class="o">></span>
  <span class="k">constexpr</span> <span class="n">extents</span><span class="p">(</span><span class="n">IndexType</span><span class="p">...</span> <span class="n">dynamic_extents</span><span class="p">)</span> <span class="k">noexcept</span><span class="p">;</span>
  <span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">IndexType</span><span class="p">,</span> <span class="kt">size_t</span> <span class="n">rank_dynamic</span><span class="o">></span>
  <span class="k">constexpr</span> <span class="n">extents</span><span class="p">(</span><span class="k">const</span> <span class="n">array</span><span class="o">&lt;</span><span class="n">IndexType</span><span class="p">,</span> <span class="n">rank_dynamic</span><span class="o">>&amp;</span><span class="p">)</span> <span class="k">noexcept</span><span class="p">;</span>
  <span class="k">template</span><span class="o">&lt;</span><span class="kt">ptrdiff_t</span><span class="p">...</span> <span class="n">OtherStaticExtents</span><span class="o">></span>
  <span class="k">constexpr</span> <span class="n">extents</span><span class="p">(</span><span class="k">const</span> <span class="n">extents</span><span class="o">&lt;</span><span class="n">OtherStaticExtents</span><span class="p">...</span><span class="o">>&amp;</span> <span class="n">other</span><span class="p">);</span>
  <span class="o">~</span><span class="n">extents</span><span class="p">()</span> <span class="o">=</span> <span class="k">default</span><span class="p">;</span>

  <span class="k">constexpr</span> <span class="n">extents</span><span class="o">&amp;</span> <span class="k">operator</span><span class="o">=</span><span class="p">(</span><span class="k">const</span> <span class="n">extents</span><span class="o">&amp;</span><span class="p">)</span> <span class="k">noexcept</span> <span class="o">=</span> <span class="k">default</span><span class="p">;</span>
  <span class="k">constexpr</span> <span class="n">extents</span><span class="o">&amp;</span> <span class="k">operator</span><span class="o">=</span><span class="p">(</span><span class="n">extents</span><span class="o">&amp;&amp;</span><span class="p">)</span> <span class="k">noexcept</span> <span class="o">=</span> <span class="k">default</span><span class="p">;</span>
  <span class="k">template</span><span class="o">&lt;</span><span class="kt">ptrdiff_t</span><span class="p">...</span> <span class="n">OtherStaticExtents</span><span class="o">></span>
  <span class="k">constexpr</span> <span class="n">extents</span><span class="o">&amp;</span> <span class="k">operator</span><span class="o">=</span><span class="p">(</span><span class="k">const</span> <span class="n">extents</span><span class="o">&lt;</span><span class="n">OtherStaticExtents</span><span class="p">...</span><span class="o">>&amp;</span> <span class="n">other</span><span class="p">);</span>

  <span class="c1">// [mdspan.extents.obs], Observers of the domain multi-index space</span>
<span class="c1"></span>  <span class="k">static</span> <span class="k">constexpr</span> <span class="kt">size_t</span> <span class="nf">rank</span><span class="p">()</span> <span class="k">noexcept</span><span class="p">;</span>
  <span class="k">static</span> <span class="k">constexpr</span> <span class="kt">size_t</span> <span class="nf">rank_dynamic</span><span class="p">()</span> <span class="k">noexcept</span><span class="p">;</span>
  <span class="k">static</span> <span class="k">constexpr</span> <span class="n">index_type</span> <span class="nf">static_extent</span><span class="p">(</span><span class="kt">size_t</span><span class="p">)</span> <span class="k">noexcept</span><span class="p">;</span>
  <span class="k">constexpr</span> <span class="n">index_type</span> <span class="nf">extent</span><span class="p">(</span><span class="kt">size_t</span><span class="p">)</span> <span class="k">const</span> <span class="k">noexcept</span><span class="p">;</span>

<span class="k">private</span><span class="o">:</span>
  <span class="n">array</span><span class="o">&lt;</span><span class="n">index_type</span><span class="p">,</span> <span class="n">rank_dynamic</span><span class="p">()</span><span class="o">></span> <span class="n">dynamic_extents_</span><span class="p">;</span> <span class="c1">// </span><i><span class="c1">exposition only</span></i>
<span class="c1"></span><span class="p">};</span>

<span class="p">}}}</span>
</pre>
   <p><b>26.7.�.2 Constructors and assignment [mdspan.extents.cons]</b></p>
<pre class="language-c++ highlight"><span class="n">constexpr</span> <span class="nf">extents</span><span class="p">()</span> <span class="n">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Effects:</em> Aggregate-initializes <code class="highlight"><span class="n">dynamic_extents_</span></code> to <code class="highlight"><span class="p">{</span> <span class="p">}</span></code></p>
    <li data-md="">
     <p><em>Postconditions:</em> <code class="highlight"><span class="n">extent</span><span class="p">(</span><span class="n">r</span><span class="p">)</span></code> if <code class="highlight"><span class="n">static_extent</span><span class="p">(</span><span class="n">r</span><span class="p">)</span><span class="o">==</span><span class="n">dynamic_extent</span></code> for all <code class="highlight"><span class="n">r</span></code> in the range <code class="highlight"><span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="n">rank</span><span class="p">())</span></code></p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><span class="n">constexpr</span> <span class="nf">extents</span><span class="p">(</span><span class="k">const</span> <span class="n">extents</span><span class="o">&amp;</span> <span class="n">other</span><span class="p">);</span>
<span class="n">constexpr</span> <span class="nf">extents</span><span class="p">(</span><span class="n">extents</span><span class="o">&amp;&amp;</span> <span class="n">other</span><span class="p">);</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Effects:</em> Initializes <code class="highlight"><span class="n">dynamic_extents_</span></code> with <code class="highlight"><span class="n">other</span><span class="p">.</span><span class="n">dynamic_extents_</span></code></p>
    <li data-md="">
     <p><em>Postconditions:</em> <code class="highlight"><span class="n">extent</span><span class="p">(</span><span class="n">r</span><span class="p">)</span><span class="o">==</span><span class="n">other</span><span class="p">.</span><span class="n">extent</span><span class="p">(</span><span class="n">r</span><span class="p">)</span></code> for all <code class="highlight"><span class="n">r</span></code> in the range <code class="highlight"><span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="n">rank</span><span class="p">())</span></code></p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><span class="n">template</span><span class="o">&lt;</span><span class="kt">ptrdiff_t</span><span class="p">...</span> <span class="n">OtherStaticExtents</span><span class="o">></span>
<span class="n">constexpr</span> <span class="n">extents</span><span class="p">(</span><span class="k">const</span> <span class="n">extents</span><span class="o">&lt;</span><span class="n">OtherStaticExtents</span><span class="p">...</span><span class="o">>&amp;</span> <span class="n">other</span><span class="p">);</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Requires:</em> For each <code class="highlight"><span class="n">r</span></code> in the range <code class="highlight"><span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="n">rank</span><span class="p">())</span></code>, if <code class="highlight"><span class="n">static_extent</span><span class="p">(</span><span class="n">r</span><span class="p">)</span><span class="o">!=</span><span class="n">dynamic_extent</span></code>, then <code class="highlight"><span class="n">static_extent</span><span class="p">(</span><span class="n">r</span><span class="p">)</span><span class="o">==</span><span class="n">other</span><span class="p">.</span><span class="n">extent</span><span class="p">(</span><span class="n">r</span><span class="p">)</span></code>.</p>
    <li data-md="">
     <p><em>Effects:</em> For each <code class="highlight"><span class="n">r</span></code> in the range <code class="highlight"><span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="n">rank</span><span class="p">())</span></code>, if <code class="highlight"><span class="n">static_extent</span><span class="p">(</span><span class="n">r</span><span class="p">)</span><span class="o">==</span><span class="n">dynamic_extent</span></code>, initializes <code class="highlight"><span class="n">dynamic_extents_</span><span class="p">[</span></code><em>DynamicRank[</em><code class="highlight"><span class="n">r</span></code><em>]</em><code class="highlight"><span class="p">]</span></code> with <code class="highlight"><span class="n">other</span><span class="p">.</span><span class="n">extent</span><span class="p">(</span><span class="n">r</span><span class="p">)</span></code>.</p>
    <li data-md="">
     <p><em>Throws:</em> Nothing.</p>
    <li data-md="">
     <p><em>Postconditions:</em> <code class="highlight"><span class="o">*</span><span class="k">this</span><span class="o">==</span><span class="n">other</span></code></p>
    <li data-md="">
     <p><em>Remarks:</em> This constructor shall not participate in overload resolution unless <code class="highlight"><span class="k">sizeof</span><span class="p">...(</span><span class="n">StaticExtents</span><span class="p">)</span><span class="o">==</span><span class="k">sizeof</span><span class="p">...(</span><span class="n">OtherStaticExtents</span><span class="p">)</span></code>.</p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><span class="n">template</span><span class="o">&lt;</span><span class="n">class</span><span class="p">...</span> <span class="n">IndexType</span><span class="o">></span>
<span class="n">constexpr</span> <span class="n">extents</span><span class="p">(</span><span class="n">IndexType</span><span class="p">...</span> <span class="n">dynamic_extents</span><span class="p">)</span> <span class="n">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Requires:</em> <code class="highlight"><span class="p">((</span><span class="n">dynamic_extents</span><span class="o">>=</span><span class="mi">0</span><span class="p">)</span> <span class="o">&amp;&amp;</span> <span class="p">...)</span></code></p>
    <li data-md="">
     <p><em>Effects:</em> Aggregate-initializes <code class="highlight"><span class="n">dynamic_extents_</span></code> to <code class="highlight"><span class="p">{</span><span class="n">dynamic_extents</span><span class="p">...}</span></code></p>
    <li data-md="">
     <p><em>Postconditions:</em> <code class="highlight"><span class="n">extent</span><span class="p">(</span></code><em>DynamicRank[i]</em><code class="highlight"><span class="p">)</span></code> is equal to the <em>i</em>th entry in the parameter pack <code class="highlight"><span class="n">dynamic_extents</span></code></p>
    <li data-md="">
     <p><em>Remarks:</em> This constructor shall not participate in overload resolution unless:</p>
     <ul>
      <li data-md="">
       <p><code class="highlight"><span class="p">(</span><span class="n">is_convertible_v</span><span class="o">&lt;</span><span class="n">IndexType</span><span class="p">,</span> <span class="n">index_type</span><span class="o">></span> <span class="o">&amp;&amp;</span> <span class="p">...)</span></code></p>
      <li data-md="">
       <p>and <code class="highlight"><span class="k">sizeof</span><span class="p">...(</span><span class="n">dynamic_extents</span><span class="p">)</span><span class="o">==</span><span class="n">rank_dynamic</span><span class="p">()</span></code></p>
     </ul>
   </ul>
<pre class="language-c++ highlight"><span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">IndexType</span><span class="p">,</span> <span class="kt">size_t</span> <span class="n">rank_dynamic</span><span class="o">></span>
<span class="n">constexpr</span> <span class="n">extents</span><span class="p">(</span><span class="k">const</span> <span class="n">array</span><span class="o">&lt;</span><span class="n">IndexType</span><span class="p">,</span> <span class="n">rank_dynamic</span><span class="o">></span> <span class="o">&amp;</span> <span class="n">dynamic_extents</span><span class="p">)</span> <span class="n">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Requires:</em> <code class="highlight"><span class="n">dynamic_extents</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">>=</span><span class="mi">0</span></code> for all <code class="highlight"><span class="n">i</span></code> where 0 &lt;= <code class="highlight"><span class="n">i</span></code> &lt; <code class="highlight"><span class="n">rank_dynamic</span><span class="p">()</span></code></p>
    <li data-md="">
     <p><em>Effects:</em> Initializes <code class="highlight"><span class="n">dynamic_extents_</span></code> with <code class="highlight"><span class="n">dynamic_extents</span></code></p>
    <li data-md="">
     <p><em>Postconditions:</em> <code class="highlight"><span class="n">extent</span><span class="p">(</span></code><em>DynamicRank[i]</em><code class="highlight"><span class="p">)</span></code> is equal to <code class="highlight"><span class="n">dynamic_extents</span><span class="p">[</span><span class="n">i</span><span class="p">]</span></code></p>
    <li data-md="">
     <p><em>Remarks:</em> This constructor shall not participate in overload resolution unless:</p>
     <ul>
      <li data-md="">
       <p><code class="highlight"><span class="n">is_convertible_v</span><span class="o">&lt;</span><span class="n">IndexType</span><span class="p">,</span> <span class="n">index_type</span><span class="o">></span></code></p>
     </ul>
   </ul>
<pre class="language-c++ highlight"><span class="n">template</span><span class="o">&lt;</span><span class="kt">ptrdiff_t</span><span class="p">...</span> <span class="n">OtherStaticExtents</span><span class="o">></span>
<span class="n">constexpr</span> <span class="n">extents</span><span class="o">&amp;</span> <span class="n">operator</span><span class="o">=</span><span class="p">(</span><span class="k">const</span> <span class="n">extents</span><span class="o">&lt;</span><span class="n">OtherStaticExtents</span><span class="p">...</span><span class="o">>&amp;</span> <span class="n">other</span><span class="p">);</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Requires:</em> For each <code class="highlight"><span class="n">r</span></code> in the range <code class="highlight"><span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="n">rank</span><span class="p">())</span></code>, if <code class="highlight"><span class="n">static_extent</span><span class="p">(</span><span class="n">r</span><span class="p">)</span><span class="o">!=</span><span class="n">dynamic_extent</span></code>, then <code class="highlight"><span class="n">static_extent</span><span class="p">(</span><span class="n">r</span><span class="p">)</span><span class="o">==</span><span class="n">other</span><span class="p">.</span><span class="n">extent</span><span class="p">(</span><span class="n">r</span><span class="p">)</span></code>.</p>
    <li data-md="">
     <p><em>Effects:</em> For each <code class="highlight"><span class="n">r</span></code> in the range <code class="highlight"><span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="n">rank</span><span class="p">())</span></code>, if <code class="highlight"><span class="n">static_extent</span><span class="p">(</span><span class="n">r</span><span class="p">)</span><span class="o">==</span><span class="n">dynamic_extent</span></code>, assigns <code class="highlight"><span class="n">dynamic_extents_</span><span class="p">[</span></code><em>DynamicRank[</em><code class="highlight"><span class="n">r</span></code><em>]</em><code class="highlight"><span class="p">]</span></code> to <code class="highlight"><span class="n">other</span><span class="p">.</span><span class="n">extent</span><span class="p">(</span><span class="n">r</span><span class="p">)</span></code>.</p>
    <li data-md="">
     <p><em>Throws:</em> Nothing.</p>
    <li data-md="">
     <p><em>Postconditions:</em> <code class="highlight"><span class="o">*</span><span class="k">this</span><span class="o">==</span><span class="n">other</span></code></p>
    <li data-md="">
     <p><em>Returns:</em> <code class="highlight"><span class="o">*</span><span class="k">this</span></code>.</p>
    <li data-md="">
     <p><em>Remarks:</em> This constructor shall not participate in overload resolution unless <code class="highlight"><span class="k">sizeof</span><span class="p">...(</span><span class="n">StaticExtents</span><span class="p">)</span><span class="o">==</span><span class="k">sizeof</span><span class="p">...(</span><span class="n">OtherStaticExtents</span><span class="p">)</span></code>.</p>
   </ul>
   <p><br></p>
   <p><br> <b>26.7.�.3 Observers of the domain multi-index space [mdspan.extents.obs]</b></p>
   <p><br></p>
<pre class="language-c++ highlight"><span class="k">static</span> <span class="n">constexpr</span> <span class="kt">size_t</span> <span class="nf">rank</span><span class="p">()</span> <span class="k">const</span> <span class="n">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Returns:</em> <code class="highlight"><span class="k">sizeof</span><span class="p">...(</span><span class="n">StaticExtents</span><span class="p">)</span></code></p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><span class="k">static</span> <span class="n">constexpr</span> <span class="kt">size_t</span> <span class="nf">rank_dynamic</span><span class="p">()</span> <span class="k">const</span> <span class="n">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Returns:</em> <code class="highlight"><span class="p">((</span><span class="n">StaticExtents</span><span class="o">==</span><span class="n">dynamic_extent</span><span class="p">)</span><span class="o">+</span><span class="p">...)</span></code> <em>[Note:</em> This is the number of dynamic extents <em>—end note]</em></p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><span class="k">static</span> <span class="n">constexpr</span> <span class="n">index_type</span> <span class="nf">static_extent</span><span class="p">(</span><span class="kt">size_t</span> <span class="n">r</span><span class="p">)</span> <span class="k">const</span> <span class="n">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Returns:</em> The <code class="highlight"><span class="n">r</span></code>th entry in the <code class="highlight"><span class="n">StaticExtents</span></code> parameter pack if 0 &lt;= <code class="highlight"><span class="n">r</span></code> &lt; <code class="highlight"><span class="n">rank</span><span class="p">()</span></code>, or 1 otherwise.</p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><span class="n">constexpr</span> <span class="n">index_type</span> <span class="nf">extent</span><span class="p">(</span><span class="kt">size_t</span> <span class="n">r</span><span class="p">)</span> <span class="k">const</span> <span class="n">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Returns:</em></p>
     <ul>
      <li data-md="">
       <p>If <code class="highlight"><span class="n">static_extent</span><span class="p">(</span><span class="n">r</span><span class="p">)</span><span class="o">==</span><span class="n">dynamic_extent</span></code>, then <code class="highlight"><span class="n">dynamic_extents_</span><span class="p">[</span></code><em>DynamicRank[</em><code class="highlight"><span class="n">r</span></code><em>]</em><code class="highlight"><span class="p">]</span></code>.</p>
      <li data-md="">
       <p>Otherwise, <code class="highlight"><span class="n">static_extent</span><span class="p">(</span><span class="n">r</span><span class="p">)</span></code>.</p>
     </ul>
   </ul>
   <p><br> <b>26.7.�.4 <code class="highlight"><span class="n">extents</span></code> comparison operators [mdspan.extents.compare]</b></p>
<pre class="language-c++ highlight"><span class="n">template</span><span class="o">&lt;</span><span class="kt">ptrdiff_t</span><span class="p">...</span> <span class="n">LHS</span><span class="p">,</span> <span class="kt">ptrdiff_t</span><span class="p">...</span> <span class="n">RHS</span><span class="o">></span>
  <span class="n">constexpr</span> <span class="kt">bool</span> <span class="n">operator</span><span class="o">==</span><span class="p">(</span><span class="k">const</span> <span class="n">extents</span><span class="o">&lt;</span><span class="n">LHS</span><span class="p">...</span><span class="o">>&amp;</span> <span class="n">lhs</span><span class="p">,</span> <span class="k">const</span> <span class="n">extents</span><span class="o">&lt;</span><span class="n">RHS</span><span class="p">...</span><span class="o">>&amp;</span> <span class="n">rhs</span><span class="p">)</span> <span class="n">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Returns:</em> <code class="highlight">true</code> if <code class="highlight"><span class="n">lhs</span><span class="p">.</span><span class="n">rank</span><span class="p">()</span><span class="o">==</span><span class="n">rhs</span><span class="p">.</span><span class="n">rank</span><span class="p">()</span></code> and <code class="highlight"><span class="n">lhs</span><span class="p">.</span><span class="n">extents</span><span class="p">(</span><span class="n">r</span><span class="p">)</span><span class="o">==</span><span class="n">rhs</span><span class="p">.</span><span class="n">extents</span><span class="p">(</span><span class="n">r</span><span class="p">)</span></code> for all <code class="highlight"><span class="n">r</span></code> in the range <code class="highlight"><span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="n">lhs</span><span class="p">.</span><span class="n">rank</span><span class="p">())</span></code>, or <code class="highlight">false</code> otherwise.</p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><span class="n">template</span><span class="o">&lt;</span><span class="kt">ptrdiff_t</span><span class="p">...</span> <span class="n">LHS</span><span class="p">,</span> <span class="kt">ptrdiff_t</span><span class="p">...</span> <span class="n">RHS</span><span class="o">></span>
  <span class="n">constexpr</span> <span class="kt">bool</span> <span class="n">operator</span><span class="o">!=</span><span class="p">(</span><span class="k">const</span> <span class="n">extents</span><span class="o">&lt;</span><span class="n">LHS</span><span class="p">...</span><span class="o">>&amp;</span> <span class="n">lhs</span><span class="p">,</span> <span class="k">const</span> <span class="n">extents</span><span class="o">&lt;</span><span class="n">RHS</span><span class="p">...</span><span class="o">>&amp;</span> <span class="n">rhs</span><span class="p">)</span> <span class="n">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Returns:</em> <code class="highlight"><span class="o">!</span><span class="p">(</span><span class="n">lhs</span><span class="o">==</span><span class="n">rhs</span><span class="p">)</span></code></p>
   </ul>
   <p><br> <br> <b>26.7.� Layout mapping policy [mdspan.layout]</b></p>
   <p><b>26.7.�.1 Layout mapping requirements [mdspan.layout.reqs]</b></p>
   <ol>
    <li data-md="">
     <p>A <em>layout mapping policy</em> is a class that contains a <em>layout mapping</em>, a nested class template.</p>
    <li data-md="">
     <p>A <em>layout mapping policy</em> shall meet the requirements in table �.</p>
    <li data-md="">
     <p>A <em>layout mapping</em> shall meet the requirements of <code class="highlight"><span class="n">DefaultConstructible</span></code>, <code class="highlight"><span class="n">CopyAssignable</span></code>, <code class="highlight"><span class="n">EqualityComparable</span></code>, and the requirements in table �.</p>
    <li data-md="">
     <p>In Table �:</p>
     <ul>
      <li data-md="">
       <p><code class="highlight"><span class="n">MP</span></code> denotes a layout mapping policy.</p>
      <li data-md="">
       <p><code class="highlight"><span class="n">E</span></code> denotes a specialization of <code class="highlight"><span class="n">extents</span></code>.</p>
      <li data-md="">
       <p><code class="highlight"><span class="n">e</span></code> denotes an object of type <code class="highlight"><span class="n">E</span></code> defining a domain multi-index space.</p>
      <li data-md="">
       <p><code class="highlight"><span class="n">r</span></code> is a value of an integral type such that 0 &lt;= <code class="highlight"><span class="n">r</span></code> &lt; <code class="highlight"><span class="n">e</span><span class="p">.</span><span class="n">rank</span><span class="p">()</span></code>.</p>
      <li data-md="">
       <p><code class="highlight"><span class="n">i</span><span class="p">...</span></code> and <code class="highlight"><span class="n">j</span><span class="p">...</span></code> are packs of an integer type denoting values in the multi-index space <code class="highlight"><span class="n">e</span></code>, the <code class="highlight"><span class="n">r</span></code>*th member of packs <code class="highlight"><span class="n">i</span><span class="p">...</span></code> and <code class="highlight"><span class="n">j</span><span class="p">...</span></code> are denoted by <code class="highlight"><span class="n">i</span><span class="p">[</span><span class="n">r</span><span class="p">]</span></code> and <code class="highlight"><span class="n">j</span><span class="p">[</span><span class="n">r</span><span class="p">]</span></code>, and <code class="highlight"><span class="k">sizeof</span><span class="p">...(</span><span class="n">i</span><span class="p">)</span><span class="o">==</span><span class="n">E</span><span class="o">::</span><span class="n">rank</span><span class="p">()</span></code>, 0 &lt;= <code class="highlight"><span class="n">i</span><span class="p">[</span><span class="n">r</span><span class="p">]</span></code> &lt; <code class="highlight"><span class="n">e</span><span class="p">.</span><span class="n">extent</span><span class="p">(</span><span class="n">r</span><span class="p">)</span></code>, <code class="highlight"><span class="k">sizeof</span><span class="p">...(</span><span class="n">j</span><span class="p">)</span><span class="o">==</span><span class="n">E</span><span class="o">::</span><span class="n">rank</span><span class="p">()</span></code>, and 0 &lt;= <code class="highlight"><span class="n">j</span><span class="p">[</span><span class="n">r</span><span class="p">]</span></code> &lt; <code class="highlight"><span class="n">e</span><span class="p">.</span><span class="n">extent</span><span class="p">(</span><span class="n">r</span><span class="p">)</span></code>.</p>
      <li data-md="">
       <p><code class="highlight"><span class="n">M</span></code> denotes a layout mapping class.</p>
      <li data-md="">
       <p><code class="highlight"><span class="n">m</span></code> denotes an object of type <code class="highlight"><span class="n">M</span></code> that maps a multi-index <code class="highlight"><span class="n">i</span><span class="p">...</span></code> to an integral value.</p>
     </ul>
   </ol>
   <p>Table � — Layout mapping policy and layout mapping requirements</p>
   <table border="1">
    <tbody>
     <tr>
      <th>Expression
      <th>Return Type
      <th>Operational Semantics
      <th>Requires/Remarks
     <tr>
      <td><code class="highlight"><span class="n">MP</span><span class="o">::</span><span class="k">template</span> <span class="n">mapping</span><span class="o">&lt;</span><span class="n">E</span><span class="o">></span></code>
      <td><code class="highlight"><span class="n">M</span></code>
      <td>
      <td>
     <tr>
      <td><code class="highlight"><span class="n">m</span><span class="p">.</span><span class="n">get_extents</span><span class="p">()</span></code>
      <td><code class="highlight"><span class="n">E</span></code>
      <td>
       <p><em>Returns:</em> <code class="highlight"><span class="n">e</span></code>.</p>
      <td>
     <tr>
      <td><code class="highlight"><span class="n">m</span><span class="p">(</span><span class="n">i</span><span class="p">...)</span></code>
      <td><code class="highlight"><span class="n">E</span><span class="o">::</span><span class="n">index_type</span></code>
      <td><em>Returns:</em> Mapping of a multi-index <code class="highlight"><span class="n">i</span><span class="p">...</span></code> 
      <td><em>Requires:</em> <code class="highlight"><span class="mi">0</span> <span class="o">&lt;=</span> <span class="n">m</span><span class="p">(</span><span class="n">i</span><span class="p">...)</span></code> 
     <tr>
      <td><code class="highlight"><span class="n">m</span><span class="p">.</span><span class="n">required_span_size</span><span class="p">()</span></code>
      <td><code class="highlight"><span class="n">E</span><span class="o">::</span><span class="n">index_type</span></code>
      <td><em>Returns:</em> one plus the maximum value of <code class="highlight"><span class="n">m</span><span class="p">(</span><span class="n">i</span><span class="p">...)</span></code>.
      <td>
     <tr>
      <td><code class="highlight"><span class="n">m</span><span class="p">.</span><span class="n">is_unique</span><span class="p">()</span></code>
      <td><code class="highlight"><span class="kt">bool</span></code>
      <td><em>Returns:</em> <code class="highlight">true</code> if <code class="highlight"><span class="n">m</span><span class="p">(</span><span class="n">i</span><span class="p">...)</span><span class="o">!=</span><span class="n">m</span><span class="p">(</span><span class="n">j</span><span class="p">...)</span></code> for every <code class="highlight"><span class="n">i</span><span class="p">...</span><span class="o">!=</span><span class="n">j</span><span class="p">...</span></code> 
      <td>
     <tr>
      <td><code class="highlight"><span class="n">m</span><span class="p">.</span><span class="n">is_contiguous</span><span class="p">()</span></code>
      <td><code class="highlight"><span class="kt">bool</span></code>
      <td><em>Returns:</em> <code class="highlight">true</code> if the set of values defined by <code class="highlight"><span class="n">m</span><span class="p">(</span><span class="n">i</span><span class="p">)...</span></code> is equal to the set of values consisting of <code class="highlight"><span class="mi">0</span></code>...<code class="highlight"><span class="n">m</span><span class="p">.</span><span class="n">required_span_size</span><span class="p">()</span><span class="o">-</span><span class="mi">1</span></code> 
      <td>
     <tr>
      <td><code class="highlight"><span class="n">m</span><span class="p">.</span><span class="n">is_strided</span><span class="p">()</span></code>
      <td><code class="highlight"><span class="kt">bool</span></code>
      <td><em>Returns:</em> <code class="highlight">true</code> if <code class="highlight"><span class="n">m</span><span class="p">(</span><span class="n">j</span><span class="p">...)</span> <span class="o">-</span> <span class="n">m</span><span class="p">(</span><span class="n">i</span><span class="p">...)</span> <span class="o">=</span> <span class="n">s</span><span class="p">[</span><span class="n">r</span><span class="p">]</span></code> when all members of <code class="highlight"><span class="n">j</span><span class="p">...</span></code> and <code class="highlight"><span class="n">i</span><span class="p">...</span></code> are equal except for exactly one <code class="highlight"><span class="n">r</span></code><em>th</em> member such that <code class="highlight"><span class="n">j</span><span class="p">[</span><span class="n">r</span><span class="p">]</span><span class="o">==</span><span class="n">i</span><span class="p">[</span><span class="n">r</span><span class="p">]</span><span class="o">+</span><span class="mi">1</span></code>. <code class="highlight"><span class="n">s</span><span class="p">[</span><span class="n">r</span><span class="p">]</span></code> is the <em>stride</em> of ordinate <code class="highlight"><span class="n">r</span></code>.
      <td>
     <tr>
      <td><code class="highlight"><span class="n">M</span><span class="o">::</span><span class="n">is_always_unique</span><span class="p">()</span></code>
      <td><code class="highlight"><span class="kt">bool</span></code>
      <td><em>Returns:</em> <code class="highlight">true</code> if <code class="highlight"><span class="n">m</span><span class="p">.</span><span class="n">is_unique</span><span class="p">()</span><span class="o">==</span>true</code> for any object of type <code class="highlight"><span class="n">M</span></code>.
      <td>
     <tr>
      <td><code class="highlight"><span class="n">M</span><span class="o">::</span><span class="n">is_always_contiguous</span><span class="p">()</span></code>
      <td><code class="highlight"><span class="kt">bool</span></code>
      <td><em>Returns:</em> <code class="highlight">true</code> if <code class="highlight"><span class="n">m</span><span class="p">.</span><span class="n">is_contiguous</span><span class="p">()</span><span class="o">==</span>true</code> for any object of type <code class="highlight"><span class="n">M</span></code>.
      <td>
     <tr>
      <td><code class="highlight"><span class="n">M</span><span class="o">::</span><span class="n">is_always_strided</span><span class="p">()</span></code>
      <td><code class="highlight"><span class="kt">bool</span></code>
      <td><em>Returns:</em> true if <code class="highlight"><span class="n">m</span><span class="p">.</span><span class="n">is_strided</span><span class="p">()</span><span class="o">==</span>true</code> for any object of type <code class="highlight"><span class="n">M</span></code>.
      <td>
     <tr>
      <td><code class="highlight"><span class="n">m</span><span class="p">.</span><span class="n">stride</span><span class="p">(</span><span class="n">r</span><span class="p">)</span></code>
      <td><code class="highlight"><span class="n">E</span><span class="o">::</span><span class="n">index_type</span></code>
      <td><em>Returns:</em> <code class="highlight"><span class="n">m</span><span class="p">(</span><span class="n">j</span><span class="p">...)</span> <span class="o">-</span> <span class="n">m</span><span class="p">(</span><span class="n">i</span><span class="p">...)</span></code> when all members of <code class="highlight"><span class="n">j</span><span class="p">...</span></code> and <code class="highlight"><span class="n">i</span><span class="p">...</span></code> are equal except for the <code class="highlight"><span class="n">r</span></code><em>th</em> member such that <code class="highlight"><span class="n">j</span><span class="p">[</span><span class="n">r</span><span class="p">]</span><span class="o">==</span><span class="n">i</span><span class="p">[</span><span class="n">r</span><span class="p">]</span><span class="o">+</span><span class="mi">1</span></code>.
      <td><em>Requires:</em> <code class="highlight"><span class="n">m</span><span class="p">.</span><span class="n">is_strided</span><span class="p">()</span><span class="o">==</span>true</code>
   </table>
   <p><br> <br> <b>26.7.�.2 Class layout_left [mdspan.layout.left]</b></p>
   <ol>
    <li data-md="">
     <p><code class="highlight"><span class="n">layout_left</span></code> meets the requirements of layout mapping policy. <em>[Note:</em> Thus, any well-formed specialization of <code class="highlight"><span class="n">layout_left</span><span class="o">::</span><span class="k">template</span> <span class="n">mapping</span></code> meets the requirements of layout mapping <em>—end note]</em></p>
    <li data-md="">
     <p><code class="highlight"><span class="n">layout_left</span></code> gives a layout mapping where the left-most extent is stride one and strides increase left-to-right as the product of extents.</p>
    <li data-md="">
     <p>If <code class="highlight"><span class="n">Extents</span></code> is not a (possibly cv-qualified) specialization of <code class="highlight"><span class="n">extents</span></code>, the program is ill-formed.</p>
   </ol>
<pre class="highlight"><span class="k">namespace</span> <span class="n">std</span> <span class="p">{</span>
<span class="k">namespace</span> <span class="n">experimental</span> <span class="p">{</span>
<span class="k">namespace</span> <span class="n">fundamentals_v3</span> <span class="p">{</span>

<span class="k">struct</span> <span class="n">layout_left</span> <span class="p">{</span>
  <span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">Extents</span><span class="o">></span>
  <span class="k">class</span> <span class="nc">mapping</span> <span class="p">{</span>
  <span class="k">public</span><span class="o">:</span>
    <span class="c1">// [mdspan.layout.left.cons], layout_left::mapping constructors</span>
<span class="c1"></span>    <span class="k">constexpr</span> <span class="n">mapping</span><span class="p">()</span> <span class="k">noexcept</span><span class="p">;</span>
    <span class="k">constexpr</span> <span class="nf">mapping</span><span class="p">(</span><span class="k">const</span> <span class="n">mapping</span><span class="o">&amp;</span> <span class="n">other</span><span class="p">)</span> <span class="k">noexcept</span><span class="p">;</span>
    <span class="k">constexpr</span> <span class="nf">mapping</span><span class="p">(</span><span class="n">mapping</span><span class="o">&amp;&amp;</span> <span class="n">other</span><span class="p">)</span> <span class="k">noexcept</span><span class="p">;</span>
    <span class="k">constexpr</span> <span class="nf">mapping</span><span class="p">(</span><span class="k">const</span> <span class="n">Extents</span><span class="o">&amp;</span> <span class="n">e</span><span class="p">)</span> <span class="k">noexcept</span><span class="p">;</span>
    <span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">OtherExtents</span><span class="o">></span>
      <span class="k">constexpr</span> <span class="n">mapping</span><span class="p">(</span><span class="k">const</span> <span class="n">mapping</span><span class="o">&lt;</span><span class="n">OtherExtents</span><span class="o">>&amp;</span> <span class="n">other</span><span class="p">);</span>

    <span class="n">mapping</span><span class="o">&amp;</span> <span class="k">operator</span><span class="o">=</span><span class="p">()</span> <span class="k">noexcept</span> <span class="o">=</span> <span class="k">default</span><span class="p">;</span>
    <span class="n">mapping</span><span class="o">&amp;</span> <span class="k">operator</span><span class="o">=</span><span class="p">(</span><span class="k">const</span> <span class="n">mapping</span><span class="o">&amp;</span> <span class="n">other</span><span class="p">)</span> <span class="k">noexcept</span> <span class="o">=</span> <span class="k">default</span><span class="p">;</span>
    <span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">OtherExtents</span><span class="o">></span>
      <span class="k">constexpr</span> <span class="n">mapping</span><span class="o">&amp;</span> <span class="k">operator</span><span class="o">=</span><span class="p">(</span><span class="k">const</span> <span class="n">mapping</span><span class="o">&lt;</span><span class="n">OtherExtents</span><span class="o">>&amp;</span> <span class="n">other</span><span class="p">);</span>

    <span class="c1">// [mdspan.layout.left.ops], layout_left::mapping operations</span>
<span class="c1"></span>    <span class="n">Extents</span> <span class="nf">get_extents</span><span class="p">()</span> <span class="k">const</span> <span class="k">noexcept</span><span class="p">;</span>

    <span class="k">constexpr</span> <span class="k">typename</span> <span class="n">Extents</span><span class="o">::</span><span class="n">index_type</span> <span class="n">required_span_size</span><span class="p">()</span> <span class="k">const</span> <span class="k">noexcept</span><span class="p">;</span>

    <span class="k">template</span><span class="o">&lt;</span><span class="n">class</span><span class="p">...</span> <span class="n">Indices</span><span class="o">></span>
      <span class="k">typename</span> <span class="n">Extents</span><span class="o">::</span><span class="n">index_type</span> <span class="k">operator</span><span class="p">()(</span><span class="n">Indices</span><span class="p">...</span> <span class="n">is</span><span class="p">)</span> <span class="k">const</span><span class="p">;</span>

    <span class="k">static</span> <span class="k">constexpr</span> <span class="kt">bool</span> <span class="nf">is_always_unique</span><span class="p">();</span>
    <span class="k">static</span> <span class="k">constexpr</span> <span class="kt">bool</span> <span class="nf">is_always_contiguous</span><span class="p">();</span>
    <span class="k">static</span> <span class="k">constexpr</span> <span class="kt">bool</span> <span class="nf">is_always_strided</span><span class="p">();</span>

    <span class="k">constexpr</span> <span class="kt">bool</span> <span class="nf">is_unique</span><span class="p">()</span> <span class="k">const</span><span class="p">;</span>
    <span class="k">constexpr</span> <span class="kt">bool</span> <span class="nf">is_contiguous</span><span class="p">()</span> <span class="k">const</span><span class="p">;</span>
    <span class="k">constexpr</span> <span class="kt">bool</span> <span class="nf">is_strided</span><span class="p">()</span> <span class="k">const</span><span class="p">;</span>

    <span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">OtherExtents</span><span class="o">></span>
      <span class="k">constexpr</span> <span class="kt">bool</span> <span class="k">operator</span><span class="o">==</span><span class="p">(</span><span class="k">const</span> <span class="n">mapping</span><span class="o">&lt;</span><span class="n">OtherExtents</span><span class="o">>&amp;</span> <span class="n">other</span><span class="p">)</span> <span class="k">const</span> <span class="k">noexcept</span><span class="p">;</span>
    <span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">OtherExtents</span><span class="o">></span>
      <span class="k">constexpr</span> <span class="kt">bool</span> <span class="k">operator</span><span class="o">!=</span><span class="p">(</span><span class="k">const</span> <span class="n">mapping</span><span class="o">&lt;</span><span class="n">OtherExtents</span><span class="o">>&amp;</span> <span class="n">other</span><span class="p">)</span> <span class="k">const</span> <span class="k">noexcept</span><span class="p">;</span>

    <span class="k">typename</span> <span class="n">Extents</span><span class="o">::</span><span class="n">index_type</span> <span class="n">stride</span><span class="p">(</span><span class="kt">size_t</span> <span class="n">rank</span><span class="p">)</span> <span class="k">const</span> <span class="k">noexcept</span><span class="p">;</span>

  <span class="k">private</span><span class="o">:</span>
    <span class="n">Extents</span> <span class="n">extents_</span><span class="p">;</span> <span class="c1">// </span><i><span class="c1">exposition only</span></i>
<span class="c1"></span>  <span class="p">};</span>
<span class="p">};</span>

<span class="p">}}}</span>
</pre>
   <p><br></p>
   <p><b>26.7.�.2.1 <code class="highlight"><span class="n">layout_left</span><span class="o">::</span><span class="n">mapping</span></code> constructors [mdspan.layout.left.cons]</b></p>
   <p><br></p>
<pre class="language-c++ highlight"><span class="n">constexpr</span> <span class="nf">mapping</span><span class="p">()</span> <span class="n">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Effects:</em> Default-initializes <code class="highlight"><span class="n">extents_</span></code>.</p>
    <li data-md="">
     <p><em>Postconditions:</em> <code class="highlight"><span class="n">get_extents</span><span class="p">()</span><span class="o">==</span><span class="n">Extents</span><span class="p">()</span></code></p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><span class="n">constexpr</span> <span class="nf">mapping</span><span class="p">(</span><span class="k">const</span> <span class="n">mapping</span><span class="o">&amp;</span> <span class="n">other</span><span class="p">)</span> <span class="n">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Effects:</em> Initializes <code class="highlight"><span class="n">extents_</span></code> with <code class="highlight"><span class="n">other</span><span class="p">.</span><span class="n">extents_</span></code>.</p>
    <li data-md="">
     <p><em>Postconditions:</em> <code class="highlight"><span class="n">get_extents</span><span class="p">()</span><span class="o">==</span><span class="n">other</span><span class="p">.</span><span class="n">get_extents</span><span class="p">()</span></code>.</p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><span class="n">constexpr</span> <span class="nf">mapping</span><span class="p">(</span><span class="n">mapping</span><span class="o">&amp;&amp;</span> <span class="n">other</span><span class="p">)</span> <span class="n">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Effects:</em> Initializes <code class="highlight"><span class="n">extents_</span></code> with <code class="highlight"><span class="n">move</span><span class="p">(</span><span class="n">other</span><span class="p">.</span><span class="n">extents_</span><span class="p">)</span></code>.</p>
    <li data-md="">
     <p><em>Postconditions:</em> <code class="highlight"><span class="n">get_extents</span><span class="p">()</span></code> returns a copy of an <code class="highlight"><span class="n">Extents</span></code> that is equal to the copy returned by <code class="highlight"><span class="n">other</span><span class="p">.</span><span class="n">get_extents</span><span class="p">()</span></code> before the invocation of the move.</p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><span class="n">constexpr</span> <span class="nf">mapping</span><span class="p">(</span><span class="k">const</span> <span class="n">Extents</span> <span class="o">&amp;</span> <span class="n">e</span><span class="p">)</span> <span class="n">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Effects:</em> Initializes <code class="highlight"><span class="n">extents_</span></code> with <code class="highlight"><span class="n">e</span></code>.</p>
    <li data-md="">
     <p><em>Postconditions:</em> <code class="highlight"><span class="n">get_extents</span><span class="p">()</span><span class="o">==</span><span class="n">e</span></code>.</p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">OtherExtents</span><span class="o">></span>
<span class="n">constexpr</span> <span class="n">mapping</span><span class="p">(</span><span class="k">const</span> <span class="n">mapping</span><span class="o">&lt;</span><span class="n">OtherExtents</span><span class="o">>&amp;</span> <span class="n">other</span><span class="p">);</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Requires:</em> <code class="highlight"><span class="n">other</span><span class="p">.</span><span class="n">get_extents</span><span class="p">()</span></code> meets the requirements for use in the initialization of <code class="highlight"><span class="n">extents_</span></code>.</p>
    <li data-md="">
     <p><em>Effects:</em> Initializes <code class="highlight"><span class="n">extents_</span></code> with <code class="highlight"><span class="n">other</span><span class="p">.</span><span class="n">get_extents</span><span class="p">()</span></code>.</p>
    <li data-md="">
     <p><em>Postconditions:</em> <code class="highlight"><span class="n">get_extents</span><span class="p">()</span><span class="o">==</span><span class="n">other</span><span class="p">.</span><span class="n">extents_</span></code>.</p>
    <li data-md="">
     <p><em>Throws:</em> nothing.</p>
   </ul>
   <p><br></p>
   <p><br></p>
   <p><b>26.7.�.2.2 <code class="highlight"><span class="n">layout_left</span><span class="o">::</span><span class="n">mapping</span></code> operations [mdspan.layout.left.ops]</b></p>
   <p><br></p>
<pre class="language-c++ highlight"><span class="n">Extents</span> <span class="nf">get_extents</span><span class="p">()</span> <span class="k">const</span> <span class="n">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Returns:</em> <code class="highlight"><span class="n">extents_</span></code>.</p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><span class="kr">typename</span> <span class="n">Extents</span><span class="o">::</span><span class="n">index_type</span> <span class="n">required_span_size</span><span class="p">()</span> <span class="k">const</span> <span class="n">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Returns:</em> The product of <code class="highlight"><span class="n">get_extents</span><span class="p">().</span><span class="n">extent</span><span class="p">(</span><span class="n">r</span><span class="p">)</span></code> for all <code class="highlight"><span class="n">r</span></code> where 0 &lt;= <code class="highlight"><span class="n">r</span></code> &lt; <code class="highlight"><span class="n">get_extents</span><span class="p">().</span><span class="n">rank</span><span class="p">()</span></code></p>
   </ul>
   <p><br></p>
<pre class="highlight"><span class="k">template</span><span class="o">&lt;</span><span class="n">class</span><span class="p">...</span> <span class="n">Indices</span><span class="o">></span>
  <span class="k">typename</span> <span class="n">Extents</span><span class="o">::</span><span class="n">index_type</span> <span class="k">operator</span><span class="p">()(</span><span class="n">Indices</span><span class="p">...</span> <span class="n">i</span><span class="p">)</span> <span class="k">const</span><span class="p">;</span>
</pre>
   <p>Let <code class="highlight"><span class="n">i</span><span class="p">[</span><span class="n">k</span><span class="p">]</span></code> denote the <code class="highlight"><span class="n">k</span></code><em>th</em> member of <code class="highlight"><span class="n">i</span><span class="p">...</span></code>.</p>
   <ul>
    <li data-md="">
     <p><em>Returns:</em> Equivalent to <code class="highlight"><span class="n">offset</span></code> in</p>
   </ul>
<pre class="highlight"><span class="n">Extents</span><span class="o">::</span><span class="n">index_type</span> <span class="n">offset</span> <span class="o">=</span> <span class="mi">0</span> <span class="p">;</span>
<span class="k">for</span><span class="p">(</span><span class="kt">size_t</span> <span class="n">k</span><span class="o">=</span><span class="mi">0</span><span class="p">;</span> <span class="n">k</span><span class="o">&lt;</span><span class="n">get_extents</span><span class="p">.</span><span class="n">rank</span><span class="p">();</span> <span class="o">++</span><span class="n">k</span><span class="p">)</span> 
  <span class="n">offset</span> <span class="o">+=</span> <span class="n">i</span><span class="p">[</span><span class="n">k</span><span class="p">]</span><span class="o">*</span><span class="n">stride</span><span class="p">(</span><span class="n">k</span><span class="p">);</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Remarks:</em> This operator shall not participate in overload resolution unless</p>
     <ul>
      <li data-md="">
       <p><code class="highlight"><span class="k">sizeof</span><span class="p">...(</span><span class="n">Indices</span><span class="p">)</span><span class="o">==</span><span class="n">get_extents</span><span class="p">().</span><span class="n">rank</span><span class="p">()</span></code>,</p>
      <li data-md="">
       <p>and <code class="highlight"><span class="n">is_convertible_v</span><span class="o">&lt;</span><span class="n">Indices</span><span class="p">,</span> <span class="k">typename</span> <span class="n">Extents</span><span class="o">::</span><span class="n">index_type</span><span class="o">></span> <span class="o">&amp;&amp;</span> <span class="p">...</span></code></p>
     </ul>
   </ul>
<pre class="highlight"></pre>
   <p><br></p>
<pre class="language-c++ highlight"><span class="k">static</span> <span class="n">constexpr</span> <span class="kt">bool</span> <span class="nf">is_always_unique</span><span class="p">();</span>
<span class="k">static</span> <span class="n">constexpr</span> <span class="kt">bool</span> <span class="nf">is_always_contiguous</span><span class="p">();</span>
<span class="k">static</span> <span class="n">constexpr</span> <span class="kt">bool</span> <span class="nf">is_always_strided</span><span class="p">();</span>
<span class="n">constexpr</span> <span class="kt">bool</span> <span class="nf">is_unique</span><span class="p">()</span> <span class="k">const</span><span class="p">;</span>
<span class="n">constexpr</span> <span class="kt">bool</span> <span class="nf">is_contiguous</span><span class="p">()</span> <span class="k">const</span><span class="p">;</span>
<span class="n">constexpr</span> <span class="kt">bool</span> <span class="nf">is_strided</span><span class="p">()</span> <span class="k">const</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Returns:</em> <code class="highlight">true</code></p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><span class="kr">typename</span> <span class="n">Extents</span><span class="o">::</span><span class="n">index_type</span> <span class="n">stride</span><span class="p">(</span><span class="kt">size_t</span> <span class="n">r</span><span class="p">)</span> <span class="k">const</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Returns:</em> Equivalent to <code class="highlight"><span class="n">s</span></code> in</p>
   </ul>
<pre class="highlight"><span class="n">Extents</span><span class="o">::</span><span class="n">index_type</span> <span class="n">s</span> <span class="o">=</span> <span class="mi">1</span><span class="p">;</span>
<span class="k">for</span><span class="p">(</span><span class="kt">size_t</span> <span class="n">k</span><span class="o">=</span><span class="mi">0</span><span class="p">;</span> <span class="n">k</span><span class="o">&lt;</span><span class="n">r</span><span class="p">;</span> <span class="o">++</span><span class="n">k</span><span class="p">)</span>
  <span class="n">s</span> <span class="o">*=</span> <span class="n">get_extents</span><span class="p">().</span><span class="n">extent</span><span class="p">(</span><span class="n">k</span><span class="p">);</span>
</pre>
   <p><br></p>
<pre class="language-c++ highlight"><span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">OtherExtents</span><span class="o">></span>
  <span class="n">constexpr</span> <span class="kt">bool</span> <span class="n">operator</span><span class="o">==</span><span class="p">(</span><span class="k">const</span> <span class="n">mapping</span><span class="o">&lt;</span><span class="n">OtherExtents</span><span class="o">>&amp;</span> <span class="n">other</span><span class="p">)</span> <span class="k">const</span> <span class="n">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Returns:</em> <code class="highlight"><span class="n">get_extents</span><span class="p">()</span><span class="o">==</span><span class="n">other</span><span class="p">.</span><span class="n">get_extents</span><span class="p">()</span></code>.</p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">OtherExtents</span><span class="o">></span>
  <span class="n">constexpr</span> <span class="kt">bool</span> <span class="n">operator</span><span class="o">!=</span><span class="p">(</span><span class="k">const</span> <span class="n">mapping</span><span class="o">&lt;</span><span class="n">OtherExtents</span><span class="o">>&amp;</span> <span class="n">other</span><span class="p">)</span> <span class="k">const</span> <span class="n">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Returns:</em> <code class="highlight"><span class="n">get_extents</span><span class="p">()</span><span class="o">!=</span><span class="n">other</span><span class="p">.</span><span class="n">get_extents</span><span class="p">()</span></code>.</p>
   </ul>
   <p><br> <br> <b>26.7.�.3 Class layout_right [mdspan.layout.right]</b></p>
   <ol>
    <li data-md="">
     <p><code class="highlight"><span class="n">layout_right</span></code> meets the requirements of layout mapping policy. <em>[Note:</em> Thus, any well-formed specialization of <code class="highlight"><span class="n">layout_right</span><span class="o">::</span><span class="k">template</span> <span class="n">mapping</span></code> meets the requirements of layout mapping <em>—end note]</em></p>
    <li data-md="">
     <p>The layout mapping property <code class="highlight"><span class="n">layout_right</span></code> gives a layout mapping where the right-most extent is stride one and strides increase right-to-left as the product of extents.</p>
    <li data-md="">
     <p>If <code class="highlight"><span class="n">Extents</span></code> is not a (possibly cv-qualified) specialization of <code class="highlight"><span class="n">extents</span></code>, the program is ill-formed.</p>
   </ol>
<pre class="highlight"><span class="k">namespace</span> <span class="n">std</span> <span class="p">{</span>
<span class="k">namespace</span> <span class="n">experimental</span> <span class="p">{</span>
<span class="k">namespace</span> <span class="n">fundamentals_v3</span> <span class="p">{</span>

<span class="k">struct</span> <span class="n">layout_right</span> <span class="p">{</span>
  <span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">Extents</span><span class="o">></span>
  <span class="k">class</span> <span class="nc">mapping</span> <span class="p">{</span>
  <span class="k">public</span><span class="o">:</span>
    <span class="c1">// [mdspan.layout.right.cons], layout_left::mapping constructors</span>
<span class="c1"></span>    <span class="k">constexpr</span> <span class="n">mapping</span><span class="p">()</span> <span class="k">noexcept</span><span class="p">;</span>
    <span class="k">constexpr</span> <span class="nf">mapping</span><span class="p">(</span><span class="k">const</span> <span class="n">mapping</span><span class="o">&amp;</span> <span class="n">other</span><span class="p">)</span> <span class="k">noexcept</span><span class="p">;</span>
    <span class="k">constexpr</span> <span class="nf">mapping</span><span class="p">(</span><span class="n">mapping</span><span class="o">&amp;&amp;</span> <span class="n">other</span><span class="p">)</span> <span class="k">noexcept</span><span class="p">;</span>
    <span class="k">constexpr</span> <span class="nf">mapping</span><span class="p">(</span><span class="n">Extents</span> <span class="n">e</span><span class="p">)</span> <span class="k">noexcept</span><span class="p">;</span>
    <span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">OtherExtents</span><span class="o">></span>
      <span class="k">constexpr</span> <span class="n">mapping</span><span class="p">(</span><span class="k">const</span> <span class="n">mapping</span><span class="o">&lt;</span><span class="n">OtherExtents</span><span class="o">>&amp;</span> <span class="n">other</span><span class="p">);</span>

    <span class="n">mapping</span><span class="o">&amp;</span> <span class="k">operator</span><span class="o">=</span><span class="p">()</span> <span class="k">noexcept</span> <span class="o">=</span> <span class="k">default</span><span class="p">;</span>
    <span class="n">mapping</span><span class="o">&amp;</span> <span class="k">operator</span><span class="o">=</span><span class="p">(</span><span class="k">const</span> <span class="n">mapping</span><span class="o">&amp;</span> <span class="n">other</span><span class="p">)</span> <span class="k">noexcept</span> <span class="o">=</span> <span class="k">default</span><span class="p">;</span>
    <span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">OtherExtents</span><span class="o">></span>
      <span class="k">constexpr</span> <span class="n">mapping</span><span class="o">&amp;</span> <span class="k">operator</span><span class="o">=</span><span class="p">(</span><span class="k">const</span> <span class="n">mapping</span><span class="o">&lt;</span><span class="n">OtherExtents</span><span class="o">>&amp;</span> <span class="n">other</span><span class="p">);</span>

    <span class="c1">// [mdspan.layout.right.ops], layout_right::mapping operations</span>
<span class="c1"></span>    <span class="n">Extents</span> <span class="nf">get_extents</span><span class="p">()</span> <span class="k">const</span> <span class="k">noexcept</span><span class="p">;</span>

    <span class="k">constexpr</span> <span class="k">typename</span> <span class="n">Extents</span><span class="o">::</span><span class="n">index_type</span> <span class="n">required_span_size</span><span class="p">()</span> <span class="k">const</span> <span class="k">noexcept</span><span class="p">;</span>

    <span class="k">template</span><span class="o">&lt;</span><span class="n">class</span><span class="p">...</span> <span class="n">Indices</span><span class="o">></span>
      <span class="k">typename</span> <span class="n">Extents</span><span class="o">::</span><span class="n">index_type</span> <span class="k">operator</span><span class="p">()(</span><span class="n">Indices</span><span class="p">...</span> <span class="n">is</span><span class="p">)</span> <span class="k">const</span><span class="p">;</span>

    <span class="k">static</span> <span class="k">constexpr</span> <span class="kt">bool</span> <span class="nf">is_always_unique</span><span class="p">()</span> <span class="k">noexcept</span><span class="p">;</span>
    <span class="k">static</span> <span class="k">constexpr</span> <span class="kt">bool</span> <span class="nf">is_always_contiguous</span><span class="p">()</span> <span class="k">noexcept</span><span class="p">;</span>
    <span class="k">static</span> <span class="k">constexpr</span> <span class="kt">bool</span> <span class="nf">is_always_strided</span><span class="p">()</span> <span class="k">noexcept</span><span class="p">;</span>

    <span class="k">constexpr</span> <span class="kt">bool</span> <span class="nf">is_unique</span><span class="p">()</span> <span class="k">const</span> <span class="k">noexcept</span><span class="p">;</span>
    <span class="k">constexpr</span> <span class="kt">bool</span> <span class="nf">is_contiguous</span><span class="p">()</span> <span class="k">const</span> <span class="k">noexcept</span><span class="p">;</span>
    <span class="k">constexpr</span> <span class="kt">bool</span> <span class="nf">is_strided</span><span class="p">()</span> <span class="k">const</span> <span class="k">noexcept</span><span class="p">;</span>

    <span class="k">typename</span> <span class="n">Extents</span><span class="o">::</span><span class="n">index_type</span> <span class="n">stride</span><span class="p">(</span><span class="kt">size_t</span> <span class="n">rank</span><span class="p">)</span> <span class="k">const</span> <span class="k">noexcept</span><span class="p">;</span>

    <span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">OtherExtents</span><span class="o">></span>
      <span class="k">constexpr</span> <span class="kt">bool</span> <span class="k">operator</span><span class="o">==</span><span class="p">(</span><span class="k">const</span> <span class="n">mapping</span><span class="o">&lt;</span><span class="n">OtherExtents</span><span class="o">>&amp;</span> <span class="n">other</span><span class="p">)</span> <span class="k">const</span> <span class="k">noexcept</span><span class="p">;</span>
    <span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">OtherExtents</span><span class="o">></span>
      <span class="k">constexpr</span> <span class="kt">bool</span> <span class="k">operator</span><span class="o">!=</span><span class="p">(</span><span class="k">const</span> <span class="n">mapping</span><span class="o">&lt;</span><span class="n">OtherExtents</span><span class="o">>&amp;</span> <span class="n">other</span><span class="p">)</span> <span class="k">const</span> <span class="k">noexcept</span><span class="p">;</span>

  <span class="k">private</span><span class="o">:</span>
    <span class="n">Extents</span> <span class="n">extents_</span><span class="p">;</span> <span class="c1">// </span><i><span class="c1">exposition only</span></i>
<span class="c1"></span>  <span class="p">};</span>
<span class="p">};</span>
<span class="p">}</span>
</pre>
   <p><br></p>
   <p><b>26.7.�.3.1 <code class="highlight"><span class="n">layout_right</span><span class="o">::</span><span class="n">mapping</span></code> constructors [mdspan.layout.right.cons]</b></p>
   <p><br></p>
<pre class="language-c++ highlight"><span class="n">constexpr</span> <span class="nf">mapping</span><span class="p">()</span> <span class="n">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Effects:</em> Default-initializes <code class="highlight"><span class="n">extents_</span></code>.</p>
    <li data-md="">
     <p><em>Postconditions:</em> <code class="highlight"><span class="n">get_extents</span><span class="p">()</span><span class="o">==</span><span class="n">Extents</span><span class="p">()</span></code></p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><span class="n">constexpr</span> <span class="nf">mapping</span><span class="p">(</span><span class="k">const</span> <span class="n">mapping</span><span class="o">&amp;</span> <span class="n">other</span><span class="p">)</span> <span class="n">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Effects:</em> Initializes <code class="highlight"><span class="n">extents_</span></code> with <code class="highlight"><span class="n">other</span><span class="p">.</span><span class="n">extents_</span></code>.</p>
    <li data-md="">
     <p><em>Postconditions:</em> <code class="highlight"><span class="n">get_extents</span><span class="p">()</span><span class="o">==</span><span class="n">other</span><span class="p">.</span><span class="n">get_extents</span><span class="p">()</span></code>.</p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><span class="n">constexpr</span> <span class="nf">mapping</span><span class="p">(</span><span class="n">mapping</span><span class="o">&amp;&amp;</span> <span class="n">other</span><span class="p">)</span> <span class="n">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Effects:</em> Initializes <code class="highlight"><span class="n">extents_</span></code> with <code class="highlight"><span class="n">move</span><span class="p">(</span><span class="n">other</span><span class="p">.</span><span class="n">extents_</span><span class="p">)</span></code>.</p>
    <li data-md="">
     <p><em>Postconditions:</em> <code class="highlight"><span class="n">get_extents</span><span class="p">()</span></code> returns a copy of an <code class="highlight"><span class="n">Extents</span></code> that is equal to the copy returned by <code class="highlight"><span class="n">other</span><span class="p">.</span><span class="n">get_extents</span><span class="p">()</span></code> before the invocation of the move.</p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><span class="n">constexpr</span> <span class="nf">mapping</span><span class="p">(</span><span class="n">Extents</span> <span class="n">e</span><span class="p">)</span> <span class="n">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Effects:</em> Initializes <code class="highlight"><span class="n">extents_</span></code> with <code class="highlight"><span class="n">e</span></code>.</p>
    <li data-md="">
     <p><em>Postconditions:</em> <code class="highlight"><span class="n">get_extents</span><span class="p">()</span><span class="o">==</span><span class="n">e</span></code>.</p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">OtherExtents</span><span class="o">></span>
  <span class="n">constexpr</span> <span class="n">mapping</span><span class="p">(</span><span class="k">const</span> <span class="n">mapping</span><span class="o">&lt;</span><span class="n">OtherExtents</span><span class="o">>&amp;</span> <span class="n">other</span><span class="p">);</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Requires:</em> <code class="highlight"><span class="n">other</span><span class="p">.</span><span class="n">get_extents</span><span class="p">()</span></code> meets the requirements for use in the initialization of <code class="highlight"><span class="n">extents_</span></code>.</p>
    <li data-md="">
     <p><em>Effects:</em> Initializes <code class="highlight"><span class="n">extents_</span></code> with <code class="highlight"><span class="n">other</span><span class="p">.</span><span class="n">get_extents</span><span class="p">()</span></code>.</p>
    <li data-md="">
     <p><em>Postconditions:</em> <code class="highlight"><span class="n">get_extents</span><span class="p">()</span><span class="o">==</span><span class="n">other</span><span class="p">.</span><span class="n">extents_</span></code>.</p>
    <li data-md="">
     <p><em>Throws:</em> nothing.</p>
   </ul>
   <p><br></p>
   <p><br></p>
   <p><b>26.7.�.3.2 <code class="highlight"><span class="n">layout_right</span><span class="o">::</span><span class="n">mapping</span></code> operations [mdspan.layout.right.ops]</b></p>
   <p><br></p>
<pre class="language-c++ highlight"><span class="n">Extents</span> <span class="nf">get_extents</span><span class="p">()</span> <span class="k">const</span> <span class="n">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Returns:</em> <code class="highlight"><span class="n">extents_</span></code>.</p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><span class="kr">typename</span> <span class="n">Extents</span><span class="o">::</span><span class="n">index_type</span> <span class="n">required_span_size</span><span class="p">()</span> <span class="k">const</span> <span class="n">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Returns:</em> The product of <code class="highlight"><span class="n">get_extents</span><span class="p">().</span><span class="n">extent</span><span class="p">(</span><span class="n">r</span><span class="p">)</span></code> for all <code class="highlight"><span class="n">r</span></code> where 0 &lt;= <code class="highlight"><span class="n">r</span></code> &lt; <code class="highlight"><span class="n">get_extents</span><span class="p">().</span><span class="n">rank</span><span class="p">()</span></code></p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><span class="n">template</span><span class="o">&lt;</span><span class="n">class</span><span class="p">...</span> <span class="n">Indices</span><span class="o">></span>
  <span class="kr">typename</span> <span class="n">Extents</span><span class="o">::</span><span class="n">index_type</span> <span class="n">operator</span><span class="p">()(</span><span class="n">Indices</span><span class="p">...</span> <span class="n">i</span><span class="p">)</span> <span class="k">const</span> <span class="n">noexcept</span><span class="p">;</span>
</pre>
   <p>Let <code class="highlight"><span class="n">i</span><span class="p">[</span><span class="n">k</span><span class="p">]</span></code> denote the <code class="highlight"><span class="n">k</span></code><em>th</em> member of <code class="highlight"><span class="n">i</span><span class="p">...</span></code>.</p>
   <ul>
    <li data-md="">
     <p><em>Returns:</em> Equivalent to <code class="highlight"><span class="n">offset</span></code> in</p>
   </ul>
<pre class="highlight"><span class="n">index_type</span> <span class="n">offset</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
<span class="k">for</span><span class="p">(</span><span class="kt">size_t</span> <span class="n">k</span><span class="o">=</span><span class="mi">0</span><span class="p">;</span> <span class="n">k</span><span class="o">&lt;</span><span class="n">Extents</span><span class="o">::</span><span class="n">rank</span><span class="p">();</span> <span class="o">++</span><span class="n">k</span><span class="p">)</span> 
  <span class="n">offset</span> <span class="o">+=</span> <span class="n">i</span><span class="p">[</span><span class="n">k</span><span class="p">]</span><span class="o">*</span><span class="n">stride</span><span class="p">(</span><span class="n">k</span><span class="p">);</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Remarks:</em> This operator shall not participate in overload resolution unless</p>
     <ul>
      <li data-md="">
       <p><code class="highlight"><span class="k">sizeof</span><span class="p">...(</span><span class="n">Indices</span><span class="p">)</span><span class="o">==</span><span class="n">get_extents</span><span class="p">().</span><span class="n">rank</span><span class="p">()</span></code>,</p>
      <li data-md="">
       <p>and <code class="highlight"><span class="n">is_convertible_v</span><span class="o">&lt;</span><span class="n">Indices</span><span class="p">,</span> <span class="k">typename</span> <span class="n">Extents</span><span class="o">::</span><span class="n">index_type</span><span class="o">></span> <span class="o">&amp;&amp;</span> <span class="p">...</span></code></p>
     </ul>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><span class="k">static</span> <span class="n">constexpr</span> <span class="kt">bool</span> <span class="nf">is_always_unique</span><span class="p">()</span> <span class="n">noexcept</span><span class="p">;</span>
<span class="k">static</span> <span class="n">constexpr</span> <span class="kt">bool</span> <span class="nf">is_always_contiguous</span><span class="p">()</span> <span class="n">noexcept</span><span class="p">;</span>
<span class="k">static</span> <span class="n">constexpr</span> <span class="kt">bool</span> <span class="nf">is_always_strided</span><span class="p">()</span> <span class="n">noexcept</span><span class="p">;</span>
<span class="n">constexpr</span> <span class="kt">bool</span> <span class="nf">is_unique</span><span class="p">()</span> <span class="k">const</span> <span class="n">noexcept</span><span class="p">;</span>
<span class="n">constexpr</span> <span class="kt">bool</span> <span class="nf">is_contiguous</span><span class="p">()</span> <span class="k">const</span> <span class="n">noexcept</span><span class="p">;</span>
<span class="n">constexpr</span> <span class="kt">bool</span> <span class="nf">is_strided</span><span class="p">()</span> <span class="k">const</span> <span class="n">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Returns:</em> <code class="highlight">true</code></p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><span class="kr">typename</span> <span class="n">Extents</span><span class="o">::</span><span class="n">index_type</span> <span class="n">stride</span><span class="p">(</span><span class="kt">size_t</span> <span class="n">r</span><span class="p">)</span> <span class="k">const</span> <span class="n">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Returns:</em> Equivalent to <code class="highlight"><span class="n">s</span></code> in</p>
   </ul>
<pre class="highlight"><span class="n">Extents</span><span class="o">::</span><span class="n">index_type</span> <span class="n">s</span> <span class="o">=</span> <span class="mi">1</span><span class="p">;</span>
<span class="k">for</span><span class="p">(</span><span class="kt">size_t</span> <span class="n">k</span><span class="o">=</span><span class="n">r</span><span class="o">+</span><span class="mi">1</span><span class="p">;</span> <span class="n">k</span><span class="o">&lt;</span><span class="n">get_extents</span><span class="p">.</span><span class="n">rank</span><span class="p">();</span> <span class="o">++</span><span class="n">k</span><span class="p">)</span>
  <span class="n">s</span> <span class="o">*=</span> <span class="n">get_extents</span><span class="p">(</span><span class="n">k</span><span class="p">);</span>
</pre>
   <p><br></p>
<pre class="language-c++ highlight"><span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">OtherExtents</span><span class="o">></span>
  <span class="n">constexpr</span> <span class="kt">bool</span> <span class="n">operator</span><span class="o">==</span><span class="p">(</span><span class="k">const</span> <span class="n">mapping</span><span class="o">&lt;</span><span class="n">OtherExtents</span><span class="o">>&amp;</span> <span class="n">other</span><span class="p">)</span> <span class="k">const</span> <span class="n">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Returns:</em> <code class="highlight"><span class="n">get_extents</span><span class="p">()</span><span class="o">==</span><span class="n">other</span><span class="p">.</span><span class="n">get_extents</span><span class="p">()</span></code>.</p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">OtherExtents</span><span class="o">></span>
  <span class="n">constexpr</span> <span class="kt">bool</span> <span class="n">operator</span><span class="o">!=</span><span class="p">(</span><span class="k">const</span> <span class="n">mapping</span><span class="o">&lt;</span><span class="n">OtherExtents</span><span class="o">>&amp;</span> <span class="n">other</span><span class="p">)</span> <span class="k">const</span> <span class="n">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Returns:</em> <code class="highlight"><span class="n">get_extents</span><span class="p">()</span><span class="o">!=</span><span class="n">other</span><span class="p">.</span><span class="n">get_extents</span><span class="p">()</span></code>.</p>
   </ul>
   <p><br> <br> <b>26.7.�.4 Class <code class="highlight"><span class="n">layout_stride</span></code> [mdspan.layout.stride]</b></p>
   <ol>
    <li data-md="">
     <p><code class="highlight"><span class="n">layout_stride</span></code> meets the requirements of layout mapping policy.</p>
    <li data-md="">
     <p>The layout mapping property <code class="highlight"><span class="n">layout_stride</span></code> gives a layout mapping where the strides are user defined.</p>
    <li data-md="">
     <p>If <code class="highlight"><span class="n">Extents</span></code> is not a (possibly cv-qualified) specialization of <code class="highlight"><span class="n">extents</span></code>, the program is ill-formed.</p>
   </ol>
   <p><br></p>
<pre class="highlight"><span class="k">namespace</span> <span class="n">std</span> <span class="p">{</span>
<span class="k">namespace</span> <span class="n">experimental</span> <span class="p">{</span>
<span class="k">namespace</span> <span class="n">fundamentals_v3</span> <span class="p">{</span>

<span class="k">struct</span> <span class="n">layout_stride</span> <span class="p">{</span>
  <span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">Extents</span><span class="o">></span>
  <span class="k">class</span> <span class="nc">mapping</span> <span class="p">{</span>
  <span class="k">public</span><span class="o">:</span>
    <span class="c1">// [mdspan.layout.stride.cons], layout_stride::mapping constructors</span>
<span class="c1"></span>    <span class="k">constexpr</span> <span class="n">mapping</span><span class="p">()</span> <span class="k">noexcept</span><span class="p">;</span>
    <span class="k">constexpr</span> <span class="nf">mapping</span><span class="p">(</span><span class="n">mapping</span> <span class="k">const</span><span class="o">&amp;</span> <span class="n">other</span><span class="p">)</span> <span class="k">noexcept</span><span class="p">;</span>
    <span class="k">constexpr</span> <span class="nf">mapping</span><span class="p">(</span><span class="n">mapping</span><span class="o">&amp;&amp;</span> <span class="n">other</span><span class="p">)</span> <span class="k">noexcept</span><span class="p">;</span>
    <span class="k">constexpr</span> <span class="nf">mapping</span><span class="p">(</span><span class="n">Extents</span> <span class="n">e</span><span class="p">,</span> <span class="n">array</span><span class="o">&lt;</span><span class="k">typename</span> <span class="n">Extents</span><span class="o">::</span><span class="n">index_type</span><span class="p">,</span> <span class="n">Extents</span><span class="o">::</span><span class="n">rank</span><span class="p">()</span><span class="o">></span> <span class="n">s</span><span class="p">)</span> <span class="k">noexcept</span><span class="p">;</span>
    <span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">OtherExtents</span><span class="o">></span>
      <span class="k">constexpr</span> <span class="n">mapping</span><span class="p">(</span><span class="k">const</span> <span class="n">mapping</span><span class="o">&lt;</span><span class="n">OtherExtents</span><span class="o">>&amp;</span> <span class="n">other</span><span class="p">);</span>

    <span class="n">mapping</span><span class="o">&amp;</span> <span class="k">operator</span><span class="o">=</span><span class="p">()</span> <span class="k">noexcept</span> <span class="o">=</span> <span class="k">default</span><span class="p">;</span>
    <span class="n">mapping</span><span class="o">&amp;</span> <span class="k">operator</span><span class="o">=</span><span class="p">(</span><span class="k">const</span> <span class="n">mapping</span><span class="o">&amp;</span> <span class="n">other</span><span class="p">)</span> <span class="k">noexcept</span> <span class="o">=</span> <span class="k">default</span><span class="p">;</span>
    <span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">OtherExtents</span><span class="o">></span>
      <span class="k">constexpr</span> <span class="n">mapping</span><span class="o">&amp;</span> <span class="k">operator</span><span class="o">=</span><span class="p">(</span><span class="k">const</span> <span class="n">mapping</span><span class="o">&lt;</span><span class="n">OtherExtents</span><span class="o">>&amp;</span> <span class="n">other</span><span class="p">);</span>

    <span class="c1">// [mdspan.layout.stride.ops], layout_stride::mapping operations</span>
<span class="c1"></span>    <span class="n">Extents</span> <span class="nf">get_extents</span><span class="p">()</span> <span class="k">const</span> <span class="k">noexcept</span><span class="p">;</span>
    <span class="n">array</span><span class="o">&lt;</span><span class="k">typename</span> <span class="n">Extents</span><span class="o">::</span><span class="n">index_type</span><span class="p">,</span> <span class="n">Extents</span><span class="o">::</span><span class="n">rank</span><span class="p">()</span><span class="o">></span> <span class="n">get_strides</span><span class="p">()</span> <span class="k">const</span> <span class="k">noexcept</span><span class="p">;</span>

    <span class="k">constexpr</span> <span class="k">typename</span> <span class="n">Extents</span><span class="o">::</span><span class="n">index_type</span> <span class="n">required_span_size</span><span class="p">()</span> <span class="k">const</span> <span class="k">noexcept</span><span class="p">;</span>

    <span class="k">template</span><span class="o">&lt;</span><span class="n">class</span><span class="p">...</span> <span class="n">Indices</span><span class="o">></span>
      <span class="k">typename</span> <span class="n">Extents</span><span class="o">::</span><span class="n">index_type</span> <span class="k">operator</span><span class="p">()(</span><span class="n">Indices</span><span class="p">...</span> <span class="n">is</span><span class="p">)</span> <span class="k">const</span><span class="p">;</span>

    <span class="k">static</span> <span class="k">constexpr</span> <span class="kt">bool</span> <span class="nf">is_always_unique</span><span class="p">()</span> <span class="k">noexcept</span><span class="p">;</span>
    <span class="k">static</span> <span class="k">constexpr</span> <span class="kt">bool</span> <span class="nf">is_always_contiguous</span><span class="p">()</span> <span class="k">noexcept</span><span class="p">;</span>
    <span class="k">static</span> <span class="k">constexpr</span> <span class="kt">bool</span> <span class="nf">is_always_strided</span><span class="p">()</span> <span class="k">noexcept</span><span class="p">;</span>

    <span class="k">constexpr</span> <span class="kt">bool</span> <span class="nf">is_unique</span><span class="p">()</span> <span class="k">const</span> <span class="k">noexcept</span><span class="p">;</span>
    <span class="k">constexpr</span> <span class="kt">bool</span> <span class="nf">is_contiguous</span><span class="p">()</span> <span class="k">const</span> <span class="k">noexcept</span><span class="p">;</span>
    <span class="k">constexpr</span> <span class="kt">bool</span> <span class="nf">is_strided</span><span class="p">()</span> <span class="k">const</span> <span class="k">noexcept</span><span class="p">;</span>

    <span class="k">typename</span> <span class="n">Extents</span><span class="o">::</span><span class="n">index_type</span> <span class="n">stride</span><span class="p">(</span><span class="kt">size_t</span> <span class="n">rank</span><span class="p">)</span> <span class="k">const</span> <span class="k">noexcept</span><span class="p">;</span>

    <span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">OtherExtents</span><span class="o">></span>
      <span class="k">constexpr</span> <span class="kt">bool</span> <span class="k">operator</span><span class="o">==</span><span class="p">(</span><span class="k">const</span> <span class="n">mapping</span><span class="o">&lt;</span><span class="n">OtherExtents</span><span class="o">>&amp;</span> <span class="n">other</span><span class="p">)</span> <span class="k">const</span> <span class="k">noexcept</span><span class="p">;</span>
    <span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">OtherExtents</span><span class="o">></span>
      <span class="k">constexpr</span> <span class="kt">bool</span> <span class="k">operator</span><span class="o">!=</span><span class="p">(</span><span class="k">const</span> <span class="n">mapping</span><span class="o">&lt;</span><span class="n">OtherExtents</span><span class="o">>&amp;</span> <span class="n">other</span><span class="p">)</span> <span class="k">const</span> <span class="k">noexcept</span><span class="p">;</span>

  <span class="k">private</span><span class="o">:</span>
    <span class="n">Extents</span> <span class="n">extents_</span><span class="p">;</span> <span class="c1">// </span><i><span class="c1">exposition only</span></i>
<span class="c1"></span>    <span class="n">array</span><span class="o">&lt;</span><span class="k">typename</span> <span class="n">Extents</span><span class="o">::</span><span class="n">index_type</span><span class="p">,</span> <span class="n">Extents</span><span class="o">::</span><span class="n">rank</span><span class="p">()</span><span class="o">></span> <span class="n">strides_</span><span class="p">;</span> <span class="c1">// </span><i><span class="c1">exposition only</span></i>
<span class="c1"></span>  <span class="p">};</span>
<span class="p">};</span>
<span class="p">}}}</span>
</pre>
   <p><br></p>
   <p><b>26.7.�.4.1 layout_stride::mapping constructors [mdspan.layout.stride.cons]</b></p>
<pre class="language-c++ highlight"><span class="n">constexpr</span> <span class="nf">mapping</span><span class="p">()</span> <span class="n">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p>Effects: Default-initializes extents_.</p>
    <li data-md="">
     <p>Postconditions: <code class="highlight"><span class="n">get_extents</span><span class="p">()</span><span class="o">==</span><span class="n">Extents</span><span class="p">()</span></code> and <code class="highlight"><span class="n">get_strides</span><span class="p">()</span><span class="o">==</span><span class="n">array</span><span class="o">&lt;</span><span class="k">typename</span> <span class="n">Extents</span><span class="o">::</span><span class="n">index_type</span><span class="p">,</span> <span class="n">Extents</span><span class="o">::</span><span class="n">rank</span><span class="p">()</span><span class="o">></span><span class="p">()</span></code></p>
   </ul>
<pre class="language-c++ highlight"><span class="n">constexpr</span> <span class="nf">mapping</span><span class="p">(</span><span class="k">const</span> <span class="n">mapping</span><span class="o">&amp;</span> <span class="n">other</span><span class="p">)</span> <span class="n">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p>Effects: Initializes extents_ with other.extents_.</p>
    <li data-md="">
     <p>Postconditions: <code class="highlight"><span class="n">get_extents</span><span class="p">()</span><span class="o">==</span><span class="n">other</span><span class="p">.</span><span class="n">get_extents</span><span class="p">()</span></code> and <code class="highlight"><span class="n">get_strides</span><span class="p">()</span><span class="o">==</span><span class="n">other</span><span class="p">.</span><span class="n">get_strides</span><span class="p">()</span></code></p>
   </ul>
<pre class="language-c++ highlight"><span class="n">constexpr</span> <span class="nf">mapping</span><span class="p">(</span><span class="n">mapping</span><span class="o">&amp;&amp;</span> <span class="n">other</span><span class="p">)</span> <span class="n">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p>Effects: Initializes extents_ with <code class="highlight"><span class="n">move</span><span class="p">(</span><span class="n">other</span><span class="p">.</span><span class="n">extents_</span><span class="p">)</span></code>.</p>
    <li data-md="">
     <p>Postconditions: <code class="highlight"><span class="n">get_extents</span><span class="p">()</span></code> returns a copy of an Extents that is equal to the copy returned by <code class="highlight"><span class="n">other</span><span class="p">.</span><span class="n">get_extents</span><span class="p">()</span></code> before the invocation of the move and <code class="highlight"><span class="n">get_strides</span><span class="p">()</span></code> returns a copy of an <code class="highlight"><span class="n">array</span><span class="o">&lt;</span><span class="k">typename</span> <span class="n">Extents</span><span class="o">::</span><span class="n">index_type</span><span class="p">,</span><span class="n">Extents</span><span class="o">::</span><span class="n">rank</span><span class="p">()</span><span class="o">></span></code> that is equal to the copy returned by <code class="highlight"><span class="n">other</span><span class="p">.</span><span class="n">get_strides</span><span class="p">()</span></code> before the invocation of the move</p>
   </ul>
<pre class="language-c++ highlight"><span class="n">constexpr</span> <span class="nf">mapping</span><span class="p">(</span><span class="n">Extents</span> <span class="n">e</span><span class="p">,</span> <span class="n">array</span><span class="o">&lt;</span><span class="kr">typename</span> <span class="n">Extents</span><span class="o">::</span><span class="n">index_type</span><span class="p">,</span> <span class="n">Extents</span><span class="o">::</span><span class="n">rank</span><span class="p">()</span><span class="o">></span> <span class="n">s</span><span class="p">)</span> <span class="n">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p>Requires:</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">s</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">></span><span class="mi">0</span></code> for 0 &lt; <code class="highlight"><span class="n">i</span></code> &lt;= <code class="highlight"><span class="n">Extents</span><span class="o">::</span><span class="n">rank</span><span class="p">()</span></code></p>
    <li data-md="">
     <p>there is a permutation of the numbers <code class="highlight"><span class="mi">0</span><span class="p">,</span></code>...<code class="highlight"><span class="p">,</span><span class="n">Extents</span><span class="o">::</span><span class="n">rank</span><span class="p">()</span><span class="o">-</span><span class="mi">1</span></code> <code class="highlight"><span class="n">o</span><span class="p">(</span><span class="n">i</span><span class="p">)</span></code> with 0 &lt;= <code class="highlight"><span class="n">i</span></code> &lt; <code class="highlight"><span class="n">Extents</span><span class="o">::</span><span class="n">rank</span><span class="p">()</span></code> such that <code class="highlight"><span class="n">stride</span><span class="p">(</span><span class="n">o</span><span class="p">(</span><span class="n">i</span><span class="p">))</span><span class="o">>=</span><span class="n">stride</span><span class="p">(</span><span class="n">o</span><span class="p">(</span><span class="n">i</span><span class="o">-</span><span class="mi">1</span><span class="p">))</span><span class="o">*</span><span class="n">get_extent</span><span class="p">.</span><span class="n">extent</span><span class="p">(</span><span class="n">o</span><span class="p">(</span><span class="n">i</span><span class="o">-</span><span class="mi">1</span><span class="p">))</span></code> for 1 &lt;= <code class="highlight"><span class="n">i</span></code> &lt; <code class="highlight"><span class="n">Extents</span><span class="o">::</span><span class="n">rank</span><span class="p">()</span></code></p>
    <li data-md="">
     <p>Effects: Initializes <code class="highlight"><span class="n">extents_</span></code> with <code class="highlight"><span class="n">e</span></code> and <code class="highlight"><span class="n">strides_</span></code> with <code class="highlight"><span class="n">s</span></code></p>
    <li data-md="">
     <p>Postconditions: <code class="highlight"><span class="n">get_extents</span><span class="p">()</span><span class="o">==</span><span class="n">e</span></code> and <code class="highlight"><span class="n">get_strides</span><span class="p">()</span><span class="o">==</span><span class="n">s</span></code>.</p>
    <li data-md="">
     <p>Throws: nothing</p>
   </ul>
<pre class="language-c++ highlight"><span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">OtherExtents</span><span class="o">></span>
  <span class="n">constexpr</span> <span class="n">mapping</span><span class="p">(</span><span class="k">const</span> <span class="n">mapping</span><span class="o">&lt;</span><span class="n">OtherExtents</span><span class="o">>&amp;</span> <span class="n">other</span><span class="p">);</span>
</pre>
   <ul>
    <li data-md="">
     <p>Requires: other.get_extents() meets the requirements for use in the initialization of extents_.</p>
    <li data-md="">
     <p>Effects: Initializes <code class="highlight"><span class="n">extents_</span></code> with <code class="highlight"><span class="n">other</span><span class="p">.</span><span class="n">get_extents</span><span class="p">()</span></code> and initializes <code class="highlight"><span class="n">strides_</span></code> with <code class="highlight"><span class="n">other</span><span class="p">.</span><span class="n">get_strides</span><span class="p">()</span></code>.</p>
    <li data-md="">
     <p>Postconditions: <code class="highlight"><span class="n">get_extents</span><span class="p">()</span><span class="o">==</span><span class="n">other</span><span class="p">.</span><span class="n">get_extents</span><span class="p">()</span></code> and <code class="highlight"><span class="n">get_strides</span><span class="p">()</span><span class="o">==</span><span class="n">other</span><span class="p">.</span><span class="n">get_strides</span><span class="p">()</span></code>.</p>
    <li data-md="">
     <p>Throws: nothing.</p>
   </ul>
   <p><b>26.7.�.4.2 layout_stride::mapping operations [mdspan.layout.stride.ops]</b></p>
<pre class="language-c++ highlight"><span class="n">Extents</span> <span class="nf">get_extents</span><span class="p">()</span> <span class="k">const</span> <span class="n">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p>Returns: extents_.</p>
   </ul>
<pre class="language-c++ highlight"><span class="n">array</span><span class="o">&lt;</span><span class="kr">typename</span> <span class="n">Extents</span><span class="o">::</span><span class="n">index_type</span><span class="p">,</span> <span class="n">Extents</span><span class="o">::</span><span class="n">rank</span><span class="p">()</span><span class="o">></span> <span class="n">get_strides</span><span class="p">()</span> <span class="k">const</span> <span class="n">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p>Returns: strides_.</p>
   </ul>
<pre class="language-c++ highlight"><span class="kr">typename</span> <span class="n">Extents</span><span class="o">::</span><span class="n">index_type</span> <span class="n">required_span_size</span><span class="p">()</span> <span class="k">const</span> <span class="n">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p>Returns: The maximum of <code class="highlight"><span class="n">get_extents</span><span class="p">().</span><span class="n">extent</span><span class="p">(</span><span class="n">r</span><span class="p">)</span><span class="o">*</span><span class="n">stride</span><span class="p">(</span><span class="n">r</span><span class="p">)</span></code> for all <code class="highlight"><span class="n">r</span></code> where 0 &lt;= <code class="highlight"><span class="n">r</span></code> &lt; <code class="highlight"><span class="n">get_extents</span><span class="p">().</span><span class="n">rank</span><span class="p">()</span></code></p>
   </ul>
<pre class="language-c++ highlight"><span class="n">template</span> <span class="o">&lt;</span><span class="n">class</span><span class="p">...</span> <span class="n">Indices</span><span class="o">></span>
  <span class="kr">typename</span> <span class="n">Extents</span><span class="o">::</span><span class="n">index_type</span> <span class="n">operator</span><span class="p">()(</span><span class="n">Indices</span><span class="p">...</span> <span class="n">i</span><span class="p">)</span> <span class="k">const</span> <span class="n">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p>Returns: If <code class="highlight"><span class="n">i</span><span class="p">...</span></code> is <code class="highlight"><span class="n">i0</span><span class="p">,</span> <span class="n">i1</span><span class="p">,</span> <span class="n">i2</span><span class="p">,</span></code>...<code class="highlight"><span class="p">,</span> <span class="n">ik</span></code> (where <code class="highlight"><span class="n">k</span><span class="o">==</span><span class="n">Extents</span><span class="o">::</span><span class="n">rank</span><span class="p">()</span> <span class="o">-</span> <span class="mi">1</span></code>) and <code class="highlight"><span class="n">s</span> <span class="o">=</span> <span class="n">get_strides</span><span class="p">()</span></code>, returns <code class="highlight"><span class="n">i0</span><span class="o">*</span><span class="n">s</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span><span class="o">+</span><span class="n">i1</span><span class="o">*</span><span class="n">s</span><span class="p">[</span><span class="mi">2</span><span class="p">]</span><span class="o">+</span></code>...<code class="highlight"><span class="o">+</span><span class="n">ik</span><span class="o">*</span><span class="n">s</span><span class="p">[</span><span class="n">k</span><span class="p">]</span></code></p>
    <li data-md="">
     <p>Remarks: This operator shall not participate in overload resolution unless</p>
    <li data-md="">
     <p><code class="highlight"><span class="k">sizeof</span><span class="p">...(</span><span class="n">Indices</span><span class="p">)</span><span class="o">==</span><span class="n">Extents</span><span class="o">::</span><span class="n">rank</span><span class="p">()</span></code>,</p>
    <li data-md="">
     <p>and <code class="highlight"><span class="n">is_convertible_v</span><span class="o">&lt;</span><span class="n">Indices</span><span class="p">,</span> <span class="k">typename</span> <span class="n">Extents</span><span class="o">::</span><span class="n">index_type</span><span class="o">></span> <span class="o">&amp;&amp;</span> <span class="p">...</span></code></p>
   </ul>
<pre class="language-c++ highlight"><span class="k">static</span> <span class="n">constexpr</span> <span class="kt">bool</span> <span class="nf">is_always_unique</span><span class="p">()</span> <span class="n">noexcept</span><span class="p">;</span>
<span class="k">static</span> <span class="n">constexpr</span> <span class="kt">bool</span> <span class="nf">is_always_strided</span><span class="p">()</span> <span class="n">noexcept</span><span class="p">;</span>
<span class="n">constexpr</span> <span class="kt">bool</span> <span class="nf">is_unique</span><span class="p">()</span> <span class="k">const</span> <span class="n">noexcept</span><span class="p">;</span>
<span class="n">constexpr</span> <span class="kt">bool</span> <span class="nf">is_strided</span><span class="p">()</span> <span class="k">const</span> <span class="n">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p>Returns: true</p>
   </ul>
<pre class="language-c++ highlight"><span class="k">static</span> <span class="n">constexpr</span> <span class="kt">bool</span> <span class="nf">is_always_contiguous</span><span class="p">()</span> <span class="n">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p>Returns: false</p>
   </ul>
<pre class="language-c++ highlight"><span class="n">constexpr</span> <span class="kt">bool</span> <span class="nf">is_contiguous</span><span class="p">()</span> <span class="k">const</span> <span class="n">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p>Returns: true if there is a permutation of the numbers <code class="highlight"><span class="mi">0</span><span class="p">,</span></code>...<code class="highlight"><span class="p">,</span><span class="n">Extents</span><span class="o">::</span><span class="n">rank</span><span class="p">()</span><span class="o">-</span><span class="mi">1</span></code> <code class="highlight"><span class="n">o</span><span class="p">(</span><span class="n">i</span><span class="p">)</span></code> with 0 &lt;= <code class="highlight"><span class="n">i</span></code> &lt; <code class="highlight"><span class="n">Extents</span><span class="o">::</span><span class="n">rank</span><span class="p">()</span></code> such that <code class="highlight"><span class="n">min</span><span class="p">(</span><span class="n">stride</span><span class="p">(</span><span class="n">o</span><span class="p">(</span><span class="n">i</span><span class="p">))</span><span class="o">==</span><span class="mi">1</span></code> and <code class="highlight"><span class="n">stride</span><span class="p">(</span><span class="n">o</span><span class="p">(</span><span class="n">i</span><span class="p">))</span><span class="o">==</span><span class="n">stride</span><span class="p">(</span><span class="n">o</span><span class="p">(</span><span class="n">i</span><span class="o">-</span><span class="mi">1</span><span class="p">))</span><span class="o">*</span><span class="n">get_extent</span><span class="p">.</span><span class="n">extent</span><span class="p">(</span><span class="n">o</span><span class="p">(</span><span class="n">i</span><span class="o">-</span><span class="mi">1</span><span class="p">))</span></code> with 1 &lt;= <code class="highlight"><span class="n">i</span></code> &lt; <code class="highlight"><span class="n">Extents</span><span class="o">::</span><span class="n">rank</span><span class="p">()</span></code> otherwise returns false</p>
   </ul>
<pre class="language-c++ highlight"><span class="kr">typename</span> <span class="n">Extents</span><span class="o">::</span><span class="n">index_type</span> <span class="n">stride</span><span class="p">(</span><span class="kt">size_t</span> <span class="n">r</span><span class="p">)</span> <span class="k">const</span> <span class="n">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p>Returns: <code class="highlight"><span class="n">strides_</span><span class="p">(</span><span class="n">r</span><span class="p">)</span></code></p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">OtherExtents</span><span class="o">></span>
  <span class="n">constexpr</span> <span class="kt">bool</span> <span class="n">operator</span><span class="o">==</span><span class="p">(</span><span class="k">const</span> <span class="n">mapping</span><span class="o">&lt;</span><span class="n">OtherExtents</span><span class="o">>&amp;</span> <span class="n">other</span><span class="p">)</span> <span class="k">const</span> <span class="n">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Returns:</em> <code class="highlight"><span class="n">get_extents</span><span class="p">()</span><span class="o">==</span><span class="n">other</span><span class="p">.</span><span class="n">get_extents</span><span class="p">()</span></code>.</p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">OtherExtents</span><span class="o">></span>
  <span class="n">constexpr</span> <span class="kt">bool</span> <span class="n">operator</span><span class="o">!=</span><span class="p">(</span><span class="k">const</span> <span class="n">mapping</span><span class="o">&lt;</span><span class="n">OtherExtents</span><span class="o">>&amp;</span> <span class="n">other</span><span class="p">)</span> <span class="k">const</span> <span class="n">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Returns:</em> <code class="highlight"><span class="n">get_extents</span><span class="p">()</span><span class="o">!=</span><span class="n">other</span><span class="p">.</span><span class="n">get_extents</span><span class="p">()</span></code>.</p>
   </ul>
   <p><br> <br></p>
   <p><b>26.7.� Accessor [mdspan.accessor]</b></p>
   <p><br> <b>26.7.�.1 Accessor requirements [mdspan.accessor.reqs]</b></p>
   <ol>
    <li data-md="">
     <p>An <em>accessor</em> is a class that converts a pointer and an offset into a reference. <em>[Note:</em> The intended semantic is that the reference refers to a value at the given offset from the given pointer. <em>—end note]</em></p>
    <li data-md="">
     <p>An <em>accessor</em> shall meet the requirements of <code class="highlight"><span class="n">DefaultConstructible</span></code>, <code class="highlight"><span class="n">CopyAssignable</span></code>, and the requirements in table �.</p>
   </ol>
   <p>In Table �:</p>
   <ul>
    <li data-md="">
     <p><code class="highlight"><span class="n">A</span></code> denotes an accessor.</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">a</span></code> denotes a value of type <code class="highlight"><span class="n">A</span></code>.</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">p</span></code> denotes a value of type <code class="highlight"><span class="n">A</span><span class="o">::</span><span class="n">pointer</span></code>.</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">i</span></code> denotes an integer.</p>
   </ul>
   <p>Table �: Accessor requirements</p>
   <table border="1">
    <tbody>
     <tr>
      <th>Expression
      <th>Return Type
      <th>Requirements/Notes
     <tr>
      <td><code class="highlight"><span class="n">A</span><span class="o">::</span><span class="n">value_type</span></code>
      <td>
      <td>
     <tr>
      <td><code class="highlight"><span class="n">A</span><span class="o">::</span><span class="n">pointer</span></code>
      <td>
      <td><em>Requires:</em> <code class="highlight"><span class="n">A</span><span class="o">::</span><span class="n">pointer</span></code> shall meet the requirements of random access iterator (<strong>[random.access.iterators]</strong>), and <code class="highlight"><span class="n">iterator_traits</span><span class="o">&lt;</span><span class="n">A</span><span class="o">::</span><span class="n">pointer</span><span class="o">>::</span><span class="n">value_type</span></code> shall be exactly <code class="highlight"><span class="n">A</span><span class="o">::</span><span class="n">value_type</span></code>.
     <tr>
      <td><code class="highlight"><span class="n">A</span><span class="o">::</span><span class="n">reference</span></code>
      <td>
      <td><em>Requires:</em> <code class="highlight"><span class="n">iterator_traits</span><span class="o">&lt;</span><span class="n">A</span><span class="o">::</span><span class="n">pointer</span><span class="o">>::</span><span class="n">reference</span></code> shall be convertible to <code class="highlight"><span class="n">A</span><span class="o">::</span><span class="n">reference</span></code> 
     <tr>
      <td><code class="highlight"><span class="n">a</span><span class="p">(</span><span class="n">p</span><span class="p">,</span> <span class="n">i</span><span class="p">)</span></code>
      <td><code class="highlight"><span class="n">A</span><span class="o">::</span><span class="n">reference</span></code>
      <td><em>[Note:</em> <code class="highlight"><span class="n">basic_mdspan</span></code> implementations behave as if they use this expression in place of <code class="highlight"><span class="n">p</span><span class="p">[</span><span class="n">i</span><span class="p">]</span></code>. <em>- end note]</em>
   </table>
   <p><br> <b>26.7.�.2 Class <code class="highlight"><span class="n">accessor_basic</span></code> [mdspan.accessor.basic]</b></p>
   <ol>
    <li data-md="">
     <p><code class="highlight"><span class="n">accessor_basic</span></code> meets the requirements of accessor.</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">accessor_basic</span></code> gives an accessor that has semantics equivalent to dereferencing a pointer to an array of values.</p>
    <li data-md="">
     <p>If <code class="highlight"><span class="n">T</span></code> is not an object type or is an array type, the program is ill-formed.</p>
   </ol>
<pre class="language-c++ highlight"><span class="n">namespace</span> <span class="n">std</span> <span class="p">{</span>
<span class="n">namespace</span> <span class="n">experimental</span> <span class="p">{</span>
<span class="n">namespace</span> <span class="n">fundamentals_v3</span> <span class="p">{</span>

<span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">T</span><span class="o">></span>
<span class="k">struct</span> <span class="n">accessor_basic</span> <span class="p">{</span>
  <span class="n">using</span> <span class="n">value_type</span> <span class="o">=</span> <span class="n">T</span><span class="p">;</span>
  <span class="n">using</span> <span class="n">pointer</span> <span class="o">=</span> <span class="n">T</span><span class="o">*</span><span class="p">;</span>
  <span class="n">using</span> <span class="n">reference</span> <span class="o">=</span> <span class="n">T</span><span class="o">&amp;</span><span class="p">;</span>

  <span class="c1">// [mdspan.accessor.basic.ops], &lt;code data-opaque bs-autolink-syntax='`accessor_basic`'>accessor_basic&lt;/code> operations</span>
<span class="c1"></span>  <span class="n">constexpr</span> <span class="n">reference</span> <span class="nf">operator</span><span class="p">()(</span><span class="n">pointer</span> <span class="n">p</span><span class="p">,</span> <span class="kt">ptrdiff_t</span> <span class="n">i</span><span class="p">)</span> <span class="k">const</span> <span class="n">noexcept</span><span class="p">;</span>
<span class="p">};</span>

<span class="p">}}}</span>
</pre>
   <p><br> <b>26.7.�.2.1 <code class="highlight"><span class="n">accessor_basic</span></code> operations [mdspan.accessor.basic.ops]</b></p>
<pre class="language-c++ highlight"><span class="n">constexpr</span> <span class="n">reference</span> <span class="nf">operator</span><span class="p">()(</span><span class="n">pointer</span> <span class="n">p</span><span class="p">,</span> <span class="kt">ptrdiff_t</span> <span class="n">i</span><span class="p">)</span> <span class="k">const</span> <span class="n">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Returns:</em> <code class="highlight"><span class="n">p</span><span class="p">[</span><span class="n">i</span><span class="p">]</span></code></p>
   </ul>
   <p><br> <br> <b>26.7.� Class template <code class="highlight"><span class="n">basic_mdspan</span></code> [mdspan.basic]</b></p>
   <ol>
    <li data-md="">
     <p>The <code class="highlight"><span class="n">basic_mdspan</span></code> class template maps a multi-index within a multi-index <em>domain</em> to a reference to an element in the <em>codomain</em> <code class="highlight"><span class="n">span</span></code>.</p>
    <li data-md="">
     <p>The multi-index domain space is the Cartesian product of the extents: <code class="highlight"><span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="n">extent</span><span class="p">(</span><span class="mi">0</span><span class="p">))</span> <span class="o">*</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="n">extent</span><span class="p">(</span><span class="mi">1</span><span class="p">))</span> <span class="o">*</span></code> ... <code class="highlight"><span class="o">*</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="n">extent</span><span class="p">(</span><span class="n">rank</span><span class="p">()</span> <span class="o">-</span> <span class="mi">1</span><span class="p">))</span></code>. Each extent may be statically or dynamically specified.</p>
    <li data-md="">
     <p>As with <code class="highlight"><span class="n">span</span></code>, the storage of the objects in the codomain <code class="highlight"><span class="n">span</span></code> of a <code class="highlight"><span class="n">basic_mdspan</span></code> is owned by some other object.</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">ElementType</span></code> is required to be a complete object type that is not an abstract class type or an array type.</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">Extents</span></code> is required to be a (cv-unqualified) specialization of <code class="highlight"><span class="n">extents</span></code>.</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">LayoutPolicy</span></code> is required to be a cv-unqualified object type.</p>
    <li data-md="">
     <p>If <code class="highlight"><span class="n">LayoutPolicy</span></code> does not meet the layout mapping policy requirements, the program is ill-formed.</p>
    <li data-md="">
     <p><code class="highlight"><span class="n">Accessor</span></code> is required to be a cv-unqualified object type.</p>
    <li data-md="">
     <p>If <code class="highlight"><span class="n">Accessor</span></code> does not meet the accessor requirements, or if <code class="highlight"><span class="n">Accessor</span><span class="o">::</span><span class="n">value_type</span></code> is not exactly <code class="highlight"><span class="n">ElementType</span></code>, the program is ill-formed.</p>
   </ol>
<pre class="highlight"><span class="k">namespace</span> <span class="n">std</span> <span class="p">{</span>
<span class="k">namespace</span> <span class="n">experimental</span> <span class="p">{</span>
<span class="k">namespace</span> <span class="n">fundamentals_v3</span> <span class="p">{</span>

<span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">ElementType</span><span class="p">,</span> <span class="k">class</span> <span class="nc">Extents</span><span class="p">,</span> <span class="k">class</span> <span class="nc">LayoutPolicy</span><span class="p">,</span> <span class="k">class</span> <span class="nc">Accessor</span><span class="o">></span>
<span class="k">class</span> <span class="nc">basic_mdspan</span> <span class="p">{</span>
<span class="k">public</span><span class="o">:</span>

  <span class="c1">// Domain and codomain types</span>
<span class="c1"></span>  <span class="k">using</span> <span class="n">layout</span> <span class="o">=</span> <span class="n">LayoutPolicy</span><span class="p">;</span>
  <span class="k">using</span> <span class="n">mapping</span> <span class="o">=</span> <span class="k">typename</span> <span class="n">layout</span><span class="o">::</span><span class="k">template</span> <span class="n">mapping</span><span class="o">&lt;</span><span class="n">Extents</span><span class="o">></span><span class="p">;</span>
  <span class="k">using</span> <span class="n">accessor</span> <span class="o">=</span> <span class="n">Accessor</span><span class="p">;</span>
  <span class="k">using</span> <span class="n">element_type</span> <span class="o">=</span> <span class="k">typename</span> <span class="n">accessor</span><span class="o">::</span><span class="n">value_type</span><span class="p">;</span>
  <span class="k">using</span> <span class="n">value_type</span> <span class="o">=</span> <span class="n">remove_cv_t</span><span class="o">&lt;</span><span class="n">element_type</span><span class="o">></span><span class="p">;</span>
  <span class="k">using</span> <span class="n">index_type</span> <span class="o">=</span> <span class="kt">ptrdiff_t</span> <span class="p">;</span>
  <span class="k">using</span> <span class="n">difference_type</span> <span class="o">=</span> <span class="kt">ptrdiff_t</span> <span class="p">;</span>
  <span class="k">using</span> <span class="n">pointer</span> <span class="o">=</span> <span class="k">typename</span> <span class="n">accessor</span><span class="o">::</span><span class="n">pointer</span><span class="p">;</span>
  <span class="k">using</span> <span class="n">reference</span> <span class="o">=</span> <span class="k">typename</span> <span class="n">accessor</span><span class="o">::</span><span class="n">reference</span><span class="p">;</span>

  <span class="c1">// [mdspan.basic.cons], basic_mdspan constructors, assignment, and destructor</span>
<span class="c1"></span>  <span class="k">constexpr</span> <span class="nf">basic_mdspan</span><span class="p">()</span> <span class="k">noexcept</span> <span class="o">=</span> <span class="k">default</span><span class="p">;</span>
  <span class="k">constexpr</span> <span class="nf">basic_mdspan</span><span class="p">(</span><span class="k">const</span> <span class="n">basic_mdspan</span><span class="o">&amp;</span><span class="p">)</span> <span class="k">noexcept</span> <span class="o">=</span> <span class="k">default</span><span class="p">;</span>
  <span class="k">constexpr</span> <span class="nf">basic_mdspan</span><span class="p">(</span><span class="n">basic_mdspan</span><span class="o">&amp;&amp;</span><span class="p">)</span> <span class="k">noexcept</span><span class="p">;</span>
  <span class="k">template</span><span class="o">&lt;</span><span class="n">class</span><span class="p">...</span> <span class="n">IndexType</span><span class="o">></span>
    <span class="k">explicit</span> <span class="k">constexpr</span> <span class="n">basic_mdspan</span><span class="p">(</span><span class="n">pointer</span> <span class="n">p</span><span class="p">,</span> <span class="n">IndexType</span><span class="p">...</span> <span class="n">dynamic_extents</span><span class="p">);</span>
  <span class="k">template</span><span class="o">&lt;</span><span class="n">class</span><span class="p">...</span> <span class="n">IndexType</span><span class="o">></span>
    <span class="k">explicit</span> <span class="k">constexpr</span> <span class="n">basic_mdspan</span><span class="p">(</span><span class="k">const</span> <span class="n">span</span><span class="o">&lt;</span><span class="n">element_type</span><span class="o">>&amp;</span> <span class="n">sp</span><span class="p">,</span> <span class="n">IndexType</span><span class="p">...</span> <span class="n">dynamic_extents</span><span class="p">);</span>
  <span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">IndexType</span><span class="p">,</span> <span class="kt">size_t</span> <span class="n">N</span><span class="o">></span>
    <span class="k">explicit</span> <span class="k">constexpr</span> <span class="n">basic_mdspan</span><span class="p">(</span><span class="n">pointer</span> <span class="n">p</span><span class="p">,</span> <span class="k">const</span> <span class="n">array</span><span class="o">&lt;</span><span class="n">IndexType</span><span class="p">,</span> <span class="n">N</span><span class="o">>&amp;</span> <span class="n">dynamic_extents</span><span class="p">);</span>
  <span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">IndexType</span><span class="p">,</span> <span class="kt">size_t</span> <span class="n">N</span><span class="o">></span>
    <span class="k">explicit</span> <span class="k">constexpr</span> <span class="n">basic_mdspan</span><span class="p">(</span><span class="k">const</span> <span class="n">span</span><span class="o">&lt;</span><span class="n">element_type</span><span class="o">>&amp;</span> <span class="n">sp</span><span class="p">,</span> <span class="k">const</span> <span class="n">array</span><span class="o">&lt;</span><span class="n">IndexType</span><span class="p">,</span> <span class="n">N</span><span class="o">>&amp;</span> <span class="n">dynamic_extents</span><span class="p">);</span>
  <span class="k">constexpr</span> <span class="nf">basic_mdspan</span><span class="p">(</span><span class="n">pointer</span> <span class="n">p</span><span class="p">,</span> <span class="k">const</span> <span class="n">mapping</span><span class="o">&amp;</span> <span class="n">m</span><span class="p">);</span>
  <span class="k">constexpr</span> <span class="nf">basic_mdspan</span><span class="p">(</span><span class="k">const</span> <span class="n">span</span><span class="o">&lt;</span><span class="n">element_type</span><span class="o">>&amp;</span> <span class="n">sp</span><span class="p">,</span> <span class="k">const</span> <span class="n">mapping</span><span class="o">&amp;</span> <span class="n">m</span><span class="p">);</span>
  <span class="k">constexpr</span> <span class="nf">basic_mdspan</span><span class="p">(</span><span class="n">pointer</span> <span class="n">p</span><span class="p">,</span> <span class="k">const</span> <span class="n">mapping</span><span class="o">&amp;</span> <span class="n">m</span><span class="p">,</span> <span class="k">const</span> <span class="n">accessor</span><span class="o">&amp;</span> <span class="n">a</span><span class="p">);</span>
  <span class="k">constexpr</span> <span class="nf">basic_mdspan</span><span class="p">(</span><span class="k">const</span> <span class="n">span</span><span class="o">&lt;</span><span class="n">element_type</span><span class="o">>&amp;</span> <span class="n">sp</span><span class="p">,</span> <span class="k">const</span> <span class="n">mapping</span><span class="o">&amp;</span> <span class="n">m</span><span class="p">,</span> <span class="k">const</span> <span class="n">accessor</span><span class="o">&amp;</span> <span class="n">a</span><span class="p">);</span>
  <span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">OtherElementType</span><span class="p">,</span> <span class="k">class</span> <span class="nc">OtherExtents</span><span class="p">,</span> <span class="k">class</span> <span class="nc">OtherLayoutPolicy</span><span class="p">,</span> <span class="k">class</span> <span class="nc">OtherAccessor</span><span class="o">></span>
    <span class="k">constexpr</span> <span class="n">basic_mdspan</span><span class="p">(</span><span class="k">const</span> <span class="n">basic_mdspan</span><span class="o">&lt;</span><span class="n">OtherElementType</span><span class="p">,</span> <span class="n">OtherExtents</span><span class="p">,</span> <span class="n">OtherLayoutPolicy</span><span class="p">,</span> <span class="n">OtherAccessor</span><span class="o">>&amp;</span> <span class="n">other</span><span class="p">);</span>

  <span class="o">~</span><span class="n">basic_mdspan</span><span class="p">()</span> <span class="o">=</span> <span class="k">default</span><span class="p">;</span>

  <span class="k">constexpr</span> <span class="n">basic_mdspan</span><span class="o">&amp;</span> <span class="k">operator</span><span class="o">=</span><span class="p">(</span><span class="k">const</span> <span class="n">basic_mdspan</span><span class="o">&amp;</span><span class="p">)</span> <span class="k">noexcept</span> <span class="o">=</span> <span class="k">default</span><span class="p">;</span>
  <span class="k">constexpr</span> <span class="n">basic_mdspan</span><span class="o">&amp;</span> <span class="k">operator</span><span class="o">=</span><span class="p">(</span><span class="n">basic_mdspan</span><span class="o">&amp;&amp;</span><span class="p">)</span> <span class="k">noexcept</span> <span class="o">=</span> <span class="k">default</span><span class="p">;</span>
  <span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">OtherElementType</span><span class="p">,</span> <span class="k">class</span> <span class="nc">OtherExtents</span><span class="p">,</span> <span class="k">class</span> <span class="nc">OtherLayoutPolicy</span><span class="p">,</span> <span class="k">class</span> <span class="nc">OtherAccessor</span><span class="o">></span>
    <span class="k">constexpr</span> <span class="n">basic_mdspan</span><span class="o">&amp;</span> <span class="k">operator</span><span class="o">=</span><span class="p">(</span><span class="k">const</span> <span class="n">basic_mdspan</span><span class="o">&lt;</span><span class="n">OtherElementType</span><span class="p">,</span> <span class="n">OtherExtents</span><span class="p">,</span> <span class="n">OtherLayoutPolicy</span><span class="p">,</span> <span class="n">OtherAccessor</span><span class="o">>&amp;</span> <span class="n">other</span><span class="p">)</span> <span class="k">noexcept</span><span class="p">;</span>

  <span class="c1">// [mdspan.basic.mapping], basic_mdspan mapping domain multi-index to access codomain element</span>
<span class="c1"></span>  <span class="k">constexpr</span> <span class="n">reference</span> <span class="k">operator</span><span class="p">[](</span><span class="n">index_type</span><span class="p">)</span> <span class="k">const</span> <span class="k">noexcept</span><span class="p">;</span>
  <span class="k">template</span><span class="o">&lt;</span><span class="n">class</span><span class="p">...</span> <span class="n">IndexType</span><span class="o">></span>
    <span class="k">constexpr</span> <span class="n">reference</span> <span class="k">operator</span><span class="p">()(</span><span class="n">IndexType</span><span class="p">...</span> <span class="n">indices</span><span class="p">)</span> <span class="k">const</span> <span class="k">noexcept</span><span class="p">;</span>
  <span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">IndexType</span><span class="p">,</span> <span class="kt">size_t</span> <span class="n">N</span><span class="o">></span>
    <span class="k">constexpr</span> <span class="n">reference</span> <span class="k">operator</span><span class="p">()(</span><span class="k">const</span> <span class="n">array</span><span class="o">&lt;</span><span class="n">IndexType</span><span class="p">,</span> <span class="n">N</span><span class="o">>&amp;</span> <span class="n">indices</span><span class="p">)</span> <span class="k">const</span> <span class="k">noexcept</span><span class="p">;</span>
  <span class="n">accessor</span> <span class="nf">get_accessor</span><span class="p">()</span> <span class="k">const</span><span class="p">;</span>

  <span class="c1">// [mdspan.basic.domobs], basic_mdspan observers of the domain multi-index space</span>
<span class="c1"></span>  <span class="k">static</span> <span class="k">constexpr</span> <span class="kt">int</span> <span class="nf">rank</span><span class="p">()</span> <span class="k">noexcept</span><span class="p">;</span>
  <span class="k">static</span> <span class="k">constexpr</span> <span class="kt">int</span> <span class="nf">rank_dynamic</span><span class="p">()</span> <span class="k">noexcept</span><span class="p">;</span>
  <span class="k">static</span> <span class="k">constexpr</span> <span class="n">index_type</span> <span class="nf">static_extent</span><span class="p">(</span><span class="kt">size_t</span><span class="p">)</span> <span class="k">noexcept</span><span class="p">;</span>

  <span class="k">constexpr</span> <span class="n">Extents</span> <span class="nf">get_extents</span><span class="p">()</span> <span class="k">const</span> <span class="k">noexcept</span><span class="p">;</span>
  <span class="k">constexpr</span> <span class="n">index_type</span> <span class="nf">extent</span><span class="p">(</span><span class="kt">size_t</span><span class="p">)</span> <span class="k">const</span> <span class="k">noexcept</span><span class="p">;</span>
  <span class="k">constexpr</span> <span class="n">index_type</span> <span class="nf">size</span><span class="p">()</span> <span class="k">const</span> <span class="k">noexcept</span><span class="p">;</span>
  <span class="k">constexpr</span> <span class="n">index_type</span> <span class="nf">unique_size</span><span class="p">()</span> <span class="k">const</span> <span class="k">noexcept</span><span class="p">;</span>

  <span class="c1">// [mdspan.basic.codomain], basic_mdspan observers of the codomain</span>
<span class="c1"></span>  <span class="k">constexpr</span> <span class="n">span</span><span class="o">&lt;</span><span class="n">element_type</span><span class="o">></span> <span class="n">span</span><span class="p">()</span> <span class="k">const</span> <span class="k">noexcept</span><span class="p">;</span>

  <span class="c1">// [mdspan.basic.obs], basic_mdspan observers of the mapping</span>
<span class="c1"></span>  <span class="k">static</span> <span class="k">constexpr</span> <span class="kt">bool</span> <span class="nf">is_always_unique</span><span class="p">()</span> <span class="k">noexcept</span><span class="p">;</span>
  <span class="k">static</span> <span class="k">constexpr</span> <span class="kt">bool</span> <span class="nf">is_always_contiguous</span><span class="p">()</span> <span class="k">noexcept</span><span class="p">;</span>
  <span class="k">static</span> <span class="k">constexpr</span> <span class="kt">bool</span> <span class="nf">is_always_strided</span><span class="p">()</span> <span class="k">noexcept</span><span class="p">;</span>

  <span class="k">constexpr</span> <span class="n">mapping</span> <span class="nf">get_mapping</span><span class="p">()</span> <span class="k">const</span> <span class="k">noexcept</span><span class="p">;</span>
  <span class="k">constexpr</span> <span class="kt">bool</span> <span class="nf">is_unique</span><span class="p">()</span> <span class="k">const</span> <span class="k">noexcept</span><span class="p">;</span>
  <span class="k">constexpr</span> <span class="kt">bool</span> <span class="nf">is_contiguous</span><span class="p">()</span> <span class="k">const</span> <span class="k">noexcept</span><span class="p">;</span>
  <span class="k">constexpr</span> <span class="kt">bool</span> <span class="nf">is_strided</span><span class="p">()</span> <span class="k">const</span> <span class="k">noexcept</span><span class="p">;</span>
  <span class="k">constexpr</span> <span class="n">index_type</span> <span class="nf">stride</span><span class="p">(</span><span class="kt">size_t</span><span class="p">)</span> <span class="k">const</span><span class="p">;</span>

<span class="k">private</span><span class="o">:</span>
  <span class="n">accessor</span> <span class="n">acc_</span><span class="p">;</span> <span class="c1">// </span><i><span class="c1">exposition only</span></i>
<span class="c1"></span>  <span class="n">mapping</span> <span class="n">map_</span><span class="p">;</span> <span class="c1">// </span><i><span class="c1">exposition only</span></i>
<span class="c1"></span>  <span class="n">pointer</span> <span class="n">ptr_</span><span class="p">;</span> <span class="c1">// </span><i><span class="c1">exposition only</span></i>
<span class="c1"></span><span class="p">};</span>

<span class="p">}}}</span>
</pre>
   <p><br> <b>26.7.�.1 <code class="highlight"><span class="n">basic_mdspan</span></code> constructors, assignment, and destructor [mdspan.basic.cons]</b> // Mapping domain multi-index to access codomain element</p>
<pre class="language-c++ highlight"><span class="n">constexpr</span> <span class="nf">basic_mdspan</span><span class="p">()</span> <span class="n">noexcept</span> <span class="o">=</span> <span class="k">default</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Effects:</em></p>
     <ul>
      <li data-md="">
       <p>zero-initializes <code class="highlight"><span class="n">ptr_</span></code></p>
      <li data-md="">
       <p>value-initializes <code class="highlight"><span class="n">map_</span></code></p>
      <li data-md="">
       <p>value-initializes <code class="highlight"><span class="n">acc_</span></code></p>
     </ul>
    <li data-md="">
     <p><em>Postconditions:</em></p>
     <ul>
      <li data-md="">
       <p><code class="highlight"><span class="n">size</span><span class="p">()</span><span class="o">==</span><span class="mi">0</span></code></p>
      <li data-md="">
       <p><code class="highlight"><span class="n">get_extents</span><span class="p">()</span><span class="o">==</span><span class="n">Extents</span><span class="p">()</span></code></p>
      <li data-md="">
       <p><code class="highlight"><span class="n">get_mapping</span><span class="p">()</span><span class="o">==</span><span class="n">mapping</span><span class="p">()</span></code></p>
     </ul>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><span class="n">constexpr</span> <span class="nf">basic_mdspan</span><span class="p">(</span><span class="k">const</span> <span class="n">basic_mdspan</span><span class="o">&amp;</span> <span class="n">other</span><span class="p">)</span> <span class="n">noexcept</span> <span class="o">=</span> <span class="k">default</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Effects:</em></p>
     <ul>
      <li data-md="">
       <p>initializes <code class="highlight"><span class="n">ptr_</span></code> with <code class="highlight"><span class="n">other</span><span class="p">.</span><span class="n">ptr_</span></code></p>
      <li data-md="">
       <p>initializes <code class="highlight"><span class="n">map_</span></code> with <code class="highlight"><span class="n">other</span><span class="p">.</span><span class="n">map_</span></code></p>
      <li data-md="">
       <p>initializes <code class="highlight"><span class="n">acc_</span></code> with <code class="highlight"><span class="n">other</span><span class="p">.</span><span class="n">acc_</span></code></p>
     </ul>
    <li data-md="">
     <p><em>Postconditions:</em></p>
     <ul>
      <li data-md="">
       <p><code class="highlight"><span class="n">size</span><span class="p">()</span><span class="o">==</span><span class="n">other</span><span class="p">.</span><span class="n">size</span><span class="p">()</span></code></p>
      <li data-md="">
       <p><code class="highlight"><span class="n">get_extents</span><span class="p">()</span><span class="o">==</span><span class="n">other</span><span class="p">.</span><span class="n">get_extents</span><span class="p">()</span></code></p>
      <li data-md="">
       <p><code class="highlight"><span class="n">get_mapping</span><span class="p">()</span><span class="o">==</span><span class="n">other</span><span class="p">.</span><span class="n">get_mapping</span><span class="p">()</span></code></p>
     </ul>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><span class="n">constexpr</span> <span class="nf">basic_mdspan</span><span class="p">(</span><span class="n">basic_mdspan</span><span class="o">&amp;&amp;</span> <span class="n">other</span><span class="p">)</span> <span class="n">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Effects:</em></p>
     <ul>
      <li data-md="">
       <p>initializes <code class="highlight"><span class="n">ptr_</span></code> with <code class="highlight"><span class="n">move</span><span class="p">(</span><span class="n">other</span><span class="p">.</span><span class="n">ptr_</span><span class="p">)</span></code></p>
      <li data-md="">
       <p>initializes <code class="highlight"><span class="n">map_</span></code> with <code class="highlight"><span class="n">move</span><span class="p">(</span><span class="n">other</span><span class="p">.</span><span class="n">map_</span><span class="p">)</span></code></p>
      <li data-md="">
       <p>initializes <code class="highlight"><span class="n">acc_</span></code> with <code class="highlight"><span class="n">move</span><span class="p">(</span><span class="n">other</span><span class="p">.</span><span class="n">acc_</span><span class="p">)</span></code></p>
     </ul>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><span class="n">template</span><span class="o">&lt;</span><span class="n">class</span><span class="p">...</span> <span class="n">IndexType</span><span class="o">></span>
  <span class="n">explicit</span> <span class="n">constexpr</span> <span class="n">basic_mdspan</span><span class="p">(</span><span class="n">pointer</span> <span class="n">ptr</span><span class="p">,</span> <span class="n">IndexType</span><span class="p">...</span> <span class="n">dynamic_extents</span><span class="p">);</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Requires:</em> <code class="highlight"><span class="p">[</span><span class="n">ptr</span><span class="p">,</span> <span class="n">ptr</span><span class="o">+</span><span class="n">mapping</span><span class="p">(</span><span class="n">Extents</span><span class="p">(</span><span class="n">dynamic_extents</span><span class="p">...)).</span><span class="n">required_span_size</span><span class="p">())</span></code> shall be a valid range.</p>
    <li data-md="">
     <p><em>Effects:</em></p>
     <ul>
      <li data-md="">
       <p>initializes <code class="highlight"><span class="n">ptr_</span></code> with <code class="highlight"><span class="n">ptr</span></code></p>
      <li data-md="">
       <p>initializes <code class="highlight"><span class="n">map_</span></code> with <code class="highlight"><span class="n">Extents</span><span class="p">(</span><span class="n">dynamic_extents</span><span class="p">...)</span></code></p>
      <li data-md="">
       <p>value-initializes <code class="highlight"><span class="n">acc_</span></code></p>
     </ul>
    <li data-md="">
     <p><em>Postconditions:</em></p>
     <ul>
      <li data-md="">
       <p><code class="highlight"><span class="n">get_extents</span><span class="p">()</span><span class="o">==</span><span class="n">Extents</span><span class="p">(</span><span class="n">dynamic_extents</span><span class="p">...)</span></code></p>
      <li data-md="">
       <p><code class="highlight"><span class="n">get_mapping</span><span class="p">()</span><span class="o">==</span><span class="n">mapping</span><span class="p">(</span><span class="n">Extents</span><span class="p">(</span><span class="n">dynamic_extents</span><span class="p">...))</span></code></p>
     </ul>
    <li data-md="">
     <p><em>Remarks:</em> This constructor will not participate in overload resolution unless:</p>
     <ul>
      <li data-md="">
       <p><code class="highlight"><span class="p">(</span><span class="n">is_convertible_v</span><span class="o">&lt;</span><span class="n">IndexType</span><span class="p">,</span> <span class="n">index_type</span><span class="o">></span> <span class="o">&amp;&amp;</span> <span class="p">...)</span></code>,</p>
      <li data-md="">
       <p><code class="highlight"><span class="k">sizeof</span><span class="p">...(</span><span class="n">dynamic_extents</span><span class="p">)</span><span class="o">==</span><span class="n">rank_dynamic</span><span class="p">()</span></code>, and</p>
      <li data-md="">
       <p><code class="highlight"><span class="n">is_constructible_v</span><span class="o">&lt;</span><span class="n">mapping</span><span class="p">,</span> <span class="n">Extents</span><span class="o">></span></code>.</p>
     </ul>
    <li data-md="">
     <p><em>Throws:</em> Nothing.</p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><span class="n">template</span><span class="o">&lt;</span><span class="n">class</span><span class="p">...</span> <span class="n">IndexType</span><span class="o">></span>
  <span class="n">explicit</span> <span class="n">constexpr</span> <span class="n">basic_mdspan</span><span class="p">(</span><span class="k">const</span> <span class="n">span</span><span class="o">&lt;</span><span class="n">element_type</span><span class="o">>&amp;</span> <span class="n">sp</span><span class="p">,</span> <span class="n">IndexType</span><span class="p">...</span> <span class="n">dynamic_extents</span><span class="p">);</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Requires:</em> <code class="highlight"><span class="n">sp</span><span class="p">.</span><span class="n">size</span><span class="p">()</span><span class="o">==</span><span class="n">mapping</span><span class="p">(</span><span class="n">Extents</span><span class="p">(</span><span class="n">dynamic_extents</span><span class="p">...)).</span><span class="n">required_span_size</span><span class="p">()</span></code></p>
    <li data-md="">
     <p><em>Effects:</em></p>
     <ul>
      <li data-md="">
       <p>initializes <code class="highlight"><span class="n">ptr_</span></code> with <code class="highlight"><span class="n">sp</span><span class="p">.</span><span class="n">data</span><span class="p">()</span></code></p>
      <li data-md="">
       <p>value-initializes <code class="highlight"><span class="n">map_</span></code></p>
      <li data-md="">
       <p>value-initializes <code class="highlight"><span class="n">acc_</span></code></p>
     </ul>
    <li data-md="">
     <p><em>Postconditions:</em></p>
     <ul>
      <li data-md="">
       <p><code class="highlight"><span class="n">get_extents</span><span class="p">()</span><span class="o">==</span><span class="n">Extents</span><span class="p">(</span><span class="n">dynamic_extents</span><span class="p">...)</span></code></p>
      <li data-md="">
       <p><code class="highlight"><span class="n">get_mapping</span><span class="p">()</span><span class="o">==</span><span class="n">mapping</span><span class="p">(</span><span class="n">Extents</span><span class="p">(</span><span class="n">dynamic_extents</span><span class="p">...))</span></code></p>
     </ul>
    <li data-md="">
     <p><em>Remarks:</em> This constructor will not participate in overload resolution unless:</p>
     <ul>
      <li data-md="">
       <p><code class="highlight"><span class="p">(</span><span class="n">is_convertible_v</span><span class="o">&lt;</span><span class="n">IndexType</span><span class="p">,</span> <span class="n">index_type</span><span class="o">></span> <span class="o">&amp;&amp;</span> <span class="p">...)</span></code>,</p>
      <li data-md="">
       <p><code class="highlight"><span class="k">sizeof</span><span class="p">...(</span><span class="n">dynamic_extents</span><span class="p">)</span><span class="o">==</span><span class="n">rank_dynamic</span><span class="p">()</span></code>,</p>
      <li data-md="">
       <p><code class="highlight"><span class="n">is_constructible_v</span><span class="o">&lt;</span><span class="n">mapping</span><span class="p">,</span> <span class="n">Extents</span><span class="o">></span></code>.</p>
     </ul>
    <li data-md="">
     <p><em>Throws:</em> Nothing.</p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">IndexType</span><span class="p">,</span> <span class="kt">size_t</span> <span class="n">N</span><span class="o">></span>
  <span class="n">explicit</span> <span class="n">constexpr</span> <span class="n">basic_mdspan</span><span class="p">(</span><span class="n">pointer</span> <span class="n">p</span><span class="p">,</span> <span class="k">const</span> <span class="n">array</span><span class="o">&lt;</span><span class="n">IndexType</span><span class="p">,</span> <span class="n">N</span><span class="o">>&amp;</span> <span class="n">dynamic_extents</span><span class="p">);</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Requires:</em> <code class="highlight"><span class="p">[</span><span class="n">ptr</span><span class="p">,</span> <span class="n">ptr</span><span class="o">+</span><span class="n">mapping</span><span class="p">(</span><span class="n">Extents</span><span class="p">(</span><span class="n">dynamic_extents</span><span class="p">)).</span><span class="n">required_span_size</span><span class="p">())</span></code> shall be a valid range.</p>
    <li data-md="">
     <p><em>Effects:</em> Equivalent to <code class="highlight"><span class="n">basic_mdspan</span><span class="p">(</span><span class="n">p</span><span class="p">,</span> <span class="n">dynamic_extents</span><span class="p">[</span><span class="n">Rs</span><span class="p">]...)</span></code>, with <code class="highlight"><span class="n">Rs</span><span class="p">...</span></code> from <code class="highlight"><span class="n">index_sequence</span><span class="o">&lt;</span><span class="n">Rs</span><span class="p">...</span><span class="o">></span></code> matching <code class="highlight"><span class="n">make_index_sequence</span><span class="o">&lt;</span><span class="n">N</span><span class="o">></span></code>.</p>
    <li data-md="">
     <p><em>Remarks:</em> This constructor does not participate in overload resolution unless</p>
     <ul>
      <li data-md="">
       <p><code class="highlight"><span class="n">IndexType</span></code> is convertible to <code class="highlight"><span class="n">index_type</span></code>, and</p>
      <li data-md="">
       <p><code class="highlight"><span class="n">N</span><span class="o">==</span><span class="n">rank_dynamic</span><span class="p">()</span></code>, and</p>
      <li data-md="">
       <p><code class="highlight"><span class="n">is_constructible_v</span><span class="o">&lt;</span><span class="n">mapping</span><span class="p">,</span> <span class="n">Extents</span><span class="o">></span></code>.</p>
     </ul>
    <li data-md="">
     <p><em>Throws:</em> Nothing.</p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">IndexType</span><span class="p">,</span> <span class="kt">size_t</span> <span class="n">N</span><span class="o">></span>
  <span class="n">explicit</span> <span class="n">constexpr</span> <span class="n">basic_mdspan</span><span class="p">(</span><span class="k">const</span> <span class="n">span</span><span class="o">&lt;</span><span class="n">element_type</span><span class="o">>&amp;</span> <span class="n">sp</span><span class="p">,</span> <span class="k">const</span> <span class="n">array</span><span class="o">&lt;</span><span class="n">IndexType</span><span class="p">,</span> <span class="n">N</span><span class="o">>&amp;</span> <span class="n">dynamic_extents</span><span class="p">);</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Requires:</em> <code class="highlight"><span class="n">sp</span><span class="p">.</span><span class="n">size</span><span class="p">()</span><span class="o">==</span><span class="n">mapping</span><span class="p">(</span><span class="n">Extents</span><span class="p">(</span><span class="n">dynamic_extents</span><span class="p">)).</span><span class="n">required_span_size</span><span class="p">()</span></code></p>
    <li data-md="">
     <p><em>Effects:</em> Equivalent to <code class="highlight"><span class="n">basic_mdspan</span><span class="p">(</span><span class="n">sp</span><span class="p">.</span><span class="n">data</span><span class="p">(),</span> <span class="n">dynamic_extents</span><span class="p">[</span><span class="n">Rs</span><span class="p">]...)</span></code>, with <code class="highlight"><span class="n">Rs</span><span class="p">...</span></code> from <code class="highlight"><span class="n">index_sequence</span><span class="o">&lt;</span><span class="n">Rs</span><span class="p">...</span><span class="o">></span></code> matching <code class="highlight"><span class="n">make_index_sequence</span><span class="o">&lt;</span><span class="n">N</span><span class="o">></span></code>.</p>
    <li data-md="">
     <p><em>Remarks:</em> This constructor does not participate in overload resolution unless</p>
     <ul>
      <li data-md="">
       <p><code class="highlight"><span class="n">IndexType</span></code> is convertible to <code class="highlight"><span class="n">index_type</span></code>,</p>
      <li data-md="">
       <p><code class="highlight"><span class="n">N</span><span class="o">==</span><span class="n">rank_dynamic</span><span class="p">()</span></code>,</p>
      <li data-md="">
       <p><code class="highlight"><span class="n">is_constructible_v</span><span class="o">&lt;</span><span class="n">mapping</span><span class="p">,</span> <span class="n">Extents</span><span class="o">></span></code>.</p>
     </ul>
    <li data-md="">
     <p><em>Throws:</em> Nothing.</p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><span class="n">constexpr</span> <span class="nf">basic_mdspan</span><span class="p">(</span><span class="n">pointer</span> <span class="n">p</span><span class="p">,</span> <span class="k">const</span> <span class="n">mapping</span><span class="o">&amp;</span> <span class="n">m</span><span class="p">);</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Requires:</em> <code class="highlight"><span class="p">[</span><span class="n">ptr</span><span class="p">,</span> <span class="n">ptr</span><span class="o">+</span><span class="n">m</span><span class="p">.</span><span class="n">required_span_size</span><span class="p">())</span></code> shall be a valid range.</p>
    <li data-md="">
     <p><em>Effects:</em></p>
     <ul>
      <li data-md="">
       <p>initializes <code class="highlight"><span class="n">ptr_</span></code> with <code class="highlight"><span class="n">p</span></code></p>
      <li data-md="">
       <p>initializes <code class="highlight"><span class="n">map_</span></code> with <code class="highlight"><span class="n">m</span></code></p>
      <li data-md="">
       <p>value-initializes <code class="highlight"><span class="n">acc_</span></code></p>
     </ul>
    <li data-md="">
     <p><em>Postconditions:</em></p>
     <ul>
      <li data-md="">
       <p><code class="highlight"><span class="n">get_extents</span><span class="p">()</span><span class="o">==</span><span class="n">m</span><span class="p">.</span><span class="n">get_extents</span><span class="p">()</span></code></p>
      <li data-md="">
       <p><code class="highlight"><span class="n">get_mapping</span><span class="p">()</span><span class="o">==</span><span class="n">m</span></code></p>
     </ul>
    <li data-md="">
     <p><em>Throws:</em> Nothing.</p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><span class="n">constexpr</span> <span class="nf">basic_mdspan</span><span class="p">(</span><span class="k">const</span> <span class="n">span</span><span class="o">&lt;</span><span class="n">element_type</span><span class="o">>&amp;</span> <span class="n">sp</span><span class="p">,</span> <span class="k">const</span> <span class="n">mapping</span><span class="o">&amp;</span> <span class="n">m</span><span class="p">);</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Requires:</em> <code class="highlight"><span class="n">sp</span><span class="p">.</span><span class="n">size</span><span class="p">()</span><span class="o">==</span><span class="n">m</span><span class="p">.</span><span class="n">required_span_size</span><span class="p">()</span></code></p>
    <li data-md="">
     <p><em>Effects:</em> Equivalent to <code class="highlight"><span class="n">basic_mdspan</span><span class="p">(</span><span class="n">sp</span><span class="p">.</span><span class="n">data</span><span class="p">(),</span> <span class="n">m</span><span class="p">)</span></code></p>
    <li data-md="">
     <p><em>Remarks:</em> This constructor does not participate in overload resolution unless <code class="highlight"><span class="n">is_constructible_v</span><span class="o">&lt;</span><span class="n">mapping</span><span class="p">,</span> <span class="n">Extents</span><span class="o">></span></code>.</p>
    <li data-md="">
     <p><em>Throws:</em> Nothing.</p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><span class="n">constexpr</span> <span class="nf">basic_mdspan</span><span class="p">(</span><span class="n">pointer</span> <span class="n">p</span><span class="p">,</span> <span class="k">const</span> <span class="n">mapping</span><span class="o">&amp;</span> <span class="n">m</span><span class="p">,</span> <span class="k">const</span> <span class="n">accessor</span><span class="o">&amp;</span> <span class="n">a</span><span class="p">);</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Requires:</em> <code class="highlight"><span class="p">[</span><span class="n">ptr</span><span class="p">,</span> <span class="n">ptr</span><span class="o">+</span><span class="n">m</span><span class="p">.</span><span class="n">required_span_size</span><span class="p">())</span></code> shall be a valid range.</p>
    <li data-md="">
     <p><em>Effects:</em></p>
     <ul>
      <li data-md="">
       <p>initializes <code class="highlight"><span class="n">ptr_</span></code> with <code class="highlight"><span class="n">p</span></code></p>
      <li data-md="">
       <p>initializes <code class="highlight"><span class="n">map_</span></code> with <code class="highlight"><span class="n">m</span></code></p>
      <li data-md="">
       <p>initializes <code class="highlight"><span class="n">acc_</span></code> with <code class="highlight"><span class="n">a</span></code></p>
     </ul>
    <li data-md="">
     <p><em>Postconditions:</em></p>
     <ul>
      <li data-md="">
       <p><code class="highlight"><span class="n">get_extents</span><span class="p">()</span><span class="o">==</span><span class="n">m</span><span class="p">.</span><span class="n">get_extents</span><span class="p">()</span></code></p>
      <li data-md="">
       <p><code class="highlight"><span class="n">get_mapping</span><span class="p">()</span><span class="o">==</span><span class="n">m</span></code></p>
     </ul>
    <li data-md="">
     <p><em>Throws:</em> Nothing.</p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><span class="n">constexpr</span> <span class="nf">basic_mdspan</span><span class="p">(</span><span class="k">const</span> <span class="n">span</span><span class="o">&lt;</span><span class="n">element_type</span><span class="o">>&amp;</span> <span class="n">sp</span><span class="p">,</span> <span class="k">const</span> <span class="n">mapping</span><span class="o">&amp;</span> <span class="n">m</span><span class="p">,</span> <span class="k">const</span> <span class="n">accessor</span><span class="o">&amp;</span> <span class="n">a</span><span class="p">);</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Requires:</em> <code class="highlight"><span class="n">sp</span><span class="p">.</span><span class="n">size</span><span class="p">()</span><span class="o">==</span><span class="n">m</span><span class="p">.</span><span class="n">required_span_size</span><span class="p">()</span></code></p>
    <li data-md="">
     <p><em>Effects:</em> Equivalent to <code class="highlight"><span class="n">basic_mdspan</span><span class="p">(</span><span class="n">sp</span><span class="p">.</span><span class="n">data</span><span class="p">(),</span> <span class="n">m</span><span class="p">,</span> <span class="n">a</span><span class="p">)</span></code></p>
    <li data-md="">
     <p><em>Remarks:</em> This constructor does not participate in overload resolution unless</p>
     <ul>
      <li data-md="">
       <p><code class="highlight"><span class="n">is_constructible_v</span><span class="o">&lt;</span><span class="n">mapping</span><span class="p">,</span> <span class="n">Extents</span><span class="o">></span></code>.</p>
     </ul>
    <li data-md="">
     <p><em>Throws:</em> Nothing.</p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">OtherElementType</span><span class="p">,</span> <span class="n">class</span> <span class="n">OtherExtents</span><span class="p">,</span> <span class="n">class</span> <span class="n">OtherLayoutPolicy</span><span class="p">,</span> <span class="n">class</span> <span class="n">OtherAccessor</span><span class="o">></span>
  <span class="n">constexpr</span> <span class="n">basic_mdspan</span><span class="p">(</span><span class="k">const</span> <span class="n">basic_mdspan</span><span class="o">&lt;</span><span class="n">OtherElementType</span><span class="p">,</span> <span class="n">OtherExtents</span><span class="p">,</span> <span class="n">OtherLayoutPolicy</span><span class="p">,</span> <span class="n">OtherAccessor</span><span class="o">>&amp;</span> <span class="n">other</span><span class="p">);</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Requires:</em></p>
     <ul>
      <li data-md="">
       <p>For all <code class="highlight"><span class="n">r</span></code> in the range <code class="highlight"><span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="n">rank</span><span class="p">())</span></code>, if <code class="highlight"><span class="n">other</span><span class="p">.</span><span class="n">static_extent</span><span class="p">(</span><span class="n">r</span><span class="p">)</span><span class="o">==</span><span class="n">dynamic_extent</span></code> or <code class="highlight"><span class="n">static_extent</span><span class="p">(</span><span class="n">r</span><span class="p">)</span><span class="o">==</span><span class="n">dynamic_extent</span></code>, then <code class="highlight"><span class="n">other</span><span class="p">.</span><span class="n">extent</span><span class="p">(</span><span class="n">r</span><span class="p">)</span><span class="o">==</span><span class="n">extent</span><span class="p">(</span><span class="n">r</span><span class="p">)</span></code></p>
     </ul>
    <li data-md="">
     <p><em>Effects:</em></p>
     <ul>
      <li data-md="">
       <p>initializes <code class="highlight"><span class="n">ptr_</span></code> with <code class="highlight"><span class="n">other</span><span class="p">.</span><span class="n">ptr_</span></code></p>
      <li data-md="">
       <p>initializes <code class="highlight"><span class="n">map_</span></code> with <code class="highlight"><span class="n">other</span><span class="p">.</span><span class="n">map_</span></code></p>
      <li data-md="">
       <p>initializes <code class="highlight"><span class="n">acc_</span></code> with <code class="highlight"><span class="n">other</span><span class="p">.</span><span class="n">acc_</span></code></p>
     </ul>
    <li data-md="">
     <p><em>Postconditions:</em></p>
     <ul>
      <li data-md="">
       <p><code class="highlight"><span class="n">get_extents</span><span class="p">()</span><span class="o">==</span><span class="n">Extents</span><span class="p">(</span><span class="n">other</span><span class="p">.</span><span class="n">get_extents</span><span class="p">())</span></code></p>
      <li data-md="">
       <p><code class="highlight"><span class="n">get_mapping</span><span class="p">()</span><span class="o">==</span><span class="n">mapping</span><span class="p">(</span><span class="n">other</span><span class="p">.</span><span class="n">get_mapping</span><span class="p">())</span></code></p>
     </ul>
    <li data-md="">
     <p><em>Remarks:</em> This constructor will not participate in overload resolution unless all of the following conditions are met:</p>
     <ul>
      <li data-md="">
       <p><code class="highlight"><span class="n">OtherElementType</span><span class="p">(</span><span class="o">*</span><span class="p">)[]</span></code> is convertible to <code class="highlight"><span class="n">ElementType</span><span class="p">(</span><span class="o">*</span><span class="p">)[]</span></code>,</p>
      <li data-md="">
       <p><code class="highlight"><span class="n">OtherLayoutPolicy</span><span class="o">::</span><span class="k">template</span> <span class="n">mapping</span><span class="o">&lt;</span><span class="n">OtherExtents</span><span class="o">></span></code> is convertible to <code class="highlight"><span class="n">mapping</span></code></p>
      <li data-md="">
       <p><code class="highlight"><span class="n">OtherAccessor</span></code> is convertible to <code class="highlight"><span class="n">Accessor</span></code>, and</p>
      <li data-md="">
       <p><code class="highlight"><span class="n">OtherAccessor</span><span class="o">::</span><span class="n">pointer</span></code> is convertible to <code class="highlight"><span class="n">pointer</span></code>.</p>
     </ul>
    <li data-md="">
     <p><em>Throws:</em> Nothing.</p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">OtherElementType</span><span class="p">,</span> <span class="n">class</span> <span class="n">OtherExtents</span><span class="p">,</span> <span class="n">class</span> <span class="n">OtherLayoutPolicy</span><span class="p">,</span> <span class="n">class</span> <span class="n">OtherAccessor</span><span class="o">></span>
  <span class="n">constexpr</span> <span class="n">basic_mdspan</span><span class="o">&amp;</span> <span class="n">operator</span><span class="o">=</span><span class="p">(</span><span class="k">const</span> <span class="n">basic_mdspan</span><span class="o">&lt;</span><span class="n">OtherElementType</span><span class="p">,</span> <span class="n">OtherExtents</span><span class="p">,</span> <span class="n">OtherLayoutPolicy</span><span class="p">,</span> <span class="n">OtherAccessor</span><span class="o">>&amp;</span> <span class="n">other</span><span class="p">);</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Requires:</em></p>
     <ul>
      <li data-md="">
       <p>For all <code class="highlight"><span class="n">r</span></code> in the range <code class="highlight"><span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="n">rank</span><span class="p">())</span></code>, if <code class="highlight"><span class="n">other</span><span class="p">.</span><span class="n">static_extent</span><span class="p">(</span><span class="n">r</span><span class="p">)</span><span class="o">==</span><span class="n">dynamic_extent</span></code> or <code class="highlight"><span class="n">static_extent</span><span class="p">(</span><span class="n">r</span><span class="p">)</span><span class="o">==</span><span class="n">dynamic_extent</span></code>, then <code class="highlight"><span class="n">other</span><span class="p">.</span><span class="n">extent</span><span class="p">(</span><span class="n">r</span><span class="p">)</span><span class="o">==</span><span class="n">extent</span><span class="p">(</span><span class="n">r</span><span class="p">)</span></code></p>
     </ul>
    <li data-md="">
     <p><em>Effects:</em></p>
     <ul>
      <li data-md="">
       <p>assigns <code class="highlight"><span class="n">other</span><span class="p">.</span><span class="n">ptr_</span></code> to <code class="highlight"><span class="n">ptr_</span></code>.</p>
      <li data-md="">
       <p>assigns <code class="highlight"><span class="n">other</span><span class="p">.</span><span class="n">map_</span></code> to <code class="highlight"><span class="n">map_</span></code></p>
      <li data-md="">
       <p>assigns <code class="highlight"><span class="n">other</span><span class="p">.</span><span class="n">acc_</span></code> to <code class="highlight"><span class="n">acc_</span></code></p>
     </ul>
    <li data-md="">
     <p><em>Postconditions:</em></p>
     <ul>
      <li data-md="">
       <p><code class="highlight"><span class="n">get_extents</span><span class="p">()</span><span class="o">==</span><span class="n">Extents</span><span class="p">(</span><span class="n">other</span><span class="p">.</span><span class="n">get_extents</span><span class="p">())</span></code></p>
      <li data-md="">
       <p><code class="highlight"><span class="n">get_mapping</span><span class="p">()</span><span class="o">==</span><span class="n">mapping</span><span class="p">(</span><span class="n">other</span><span class="p">.</span><span class="n">get_mapping</span><span class="p">())</span></code></p>
     </ul>
    <li data-md="">
     <p><em>Remarks:</em> This constructor will not participate in overload resolution unless all of the following conditions are met:</p>
     <ul>
      <li data-md="">
       <p><code class="highlight"><span class="n">OtherElementType</span><span class="p">(</span><span class="o">*</span><span class="p">)[]</span></code> is assignable to <code class="highlight"><span class="n">ElementType</span><span class="p">(</span><span class="o">*</span><span class="p">)[]</span></code>,</p>
      <li data-md="">
       <p><code class="highlight"><span class="n">OtherLayoutPolicy</span><span class="o">::</span><span class="k">template</span> <span class="n">mapping</span><span class="o">&lt;</span><span class="n">OtherExtents</span><span class="o">></span></code> is assignable to <code class="highlight"><span class="n">mapping</span></code></p>
      <li data-md="">
       <p><code class="highlight"><span class="n">OtherAccessor</span></code> is assignable to <code class="highlight"><span class="n">Accessor</span></code>, and</p>
      <li data-md="">
       <p><code class="highlight"><span class="n">OtherAccessor</span><span class="o">::</span><span class="n">pointer</span></code> is assignable to <code class="highlight"><span class="n">pointer</span></code>.</p>
     </ul>
    <li data-md="">
     <p><em>Throws:</em> Nothing.</p>
   </ul>
   <p><br> <b>26.7.�.2 <code class="highlight"><span class="n">basic_mdspan</span></code> mapping domain multi-index to access codomain element [mdspan.basic.mapping]</b></p>
<pre class="language-c++ highlight"><span class="n">constexpr</span> <span class="n">reference</span> <span class="n">operator</span><span class="p">[](</span><span class="n">index_type</span> <span class="n">i</span><span class="p">)</span> <span class="k">const</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Effects:</em> Equivalent to <code class="highlight"><span class="k">return</span> <span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="p">)(</span><span class="n">i</span><span class="p">);</span></code>.</p>
    <li data-md="">
     <p><em>Remarks:</em> This operator does not participate in overload resolution unless <code class="highlight"><span class="n">rank</span><span class="p">()</span><span class="o">==</span><span class="mi">1</span></code></p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><span class="n">template</span><span class="o">&lt;</span><span class="n">class</span><span class="p">...</span> <span class="n">IndexType</span><span class="o">></span>
  <span class="n">constexpr</span> <span class="n">reference</span> <span class="n">operator</span><span class="p">()(</span><span class="n">IndexType</span><span class="p">...</span> <span class="n">indices</span><span class="p">)</span> <span class="k">const</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Requires:</em> 0 &lt;= <code class="highlight"><span class="n">array</span><span class="o">&lt;</span><span class="n">index_type</span><span class="p">,</span> <span class="k">sizeof</span><span class="p">...(</span><span class="n">indices</span><span class="p">)</span><span class="o">></span><span class="p">{</span><span class="n">indices</span><span class="p">...}[</span><span class="n">r</span><span class="p">]</span></code> &lt; <code class="highlight"><span class="n">extent</span><span class="p">(</span><span class="n">r</span><span class="p">)</span></code> for all <code class="highlight"><span class="n">r</span></code> in the range <code class="highlight"><span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="n">rank</span><span class="p">())</span></code>.</p>
    <li data-md="">
     <p><em>Effects:</em> Equivalent to <code class="highlight"><span class="k">return</span> <span class="nf">acc_</span><span class="p">(</span><span class="n">ptr_</span><span class="p">,</span> <span class="n">indices</span><span class="p">...);</span></code></p>
    <li data-md="">
     <p><em>Remarks:</em> This operator does not participate in overload resolution unless</p>
     <ul>
      <li data-md="">
       <p><code class="highlight"><span class="n">is_convertible_v</span><span class="o">&lt;</span><span class="n">IndexType</span><span class="p">,</span> <span class="n">index_type</span><span class="o">></span> <span class="o">&amp;&amp;</span> <span class="p">...</span></code></p>
      <li data-md="">
       <p><code class="highlight"><span class="k">sizeof</span><span class="p">...(</span><span class="n">IndexType</span><span class="p">)</span><span class="o">==</span><span class="n">rank</span><span class="p">()</span></code></p>
     </ul>
    <li data-md="">
     <p><em>Throws:</em> nothing.</p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">IndexType</span><span class="p">,</span> <span class="kt">size_t</span> <span class="n">N</span><span class="o">></span>
  <span class="n">constexpr</span> <span class="n">reference</span> <span class="n">operator</span><span class="p">()(</span><span class="k">const</span> <span class="n">array</span><span class="o">&lt;</span><span class="n">IndexType</span><span class="p">,</span> <span class="n">N</span><span class="o">>&amp;</span> <span class="n">indices</span><span class="p">)</span> <span class="k">const</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Effects:</em> Equivalent to <code class="highlight"><span class="k">return</span> <span class="n">std</span><span class="o">::</span><span class="n">apply</span><span class="p">(</span><span class="o">*</span><span class="k">this</span><span class="p">,</span> <span class="n">indices</span><span class="p">);</span></code></p>
    <li data-md="">
     <p><em>Remarks:</em> This operator does not participate in overload resolution unless</p>
     <ul>
      <li data-md="">
       <p><code class="highlight"><span class="n">is_convertible_v</span><span class="o">&lt;</span><span class="n">IndexType</span><span class="p">,</span> <span class="n">index_type</span><span class="o">></span></code></p>
      <li data-md="">
       <p><code class="highlight"><span class="n">rank</span><span class="p">()</span><span class="o">==</span><span class="n">N</span></code></p>
     </ul>
    <li data-md="">
     <p><em>Throws:</em> nothing.</p>
   </ul>
<pre class="language-c++ highlight"><span class="n">accessor</span> <span class="nf">get_accessor</span><span class="p">()</span> <span class="k">const</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Returns:</em> <code class="highlight"><span class="n">acc_</span></code>.</p>
   </ul>
   <p><br> <b>26.7.�.3 <code class="highlight"><span class="n">basic_mdspan</span></code> observers of the domain multi-index space [mdspan.basic.domobs]</b></p>
<pre class="language-c++ highlight"><span class="k">static</span> <span class="n">constexpr</span> <span class="kt">int</span> <span class="nf">rank</span><span class="p">()</span> <span class="n">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Returns:</em> <code class="highlight"><span class="n">Extents</span><span class="o">::</span><span class="n">rank</span><span class="p">()</span></code>.</p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><span class="k">static</span> <span class="n">constexpr</span> <span class="kt">int</span> <span class="nf">rank_dynamic</span><span class="p">()</span> <span class="n">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Returns:</em> <code class="highlight"><span class="n">Extents</span><span class="o">::</span><span class="n">rank_dynamic</span><span class="p">()</span></code>.</p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><span class="k">static</span> <span class="n">constexpr</span> <span class="n">index_type</span> <span class="nf">static_extent</span><span class="p">(</span><span class="kt">size_t</span> <span class="n">r</span><span class="p">)</span> <span class="n">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Returns:</em> <code class="highlight"><span class="n">Extents</span><span class="o">::</span><span class="n">static_extent</span><span class="p">(</span><span class="n">r</span><span class="p">)</span></code>.</p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><span class="n">constexpr</span> <span class="n">Extents</span> <span class="nf">get_extents</span><span class="p">()</span> <span class="k">const</span> <span class="n">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Returns:</em> <code class="highlight"><span class="n">get_mapping</span><span class="p">().</span><span class="n">get_extents</span><span class="p">()</span></code>.</p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><span class="n">constexpr</span> <span class="n">index_type</span> <span class="nf">extent</span><span class="p">(</span><span class="kt">size_t</span> <span class="n">r</span><span class="p">)</span> <span class="k">const</span> <span class="n">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Returns:</em> <code class="highlight"><span class="n">get_extents</span><span class="p">().</span><span class="n">extent</span><span class="p">(</span><span class="n">r</span><span class="p">)</span></code>.</p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><span class="n">constexpr</span> <span class="n">index_type</span> <span class="nf">size</span><span class="p">()</span> <span class="k">const</span> <span class="n">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Returns:</em> Product of <code class="highlight"><span class="n">extent</span><span class="p">(</span><span class="n">r</span><span class="p">)</span></code> for all <code class="highlight"><span class="n">r</span></code> where 0 &lt;= <code class="highlight"><span class="n">r</span></code> &lt; <code class="highlight"><span class="n">get_extents</span><span class="p">().</span><span class="n">rank</span><span class="p">()</span></code>.</p>
   </ul>
<pre class="language-c++ highlight"><span class="n">constexpr</span> <span class="n">index_type</span> <span class="nf">unique_size</span><span class="p">()</span> <span class="k">const</span> <span class="n">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Returns:</em> The number of unique elements in the codomain. <em>[Note:</em> If <code class="highlight"><span class="n">get_mapping</span><span class="p">().</span><span class="n">is_unique</span><span class="p">()</span></code> is <code class="highlight">true</code>, this is identical to <code class="highlight"><span class="n">size</span><span class="p">()</span></code> <em>—end note]</em></p>
   </ul>
   <p><br> <b>26.7.�.3 <code class="highlight"><span class="n">basic_mdspan</span></code> observers of the codomain [mdspan.basic.codomain]</b></p>
<pre class="language-c++ highlight"><span class="n">constexpr</span> <span class="n">span</span><span class="o">&lt;</span><span class="n">element_type</span><span class="o">></span> <span class="n">span</span><span class="p">()</span> <span class="k">const</span> <span class="n">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Returns:</em> The codomain <code class="highlight"><span class="n">span</span></code>.</p>
   </ul>
   <p><br> <b>26.7.�.4 <code class="highlight"><span class="n">basic_mdspan</span></code> observers of the mapping [mdspan.basic.obs]</b></p>
   <p><br></p>
<pre class="language-c++ highlight"><span class="k">static</span> <span class="n">constexpr</span> <span class="kt">bool</span> <span class="nf">is_always_unique</span><span class="p">()</span> <span class="n">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Returns:</em> <code class="highlight"><span class="n">mapping</span><span class="o">::</span><span class="n">is_always_unique</span><span class="p">()</span></code></p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><span class="k">static</span> <span class="n">constexpr</span> <span class="kt">bool</span> <span class="nf">is_always_contiguous</span><span class="p">()</span> <span class="n">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Returns:</em> <code class="highlight"><span class="n">mapping</span><span class="o">::</span><span class="n">is_always_contiguous</span><span class="p">()</span></code></p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><span class="k">static</span> <span class="n">constexpr</span> <span class="kt">bool</span> <span class="nf">is_always_strided</span><span class="p">()</span> <span class="n">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Returns:</em> <code class="highlight"><span class="n">mapping</span><span class="o">::</span><span class="n">is_always_strided</span><span class="p">()</span></code></p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><span class="n">constexpr</span> <span class="n">mapping</span> <span class="nf">get_mapping</span><span class="p">()</span> <span class="k">const</span> <span class="n">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Returns:</em> <code class="highlight"><span class="n">map_</span></code></p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><span class="n">constexpr</span> <span class="kt">bool</span> <span class="nf">is_unique</span><span class="p">()</span> <span class="k">const</span> <span class="n">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Returns:</em> <code class="highlight"><span class="n">get_mapping</span><span class="p">().</span><span class="n">is_unique</span><span class="p">()</span></code></p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><span class="n">constexpr</span> <span class="kt">bool</span> <span class="nf">is_contiguous</span><span class="p">()</span> <span class="k">const</span> <span class="n">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Returns:</em> <code class="highlight"><span class="n">get_mapping</span><span class="p">().</span><span class="n">is_contiguous</span><span class="p">()</span></code></p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><span class="n">constexpr</span> <span class="kt">bool</span> <span class="nf">is_strided</span><span class="p">()</span> <span class="k">const</span> <span class="n">noexcept</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Returns:</em> <code class="highlight"><span class="n">get_mapping</span><span class="p">().</span><span class="n">is_strided</span><span class="p">()</span></code></p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><span class="n">constexpr</span> <span class="n">index_type</span> <span class="nf">stride</span><span class="p">(</span><span class="kt">size_t</span> <span class="n">r</span><span class="p">)</span> <span class="k">const</span><span class="p">;</span>
</pre>
   <ul>
    <li data-md="">
     <p><em>Returns:</em> <code class="highlight"><span class="n">get_mapping</span><span class="p">().</span><span class="n">stride</span><span class="p">(</span><span class="n">r</span><span class="p">)</span></code></p>
   </ul>
   <p><br> <br> <b>26.7.� subspan [mdspan.subspan]</b></p>
<pre class="language-c++ highlight"><span class="n">namespace</span> <span class="n">std</span> <span class="p">{</span>
<span class="n">namespace</span> <span class="n">experimental</span> <span class="p">{</span>
<span class="n">namespace</span> <span class="n">fundamentals_v3</span> <span class="p">{</span>

  <span class="c1">// [mdspan.subspan], subspan creation</span>
<span class="c1"></span>  <span class="n">template</span><span class="o">&lt;</span><span class="n">class</span> <span class="n">ElementType</span><span class="p">,</span> <span class="n">class</span> <span class="n">Extents</span><span class="p">,</span> <span class="n">class</span> <span class="n">LayoutPolicy</span><span class="p">,</span>
           <span class="n">class</span> <span class="n">Accessor</span><span class="p">,</span> <span class="n">class</span><span class="p">...</span> <span class="n">SliceSpecifiers</span><span class="o">></span>
    <span class="n">basic_mdspan</span><span class="o">&lt;</span><span class="n">ElementType</span><span class="p">,</span> <span class="n">E</span> <span class="cm">/* see-below */</span><span class="p">,</span> <span class="n">layout_stride</span><span class="p">,</span> <span class="n">Accessor</span><span class="o">></span>
      <span class="n">subspan</span><span class="p">(</span><span class="k">const</span> <span class="n">basic_mdspan</span><span class="o">&lt;</span><span class="n">ElementType</span><span class="p">,</span> <span class="n">Extents</span><span class="p">,</span> <span class="n">LayoutPolicy</span><span class="p">,</span> <span class="n">Accessor</span><span class="o">>&amp;</span> <span class="n">src</span><span class="p">,</span> <span class="n">SliceSpecifiers</span> <span class="p">...</span> <span class="n">slices</span><span class="p">)</span> <span class="n">noexcept</span><span class="p">;</span>

<span class="p">}}}</span>
</pre>
   <p><code class="highlight"><span class="n">subspan</span></code> creates a <code class="highlight"><span class="n">basic_mdspan</span></code> that is a view on a (potentially trivial) subset of another <code class="highlight"><span class="n">basic_mdspan</span></code>.
The SliceSpecifier parameters indicate the subset that the return value references.
Let slices[r] denote the rth value in the parameter pack slices.
The second template parameter of the return type is E, a specialization of <code class="highlight"><span class="n">extents</span></code>. <br></p>
   <p>Let <em>C</em> be the number of parameters in <code class="highlight"><span class="n">SliceSpecifiers</span></code> which are convertible to <code class="highlight"><span class="kt">ptrdiff_t</span></code> <br> Let <em>ranges[r]</em> denote the rth value in the parameter pack slices, which is not convertible to <code class="highlight"><span class="kt">ptrdiff_t</span></code> <br> Let <em>sub</em> be the return value of <code class="highlight"><span class="n">subspan</span></code> <br> Let <em>first[r]</em> denote the rth lower bound of <code class="highlight"><span class="n">slices</span><span class="p">[</span><span class="n">r</span><span class="p">]</span></code>. <br></p>
   <ul>
    <li data-md="">
     <p>If <code class="highlight"><span class="n">slices</span><span class="p">[</span><span class="n">r</span><span class="p">]</span></code> is convertible to <code class="highlight"><span class="kt">ptrdiff_t</span></code> <code class="highlight"><span class="n">first</span><span class="p">[</span><span class="n">r</span><span class="p">]</span><span class="o">==</span><span class="n">slices</span><span class="p">[</span><span class="n">r</span><span class="p">]</span></code> <br></p>
    <li data-md="">
     <p>If <code class="highlight"><span class="n">slices</span><span class="p">[</span><span class="n">r</span><span class="p">]</span></code> is convertible to <code class="highlight"><span class="n">pair</span><span class="o">&lt;</span><span class="kt">ptrdiff_t</span><span class="p">,</span><span class="kt">ptrdiff_t</span><span class="o">></span></code> <code class="highlight"><span class="n">first</span><span class="p">[</span><span class="n">r</span><span class="p">]</span><span class="o">==</span><span class="n">pair</span><span class="o">&lt;</span><span class="kt">ptrdiff_t</span><span class="p">,</span><span class="kt">ptrdiff_t</span><span class="o">></span><span class="p">(</span><span class="n">slices</span><span class="p">[</span><span class="n">r</span><span class="p">]).</span><span class="n">first</span><span class="p">()</span></code> <br></p>
    <li data-md="">
     <p>If <code class="highlight"><span class="n">slices</span><span class="p">[</span><span class="n">r</span><span class="p">]</span></code> is convertible to <code class="highlight"><span class="n">alltype_t</span></code> <code class="highlight"><span class="n">first</span><span class="p">[</span><span class="n">r</span><span class="p">]</span><span class="o">==</span><span class="mi">0</span></code> <br></p>
   </ul>
   Let <code class="highlight"><span class="n">last</span><span class="p">[</span><span class="n">r</span><span class="p">]</span></code> denote the rth upper bound of <code class="highlight"><span class="n">slices</span><span class="p">[</span><span class="n">r</span><span class="p">]</span></code>. <br> 
   <ul>
    <li data-md="">
     <p>If <code class="highlight"><span class="n">slices</span><span class="p">[</span><span class="n">r</span><span class="p">]</span></code> is convertible to <code class="highlight"><span class="kt">ptrdiff_t</span></code> <code class="highlight"><span class="n">last</span><span class="p">[</span><span class="n">r</span><span class="p">]</span><span class="o">==</span><span class="n">slices</span><span class="p">[</span><span class="n">r</span><span class="p">]</span><span class="o">+</span><span class="mi">1</span></code> <br></p>
    <li data-md="">
     <p>If <code class="highlight"><span class="n">slices</span><span class="p">[</span><span class="n">r</span><span class="p">]</span></code> is convertible to <code class="highlight"><span class="n">pair</span><span class="o">&lt;</span><span class="kt">ptrdiff_t</span><span class="p">,</span><span class="kt">ptrdiff_t</span><span class="o">></span></code> <code class="highlight"><span class="n">last</span><span class="p">[</span><span class="n">r</span><span class="p">]</span><span class="o">==</span><span class="n">pair</span><span class="o">&lt;</span><span class="kt">ptrdiff_t</span><span class="p">,</span><span class="kt">ptrdiff_t</span><span class="o">></span><span class="p">(</span><span class="n">slices</span><span class="p">[</span><span class="n">r</span><span class="p">]).</span><span class="n">second</span><span class="p">()</span></code> <br></p>
    <li data-md="">
     <p>If <code class="highlight"><span class="n">slices</span><span class="p">[</span><span class="n">r</span><span class="p">]</span></code> is convertible to <code class="highlight"><span class="n">alltype_t</span></code> <code class="highlight"><span class="n">last</span><span class="p">[</span><span class="n">r</span><span class="p">]</span><span class="o">==</span><span class="n">src</span><span class="p">.</span><span class="n">extent</span><span class="p">(</span><span class="n">r</span><span class="p">)</span></code> <br></p>
   </ul>
   <p>Requires: <br></p>
   <ul>
    <li data-md="">
     <p><code class="highlight"><span class="k">sizeof</span><span class="p">(</span><span class="n">slices</span><span class="p">...)</span><span class="o">==</span><span class="n">Extents</span><span class="o">::</span><span class="n">rank</span><span class="p">()</span></code> <br></p>
    <li data-md="">
     <p><code class="highlight"><span class="n">slices</span><span class="p">[</span><span class="n">r</span><span class="p">]</span></code> is convertible to <code class="highlight"><span class="kt">ptrdiff_t</span></code>, <code class="highlight"><span class="n">pair</span><span class="o">&lt;</span><span class="kt">ptrdiff_t</span><span class="p">,</span><span class="kt">ptrdiff_t</span><span class="o">></span></code> or <code class="highlight"><span class="n">alltype_t</span></code> <br></p>
    <li data-md="">
     <p>0 &lt;= <code class="highlight"><span class="n">first</span><span class="p">[</span><span class="n">r</span><span class="p">]</span></code> &lt; <code class="highlight"><span class="n">src</span><span class="p">.</span><span class="n">extent</span><span class="p">(</span><span class="n">r</span><span class="p">)</span></code> <br></p>
    <li data-md="">
     <p>0 &lt; <code class="highlight"><span class="n">last</span><span class="p">[</span><span class="n">r</span><span class="p">]</span></code> &lt;= <code class="highlight"><span class="n">src</span><span class="p">.</span><span class="n">extent</span><span class="p">(</span><span class="n">r</span><span class="p">)</span></code> <br></p>
    <li data-md="">
     <p><code class="highlight"><span class="n">LayoutPolicy</span></code> is <code class="highlight"><span class="n">layout_right</span></code>, <code class="highlight"><span class="n">layout_left</span></code>, or <code class="highlight"><span class="n">layout_stride</span></code> <br></p>
   </ul>
   <p>Postcondition: <br></p>
   <ul>
    <li data-md="">
     <p><code class="highlight"><span class="n">E</span><span class="o">::</span><span class="n">rank</span><span class="p">()</span><span class="o">==</span><span class="n">Extents</span><span class="o">::</span><span class="n">rank</span><span class="p">()</span><span class="o">-</span><span class="n">C</span></code> <br></p>
    <li data-md="">
     <p>If <em>ranges[r]</em> is the nth value of <code class="highlight"><span class="n">ranges</span></code> convertible to <code class="highlight"><span class="n">alltype_t</span></code> or <code class="highlight"><span class="n">pair</span><span class="o">&lt;</span><span class="kt">ptrdiff_t</span><span class="p">,</span><span class="kt">ptrdiff_t</span><span class="o">></span></code> and <code class="highlight"><span class="n">slices</span><span class="p">[</span><span class="n">k</span><span class="p">]</span></code> is the <code class="highlight"><span class="n">n</span></code>th value of <code class="highlight"><span class="n">slices</span></code> convertible to <code class="highlight"><span class="n">all</span> <span class="n">type_t</span></code> or <code class="highlight"><span class="n">pair</span><span class="o">&lt;</span><span class="kt">ptrdiff_t</span><span class="p">,</span><span class="kt">ptrdiff_t</span><span class="o">></span></code> then <code class="highlight"><span class="n">sub</span><span class="p">.</span><span class="n">extent</span><span class="p">(</span><span class="n">r</span><span class="p">)</span><span class="o">==</span><span class="n">last</span><span class="p">[</span><span class="n">k</span><span class="p">]</span><span class="o">-</span><span class="n">first</span><span class="p">[</span><span class="n">k</span><span class="p">]</span></code> and <code class="highlight"><span class="n">sub</span><span class="p">.</span><span class="n">stride</span><span class="p">(</span><span class="n">r</span><span class="p">)</span><span class="o">==</span><span class="n">src</span><span class="p">.</span><span class="n">stride</span><span class="p">(</span><span class="n">k</span><span class="p">)</span></code> <br></p>
    <li data-md="">
     <p><code class="highlight"><span class="n">sub</span><span class="p">.</span><span class="n">ptr_</span><span class="o">==</span><span class="n">src</span><span class="p">.</span><span class="n">ptr_</span><span class="o">+</span><span class="n">first</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">*</span><span class="n">src</span><span class="p">.</span><span class="n">stride</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span><span class="o">+</span></code>...<code class="highlight"><span class="o">+</span><span class="n">first</span><span class="p">[</span><span class="n">Extents</span><span class="o">::</span><span class="n">rank</span><span class="p">()</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span><span class="o">*</span><span class="n">src</span><span class="p">.</span><span class="n">stride</span><span class="p">(</span><span class="n">Extents</span><span class="o">::</span><span class="n">rank</span><span class="p">()</span><span class="o">-</span><span class="mi">1</span><span class="p">)</span></code> <br></p>
    <li data-md="">
     <p class="note" role="note"><span>Note:</span> it is quality of implementation whether static extents are preserved if possible. <br></p>
   </ul>
   <ul>
    <li data-md="">
     <p>Examples:</p>
   </ul>
<pre class="language-c++ highlight"><span class="c1">// Create a mapping</span>
<span class="c1"></span><span class="k">typedef</span> <span class="n">extents</span><span class="o">&lt;</span><span class="mi">3</span><span class="p">,</span><span class="n">dynamic_extent</span><span class="p">,</span><span class="mi">7</span><span class="o">></span> <span class="n">Extents3D</span><span class="p">;</span>
<span class="n">layout_right</span><span class="o">::</span><span class="n">template</span> <span class="n">mapping</span><span class="o">&lt;</span><span class="n">Extents3D</span><span class="o">></span> <span class="n">map_right</span><span class="p">(</span><span class="mi">10</span><span class="p">);</span>

<span class="c1">// Allocate a basic_mdspan</span>
<span class="c1"></span><span class="kt">int</span><span class="o">*</span> <span class="n">ptr</span> <span class="o">=</span> <span class="n">new</span> <span class="kt">int</span><span class="p">[</span><span class="mi">3</span><span class="o">*</span><span class="mi">8</span><span class="o">*</span><span class="mi">10</span><span class="p">];</span>
<span class="n">basic_mdspan</span><span class="o">&lt;</span><span class="kt">int</span><span class="p">,</span><span class="n">Extents3D</span><span class="p">,</span><span class="n">layout_right</span><span class="o">></span> <span class="n">a</span><span class="p">(</span><span class="n">ptr</span><span class="p">,</span><span class="n">map_right</span><span class="p">);</span>

<span class="c1">// Initialize the span</span>
<span class="c1"></span><span class="k">for</span><span class="p">(</span><span class="kt">int</span> <span class="n">i0</span><span class="o">=</span><span class="mi">0</span><span class="p">;</span> <span class="n">i0</span><span class="o">&lt;</span><span class="n">a</span><span class="p">.</span><span class="n">extent</span><span class="p">(</span><span class="mi">0</span><span class="p">);</span> <span class="n">i0</span><span class="o">++</span><span class="p">)</span>
  <span class="k">for</span><span class="p">(</span><span class="kt">int</span> <span class="n">i1</span><span class="o">=</span><span class="mi">0</span><span class="p">;</span> <span class="n">i1</span><span class="o">&lt;</span><span class="n">a</span><span class="p">.</span><span class="n">extent</span><span class="p">(</span><span class="mi">1</span><span class="p">);</span> <span class="n">i1</span><span class="o">++</span><span class="p">)</span>
    <span class="k">for</span><span class="p">(</span><span class="kt">int</span> <span class="n">i2</span><span class="o">=</span><span class="mi">0</span><span class="p">;</span> <span class="n">i2</span><span class="o">&lt;</span><span class="n">a</span><span class="p">.</span><span class="n">extent</span><span class="p">(</span><span class="mi">2</span><span class="p">);</span> <span class="n">i2</span><span class="o">++</span><span class="p">)</span>
      <span class="n">a</span><span class="p">(</span><span class="n">i0</span><span class="p">,</span><span class="n">i1</span><span class="p">,</span><span class="n">i2</span><span class="p">)</span> <span class="o">=</span> <span class="mi">10000</span><span class="o">*</span><span class="n">i0</span><span class="o">+</span><span class="mi">100</span><span class="o">*</span><span class="n">i1</span><span class="o">+</span><span class="n">i2</span><span class="p">;</span>

<span class="c1">// Create Subspan</span>
<span class="c1"></span><span class="k">auto</span> <span class="n">a_sub</span> <span class="o">=</span> <span class="n">subspan</span><span class="p">(</span><span class="n">a</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="n">std</span><span class="o">::</span><span class="n">pair</span><span class="o">&lt;</span><span class="kt">int</span><span class="p">,</span><span class="kt">int</span><span class="o">></span><span class="p">(</span><span class="mi">4</span><span class="p">,</span><span class="mi">6</span><span class="p">),</span><span class="n">std</span><span class="o">::</span><span class="n">pair</span><span class="o">&lt;</span><span class="kt">int</span><span class="p">,</span><span class="kt">int</span><span class="o">></span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="mi">6</span><span class="p">));</span>

<span class="c1">// Print values of subspan</span>
<span class="c1"></span><span class="k">for</span><span class="p">(</span><span class="kt">int</span> <span class="n">i0</span><span class="o">=</span><span class="mi">0</span><span class="p">;</span> <span class="n">i0</span><span class="o">&lt;</span><span class="n">a_sub</span><span class="p">.</span><span class="n">extent</span><span class="p">(</span><span class="mi">0</span><span class="p">);</span> <span class="n">i0</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
  <span class="k">for</span><span class="p">(</span><span class="kt">int</span> <span class="n">i1</span><span class="o">=</span><span class="mi">0</span><span class="p">;</span> <span class="n">i1</span><span class="o">&lt;</span><span class="n">a_sub</span><span class="p">.</span><span class="n">extent</span><span class="p">(</span><span class="mi">1</span><span class="p">);</span> <span class="n">i1</span><span class="o">++</span><span class="p">)</span>
    <span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="n">a_sub</span><span class="p">(</span><span class="n">i0</span><span class="p">,</span><span class="n">i1</span><span class="p">)</span> <span class="o">&lt;&lt;</span> <span class="s">" "</span><span class="p">;</span>
  <span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="p">}</span>

<span class="cm">/* Output</span>
<span class="cm">10401 10402 10403 10404 10405</span>
<span class="cm">10501 10502 10503 10504 10505</span>
<span class="cm">*/</span>
</pre>
   <h2 class="heading settled" data-level="5" id="next-steps"><span class="secno">5. </span><span class="content">Next Steps</span><a class="self-link" href="#next-steps"></a></h2>
   <ul>
    <li data-md="">
     <p>Wording editing as per guidance from LWG.</p>
   </ul>
   <h2 class="heading settled" data-level="6" id="related-work"><span class="secno">6. </span><span class="content">Related Work</span><a class="self-link" href="#related-work"></a></h2>
   <p><a href="https://issues.isocpp.org/show_bug.cgi?id=80">LEWG issue</a></p>
   <p><strong>Previous paper:</strong></p>
   <ul>
    <li data-md="">
     <p><a data-link-type="biblio" href="#biblio-n4355">[N4355]</a></p>
   </ul>
   <p><strong>P0860 : Access Policy Generating Proxy Reference</strong></p>
   <p>The <code class="highlight"><span class="n">reference</span></code> type may be a proxy for accessing an <code class="highlight"><span class="n">element_type</span></code> object. For example, the <em>atomic</em> <code class="highlight"><span class="n">AccessorPolicy</span></code> in <strong>P0860</strong> defines <code class="highlight"><span class="n">AccessorPolicy</span><span class="o">::</span><span class="k">template</span> <span class="n">accessor</span><span class="o">&lt;</span><span class="n">T</span><span class="o">>::</span><span class="n">reference</span></code> to be <code class="highlight"><span class="n">atomic_ref</span><span class="o">&lt;</span><span class="n">T</span><span class="o">></span></code> from <strong>P0019</strong>.</p>
   <p><strong>Related papers:</strong></p>
   <ul>
    <li data-md="">
     <p><strong>P0122</strong> : span: bounds-safe views for sequences of objects The <code class="highlight"><span class="n">mdspan</span></code> codomain concept of <em>span</em> is well-aligned with this paper.</p>
    <li data-md="">
     <p><strong>P0367</strong> : Accessors The P0367 Accessors proposal includes
polymorphic mechanisms for accessing the memory an object or span of
objects. The <code class="highlight"><span class="n">AccessPolicy</span></code> extension point in this proposal is
intended to include such memory access properties.</p>
    <li data-md="">
     <p><strong>P0331</strong> : Motivation and Examples for Multidimensional Array</p>
    <li data-md="">
     <p><strong>P0332</strong> : Relaxed Incomplete Multidimensional Array Type
Declaration</p>
    <li data-md="">
     <p><strong>P0454</strong> : Wording for a Minimal <code class="highlight"><span class="n">mdspan</span></code> Included proposed
modification of <code class="highlight"><span class="n">span</span></code> to better align <code class="highlight"><span class="n">span</span></code> with <code class="highlight"><span class="n">mdspan</span></code>.</p>
    <li data-md="">
     <p><strong>P0546</strong> : Preparing <code class="highlight"><span class="n">span</span></code> for the future Proposed modification of <code class="highlight"><span class="n">span</span></code></p>
    <li data-md="">
     <p><strong>P0856</strong> : Restrict access property for <code class="highlight"><span class="n">mdspan</span></code> and <code class="highlight"><span class="n">span</span></code></p>
    <li data-md="">
     <p><strong>P0860</strong> : atomic access policy for <code class="highlight"><span class="n">mdspan</span></code></p>
    <li data-md="">
     <p><strong>P0900</strong> : An Ontology of Properties for <code class="highlight"><span class="n">mdspan</span></code></p>
   </ul>
   <h2 class="heading settled" data-level="7" id="todo"><span class="secno">7. </span><span class="content">TODO</span><a class="self-link" href="#todo"></a></h2>
   <ul>
    <li data-md="">
     <p>Design questions:</p>
     <ul>
      <li data-md="">
       <strike>Need a way to construct span with non-default-initialized <code class="highlight"><span class="n">mapping</span></code> and <code class="highlight"><span class="n">accessor</span></code></strike>
        Added, please review 
      <li data-md="">
       <p>Should we be constraining things with <code class="highlight"><span class="n">is_integral_v</span><span class="o">&lt;</span><span class="n">IndexType</span><span class="o">></span></code> or <code class="highlight"><span class="n">is_convertible_v</span><span class="o">&lt;</span><span class="n">IndexType</span><span class="p">,</span> <span class="n">index_type</span><span class="o">></span></code>?</p>
      <li data-md="">
       <strike>Extents and/or mapping conversion?</strike>
        Done, please review 
      <li data-md="">
       <strike>Constrain constructors of <code class="highlight"><span class="n">basic_mdspan</span></code> based on <code class="highlight"><span class="n">Mapping</span></code> and <code class="highlight"><span class="n">Accessor</span></code> constraints.</strike>
        Done, please review 
      <li data-md="">
       <strike><code class="highlight"><span class="n">unique_size</span><span class="p">()</span></code></strike>
        done 
     </ul>
   </ul>
  </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-n4355">[N4355]
   <dd>Carter Edwards. <a href="https://wg21.link/n4355">Shared Multidimensional Arrays with Polymorphic Layout</a>. 4 February 2015. URL: <a href="https://wg21.link/n4355">https://wg21.link/n4355</a>
   <dt id="biblio-p0900r0">[P0900r0]
   <dd>David S. Hollman. <a href="https://wg21.link/p0900r0">An Ontology for Properties of mdspan</a>. 12 February 2018. URL: <a href="https://wg21.link/p0900r0">https://wg21.link/p0900r0</a>
  </dl>