<!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>P0009R8: &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#toc .secno { /* Ugh, need more specificity to override base.css */
			grid-column: 1;
			width: auto;
			margin-left: 0;
		}
		#toc .content {
			grid-column: 2;
			width: auto;
			margin-right: 1rem;
		}
		#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 e9290f0f6bc01459c8b7bdfa2bb91f6985fc5c67" name="generator">
  <link href="wg21.link/P0009r8" 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; }
c-[a] { color: #990055 } /* Keyword.Declaration */
c-[b] { color: #990055 } /* Keyword.Type */
c-[c] { color: #708090 } /* Comment */
c-[d] { color: #708090 } /* Comment.Multiline */
c-[e] { color: #0077aa } /* Name.Attribute */
c-[f] { color: #669900 } /* Name.Tag */
c-[g] { color: #222222 } /* Name.Variable */
c-[k] { color: #990055 } /* Keyword */
c-[l] { color: #000000 } /* Literal */
c-[m] { color: #000000 } /* Literal.Number */
c-[n] { color: #0077aa } /* Name */
c-[o] { color: #999999 } /* Operator */
c-[p] { color: #999999 } /* Punctuation */
c-[s] { color: #a67f59 } /* Literal.String */
c-[t] { color: #a67f59 } /* Literal.String.Single */
c-[u] { color: #a67f59 } /* Literal.String.Double */
c-[cp] { color: #708090 } /* Comment.Preproc */
c-[c1] { color: #708090 } /* Comment.Single */
c-[cs] { color: #708090 } /* Comment.Special */
c-[kc] { color: #990055 } /* Keyword.Constant */
c-[kn] { color: #990055 } /* Keyword.Namespace */
c-[kp] { color: #990055 } /* Keyword.Pseudo */
c-[kr] { color: #990055 } /* Keyword.Reserved */
c-[ld] { color: #000000 } /* Literal.Date */
c-[nc] { color: #0077aa } /* Name.Class */
c-[no] { color: #0077aa } /* Name.Constant */
c-[nd] { color: #0077aa } /* Name.Decorator */
c-[ni] { color: #0077aa } /* Name.Entity */
c-[ne] { color: #0077aa } /* Name.Exception */
c-[nf] { color: #0077aa } /* Name.Function */
c-[nl] { color: #0077aa } /* Name.Label */
c-[nn] { color: #0077aa } /* Name.Namespace */
c-[py] { color: #0077aa } /* Name.Property */
c-[ow] { color: #999999 } /* Operator.Word */
c-[mb] { color: #000000 } /* Literal.Number.Bin */
c-[mf] { color: #000000 } /* Literal.Number.Float */
c-[mh] { color: #000000 } /* Literal.Number.Hex */
c-[mi] { color: #000000 } /* Literal.Number.Integer */
c-[mo] { color: #000000 } /* Literal.Number.Oct */
c-[sb] { color: #a67f59 } /* Literal.String.Backtick */
c-[sc] { color: #a67f59 } /* Literal.String.Char */
c-[sd] { color: #a67f59 } /* Literal.String.Doc */
c-[se] { color: #a67f59 } /* Literal.String.Escape */
c-[sh] { color: #a67f59 } /* Literal.String.Heredoc */
c-[si] { color: #a67f59 } /* Literal.String.Interpol */
c-[sx] { color: #a67f59 } /* Literal.String.Other */
c-[sr] { color: #a67f59 } /* Literal.String.Regex */
c-[ss] { color: #a67f59 } /* Literal.String.Symbol */
c-[vc] { color: #0077aa } /* Name.Variable.Class */
c-[vg] { color: #0077aa } /* Name.Variable.Global */
c-[vi] { color: #0077aa } /* Name.Variable.Instance */
c-[il] { color: #000000 } /* Literal.Number.Integer.Long */
</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">P0009R8<br><code class="highlight"><c- n>mdspan</c-></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-10-07">2018-10-07</time></span></h2>
   <div data-fill-with="spec-metadata">
    <dl>
     <dt>This version:
     <dd><a class="u-url" href="wg21.link/P0009r8">wg21.link/P0009r8</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/IEC JTC1/SC22/WG21 14882: 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="#p0009r8-pre-2018-11-sandiego-mailing"><span class="secno">1.1</span> <span class="content">P0009r8: Pre 2018-11-SanDiego Mailing</span></a>
      <li><a href="#p0009r7-post-2018-06-rapperswil-mailing"><span class="secno">1.2</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.3</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.4</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.5</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.6</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.7</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.8</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.9</span> <span class="content">P0009r0 : Pre 2015-10-Kona Mailing</span></a>
      <li><a href="#related-activity"><span class="secno">1.10</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="#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="p0009r8-pre-2018-11-sandiego-mailing"><span class="secno">1.1. </span><span class="content">P0009r8: Pre 2018-11-SanDiego Mailing</span><a class="self-link" href="#p0009r8-pre-2018-11-sandiego-mailing"></a></h3>
   <ul>
    <li data-md>
     <p>Refinement based upon updated <a href="https://github.com/ORNL/cpp-proposals-pub/blob/master/P0009/prototype">prototype</a> / reference implementation</p>
   </ul>
   <h3 class="heading settled" data-level="1.2" id="p0009r7-post-2018-06-rapperswil-mailing"><span class="secno">1.2. </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="http://wiki.edg.com/bin/view/Wg21rapperswil2018/LWGSatAM">LWG review at 2018-06-Rapperswil</a></p>
    <li data-md>
     <p>usage of <code class="highlight"><c- n>span</c-></code> requires reference to C++20 working draft</p>
    <li data-md>
     <p>namespace for library TS <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>experimental</c-><c- o>::</c-><c- n>fundamentals_v3</c-></code></p>
   </ul>
   <h3 class="heading settled" data-level="1.3" id="p0009r6--pre-2018-06-rapperswil-mailing"><span class="secno">1.3. </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"><c- n>span</c-><c- o>&lt;</c-><c- n>T</c-><c- p>,</c-> <c- n>N</c-><c- p>,</c-> <c- n>Accessor</c-><c- o>=</c-><c- p>...</c-><c- o>></c->
</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"><c- n>basic_mdspan</c-></code> to be two
concepts <code class="highlight"><c- n>Mapper</c-></code> and <code class="highlight"><c- n>Accessor</c-></code> (akin to <code class="highlight"><c- n>Allocator</c-></code> design).</p>
<pre class="language-c++ highlight"><c- n>basic_mdspan</c-><c- o>&lt;</c-><c- n>T</c-><c- p>,</c-> <c- n>Extents</c-><c- p>,</c-> <c- n>Mapper</c-><c- p>,</c-> <c- n>Accessor</c-><c- o>></c->
<c- n>mdspan</c-><c- o>&lt;</c-><c- n>T</c-><c- p>,</c-> <c- n>N</c-><c- p>...</c-><c- o>></c->
</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"><c- n>basic_mdspan</c-></code> to be an
arbitrary (and potentially user-extensible) list of properties.</p>
<pre class="language-c++ highlight"><c- n>basic_mdspan</c-><c- o>&lt;</c-><c- n>T</c-><c- p>,</c-> <c- n>Extents</c-><c- p>,</c-> <c- n>Properties</c-><c- p>...</c-><c- o>></c->
</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"><c- n>mdspan</c-></code> to <code class="highlight"><c- n>basic_mdspan</c-></code>.</p>
      <li data-md>
       <p>Added a <code class="highlight"><c- n>mdspan</c-></code> alias to <code class="highlight"><c- n>basic_mdspan</c-></code>.</p>
     </ul>
   </ul>
   <h3 class="heading settled" data-level="1.4" id="p0009r5--pre-2018-03-jacksonville-mailing"><span class="secno">1.4. </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"><c- n>span</c-><c- o>&lt;</c-><c- b>int</c-> <c- n>type</c-><c- p>[</c-><c- n>N</c-><c- p>]</c-><c- o>></c-></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"><c- n>mdspan</c-></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"><c- n>rank</c-><c- p>()</c-><c- o>==</c-><c- k>sizeof</c-><c- p>...(</c-><c- n>indices</c-><c- p>)</c-></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.5" id="p0009r4--pre-2017-11-albuquerque-mailing"><span class="secno">1.5. </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"><c- n>mdspan</c-></code>, multidimensional span, to align with <code class="highlight"><c- n>span</c-></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"><c- n>span</c-></code>.</p>
    <li data-md>
     <p>Add layout mapping concept.</p>
   </ul>
   <h3 class="heading settled" data-level="1.6" id="p0009r3--post-2016-06-oulu-mailing"><span class="secno">1.6. </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"><c- n>array_ref</c-></code>, and suggested the following
alternatives: - <code class="highlight"><c- n>sci_span</c-></code> - <code class="highlight"><c- n>numeric_span</c-></code> - <code class="highlight"><c- n>multidimensional_span</c-></code> - <code class="highlight"><c- n>multidim_span</c-></code> - <code class="highlight"><c- n>mdspan</c-></code> - <code class="highlight"><c- n>md_span</c-></code> - <code class="highlight"><c- n>vla_span</c-></code> - <code class="highlight"><c- n>multispan</c-></code> - <code class="highlight"><c- n>multi_span</c-></code></p>
   <p><strong>LEWG Poll</strong>: Are member <code class="highlight"><c- n>begin</c-><c- p>()</c-></code>/<code class="highlight"><c- n>end</c-><c- p>()</c-></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>
   <p><strong>LEWG Poll</strong>: Want this proposal to provide range-producing functions
outside <code class="highlight"><c- n>array_ref</c-></code>?</p>
   <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"><c- n>element_type</c-></code>, <code class="highlight"><c- n>reference</c-></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"><c- n>array_ref</c-><c- o>&lt;</c-><c- n>T</c-><c- p>[</c-><c- n>N</c-><c- p>]</c-><c- o>></c-></code> in addition to <code class="highlight"><c- n>array_ref</c-><c- o>&lt;</c-><c- n>extents</c-><c- o>&lt;</c-><c- n>N</c-><c- o>>></c-></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.7" id="p0009r2--pre-2016-06-oulu-mailing"><span class="secno">1.7. </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.8" id="p0009r1--pre-2016-02-jacksonville-mailing"><span class="secno">1.8. </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"><c- n>view</c-></code>
      <td> 5 
     <tr>
      <td><code class="highlight"><c- n>span</c-></code>
      <td> 9 
     <tr>
      <td><code class="highlight"><c- n>array_ref</c-></code>
      <td> 6 
     <tr>
      <td><code class="highlight"><c- n>slice</c-></code>
      <td> 6 
     <tr>
      <td><code class="highlight"><c- n>array_view</c-></code>
      <td> 6 
     <tr>
      <td><code class="highlight"><c- n>ref</c-></code>
      <td> 0 
     <tr>
      <td><code class="highlight"><c- n>array_span</c-></code>
      <td> 7 
     <tr>
      <td><code class="highlight"><c- n>basic_span</c-></code>
      <td> 1 
     <tr>
      <td><code class="highlight"><c- n>object_span</c-></code>
      <td> 3 
     <tr>
      <td><code class="highlight"><c- n>field</c-></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"><c- n>X</c-><c- p>[</c-><c- mi>3</c-><c- p>][][][</c-><c- mi>5</c-><c- p>]</c-></code>?</p>
   <table>
    <thead>
     <tr>
      <th>Syntax
      <th>#
    <tbody>
     <tr>
      <td><code class="highlight"><c- n>view</c-><c- o>&lt;</c-><c- b>int</c-><c- p>[</c-><c- mi>3</c-><c- p>][</c-><c- mi>0</c-><c- p>][][</c-><c- mi>5</c-><c- p>],</c-> <c- n>property1</c-><c- o>></c-></code>
      <td>12
     <tr>
      <td><code class="highlight"><c- n>view</c-><c- o>&lt;</c-><c- b>int</c-><c- p>,</c-> <c- n>dimension</c-><c- o>&lt;</c-><c- mi>3</c-><c- p>,</c-> <c- mi>0</c-><c- p>,</c-> <c- n>dynamic_extent</c-><c- p>,</c-> <c- mi>5</c-><c- o>></c-><c- p>,</c-> <c- n>property1</c-><c- o>></c-></code>
      <td> 4 
     <tr>
      <td><code class="highlight"><c- n>view</c-><c- o>&lt;</c-><c- b>int</c-><c- p>[</c-><c- mi>3</c-><c- p>][</c-><c- mi>0</c-><c- p>][</c-><c- n>dynamic_extent</c-><c- p>][</c-><c- mi>5</c-><c- p>],</c-> <c- n>property1</c-><c- o>></c-></code>
      <td> 5 
     <tr>
      <td><code class="highlight"><c- n>view</c-><c- o>&lt;</c-><c- b>int</c-><c- p>,</c-> <c- mi>3</c-><c- p>,</c-> <c- mi>0</c-><c- p>,</c-> <c- n>dynamic_extent</c-><c- p>,</c-> <c- mi>5</c-><c- p>,</c-> <c- n>property1</c-><c- o>></c-></code>
      <td> 4 
     <tr>
      <td><code class="highlight"><c- n>view</c-><c- o>&lt;</c-><c- b>int</c-><c- p>,</c-> <c- mi>3</c-><c- p>,</c-> <c- mi>0</c-><c- p>,</c-> <c- n>dynamic_extent</c-><c- p>,</c-> <c- mi>5</c-><c- p>,</c-> <c- n>properties</c-><c- o>&lt;</c-><c- n>property1</c-><c- o>>></c-></code>
      <td> 2 
     <tr>
      <td><code class="highlight"><c- n>view</c-><c- o>&lt;</c-><c- n>arr</c-><c- o>&lt;</c-><c- b>int</c-><c- p>,</c-> <c- mi>3</c-><c- p>,</c-> <c- mi>0</c-><c- p>,</c-> <c- n>dynamic_extent</c-><c- p>,</c-> <c- mi>5</c-><c- o>></c-><c- p>,</c-> <c- n>property1</c-><c- o>></c-></code>
      <td> 4 
     <tr>
      <td><code class="highlight"><c- n>view</c-><c- o>&lt;</c-><c- b>int</c-><c- p>[</c-><c- mi>3</c-><c- p>][</c-><c- mi>0</c-><c- p>][][</c-><c- mi>5</c-><c- p>],</c-> <c- n>properties</c-><c- o>&lt;</c-><c- n>property1</c-><c- o>>></c-></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"><c- n>properties</c-><c- o>&lt;></c-></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"><c- n>view</c-></code> to <code class="highlight"><c- n>array_ref</c-></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"><c- n>view</c-><c- o>&lt;</c-><c- b>int</c-><c- p>[][][]</c-><c- o>>::</c-><c- n>layout</c-></code> should be named.</p>
    <li data-md>
     <p>Rename <code class="highlight"><c- n>is_regular</c-></code> (possibly to <code class="highlight"><c- n>is_affine</c-></code>) to avoid overloading
the term with the <code class="highlight"><c- n>Regular</c-></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"><c- k>operator</c-><c- p>()</c-></code>, take integral types by value.</p>
   </ul>
   <h3 class="heading settled" data-level="1.9" id="p0009r0--pre-2015-10-kona-mailing"><span class="secno">1.9. </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"><c- n>view</c-></code>) paper with
motivation, specification, and examples.</p>
   <h3 class="heading settled" data-level="1.10" id="related-activity"><span class="secno">1.10. </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"><c- n>span</c-></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"><c- n>span</c-></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"><c- n>mdspan</c-></code>)
defines types and functions for mapping multidimensional indices
in its <strong>domain</strong>, a
multidimensional index space, to the <code class="highlight"><c- n>mdspan</c-></code>'s <strong>codomain</strong>,
elements of a contiguous span of objects.
A <strong>multidimensional index space</strong> of <strong>rank</strong> 
    <math>R</math>
     is the Cartesian product 
    <math>[0, N</math>
    <sub>0</sub>) ⨯ [0, N<sub>1</sub>) ⨯ ... ⨯ [0, N<sub>R-1</sub>)
of half-open integer intervals.
A <strong>multidimensional index</strong> or <strong>multi-index</strong> is a member of a multidimensional index space.
An <code class="highlight"><c- n>mdspan</c-></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, <a href="http://wg21.link/p0367">P0367</a> proposed a rich set of potential access properties.
   </p>
   <p><strong>A multidimensional array is not an array-of-array-of-array-of...</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-of... 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>We intend the layout mapping of a multi-index to be a constant-time <code class="highlight"><c- k>constexpr</c-></code> operation that is trivially inlined and optimized when possible.
Compiler vendors may apply optimizations such as 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"><c- o>&lt;</c-><c- n>mdspan</c-><c- o>></c-></code> to the "C++ library headers" table in <strong>[headers]</strong>.</p>
   <p>Add the header <code class="highlight"><c- o>&lt;</c-><c- n>mdspan</c-><c- o>></c-></code> to the "Containers library summary" table in <strong>[containers.general]</strong> below the listing for <code class="highlight"><c- o>&lt;</c-><c- n>span</c-><c- o>></c-></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 the entire <strong>[views]</strong> subclause from the current draft, since it is
needed for <code class="highlight"><c- n>basic_mdspan</c-></code>. </blockquote>
   <hr>
   <p><br> <em>Add the following paragraphs to</em> <strong>[views.general]</strong>:</p>
   <p>
    �. The header <code class="highlight"><c- o>&lt;</c-><c- n>mdspan</c-><c- o>></c-></code> defines the view <code class="highlight"><c- n>basic_mdspan</c-></code>,
the type alias <code class="highlight"><c- n>mdspan</c-></code>, 
and other facilities for interacting with these views.
The <code class="highlight"><c- n>basic_mdspan</c-></code> object maps a multidimensional index
within its domain
to a reference of an element in the codomain.
The <em>domain</em> of a <code class="highlight"><c- n>basic_mdspan</c-></code> object is a multidimensional index space.
A <em>multidimensional index space</em> of <em>rank</em> 
    <math>R</math>
     is the Cartesian product 
    <math>[0, N</math>
    <sub>0</sub>) ⨯ [0, N<sub>1</sub>) ⨯ ... ⨯ [0, N<sub>R-1</sub>)
of half-open integer intervals.
A <strong>multidimensional index</strong> or <strong>multi-index</strong> is a member of a multidimensional index space.
The <em>codomain</em> of a <code class="highlight"><c- n>basic_mdspan</c-></code> object is a <code class="highlight"><c- n>span</c-></code> of elements.
   </p>
   <p>�. The <code class="highlight"><c- n>subspan</c-></code> function generates a <code class="highlight"><c- n>basic_mdspan</c-></code> with a <em>domain</em> contained within the input <code class="highlight"><c- n>basic_mdspan</c-></code> domain,
and a codomain contained within the input <code class="highlight"><c- n>basic_mdspan</c-></code> codomain.</p>
   <hr>
   <p><br> <em>Add the following subclauses to the end of the</em> <strong>[views]</strong> <em>subclause in the current draft</em>:</p>
   <p><br> <b>26.7.� Header <code class="highlight"><c- o>&lt;</c-><c- n>mdspan</c-><c- o>></c-></code> synopsis [mdspan.syn]</b></p>
<pre class="highlight"><c- k>namespace</c-> <c- n>std</c-> <c- p>{</c->
<c- k>namespace</c-> <c- n>experimental</c-> <c- p>{</c->
<c- k>namespace</c-> <c- n>fundamentals_v3</c-> <c- p>{</c->
  <c- c1>// [mdspan.extents], class template extents</c->
  <c- k>template</c-><c- o>&lt;</c-><c- b>ptrdiff_t</c-><c- p>...</c-> <c- n>StaticExtents</c-><c- o>></c->
    <c- k>class</c-> <c- nc>extents</c-><c- p>;</c->

  <c- c1>// [mdspan.layout], Layout mapping policies</c->
  <c- k>class</c-> <c- nc>layout_left</c-><c- p>;</c->
  <c- k>class</c-> <c- nc>layout_right</c-><c- p>;</c->
  <c- k>class</c-> <c- nc>layout_stride</c-><c- p>;</c->

  <c- c1>// [mdspan.accessor.basic]</c->
  <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>ElementType</c-><c- o>></c->
  <c- k>class</c-> <c- nc>accessor_basic</c-><c- p>;</c->

  <c- c1>// [mdspan.basic], class template mdspan</c->
  <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>ElementType</c-><c- p>,</c->
           <c- k>class</c-> <c- nc>Extents</c-><c- p>,</c->
           <c- k>class</c-> <c- nc>LayoutPolicy</c-> <c- o>=</c-> <c- n>layout_right</c-><c- p>,</c->
           <c- k>class</c-> <c- nc>AccessorPolicy</c-> <c- o>=</c-> <c- n>accessor_basic</c-><c- o>&lt;</c-><c- n>ElementType</c-><c- o>></c-> <c- o>></c->
    <c- k>class</c-> <c- nc>basic_mdspan</c-><c- p>;</c->

  <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>T</c-><c- p>,</c-> <c- b>ptrdiff_t</c-><c- p>...</c-> <c- n>Extents</c-><c- o>></c->
    <c- k>using</c-> <c- n>mdspan</c-> <c- o>=</c-> <c- n>basic_mdspan</c-><c- o>&lt;</c-><c- n>T</c-><c- p>,</c-> <c- n>extents</c-><c- o>&lt;</c-><c- n>Extents</c-><c- p>...</c-><c- o>>></c-><c- p>;</c->

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

  <c- c1>// [mdspan.subspan], subspan creation</c->
  <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>ElementType</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Extents</c-><c- p>,</c-> <c- k>class</c-> <c- nc>LayoutPolicy</c-><c- p>,</c->
           <c- k>class</c-> <c- nc>AccessorPolicy</c-><c- p>,</c-> <c- n>class</c-><c- p>...</c-> <c- n>SliceSpecifiers</c-><c- o>></c->
  <c- k>struct</c-> <c- n>mdspan_subspan</c-> <c- p>{</c-> <c- c1>// </c-><i><c- c1>exposition only</c-></i>
    <c- k>using</c-> <c- n>extents_t</c-> <c- o>=</c-> <i><c- n>see</c-> <c- n>below</c-></i><c- p>;</c->
    <c- k>using</c-> <c- n>layout_t</c-> <c- o>=</c-> <i><c- n>see</c-> <c- n>below</c-></i><c- p>;</c->
    <c- k>using</c-> <c- n>type</c-> <c- o>=</c-> <c- n>basic_mdspan</c-><c- o>&lt;</c-><c- n>ElementType</c-><c- p>,</c-> <c- n>extents_t</c-><c- p>,</c-> <c- n>layout_t</c-><c- p>,</c->
                              <c- k>typename</c-> <c- n>AccessorPolicy</c-><c- o>::</c-><c- n>offset_policy</c-><c- o>></c-><c- p>;</c->
  <c- p>};</c->

  <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>ElementType</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Extents</c-><c- p>,</c-> <c- k>class</c-> <c- nc>LayoutPolicy</c-><c- p>,</c->
           <c- k>class</c-> <c- nc>AccessorPolicy</c-><c- p>,</c-> <c- n>class</c-><c- p>...</c-> <c- n>SliceSpecifiers</c-><c- o>></c->
  <c- k>using</c-> <c- n>mdspan_subspan_t</c-> <c- o>=</c-> <c- c1>// </c-><i><c- c1>exposition only</c-></i>
    <c- k>typename</c-> <c- n>mdspan_subspan</c-><c- o>&lt;</c-><c- n>ElementType</c-><c- p>,</c-> <c- n>Extents</c-><c- p>,</c-> <c- n>LayoutPolicy</c-><c- p>,</c->
                            <c- n>AccessorPolicy</c-><c- p>,</c-> <c- n>SliceSpecifiers</c-><c- p>...</c-><c- o>>::</c-><c- n>type</c-><c- p>;</c->

  <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>ElementType</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Extents</c-><c- p>,</c-> <c- k>class</c-> <c- nc>LayoutPolicy</c-><c- p>,</c->
           <c- k>class</c-> <c- nc>AccessorPolicy</c-><c- p>,</c-> <c- n>class</c-><c- p>...</c-> <c- n>SliceSpecifiers</c-><c- o>></c->
    <c- n>mdspan_subspan_t</c-><c- o>&lt;</c-><c- n>ElementType</c-><c- p>,</c-> <c- n>Extents</c-><c- p>,</c-> <c- n>LayoutPolicy</c-><c- p>,</c->
                     <c- n>AccessorPolicy</c-><c- p>,</c-> <c- n>SliceSpecifiers</c-><c- p>...</c-><c- o>></c->
      <c- n>subspan</c-><c- p>(</c-><c- k>const</c-> <c- n>basic_mdspan</c-><c- o>&lt;</c-><c- n>ElementType</c-><c- p>,</c-> <c- n>Extents</c-><c- p>,</c-> <c- n>LayoutPolicy</c-><c- p>,</c->
                                 <c- n>AccessorPolicy</c-><c- o>>&amp;</c-> <c- n>src</c-><c- p>,</c-> <c- n>SliceSpecifiers</c-> <c- p>...</c-> <c- n>slices</c-><c- p>)</c-> <c- k>noexcept</c-><c- p>;</c->

  <c- c1>// tag supporting subspan</c->
  <c- k>struct</c-> <c- n>all_type</c-> <c- p>{</c-> <c- k>explicit</c-> <c- n>all_type</c-><c- p>()</c-> <c- o>=</c-> <c- k>default</c-><c- p>;</c-> <c- p>};</c->
  <c- kr>inline</c-> <c- k>constexpr</c-> <c- n>all_type</c-> <c- n>all</c-> <c- o>=</c-> <c- n>all_type</c-><c- p>{};</c->
<c- p>}}}</c->
</pre>
   <p><b>26.7.� Class template <code class="highlight"><c- n>extents</c-></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"><c- n>extents</c-></code> object defines a multidimensional index space.</p>
    <li data-md>
     <p>
      A <strong>multidimensional index space</strong> of <strong>rank</strong> 
      <math>R</math>
       is the Cartesian product 
      <math>[0, N</math>
      <sub>0</sub>) ⨯ [0, N<sub>1</sub>) ⨯ ... ⨯ [0, N<sub>R-1</sub>) of half-open integer intervals.
     </p>
    <li data-md>
     <p>The <em>dynamic extents</em> of an <code class="highlight"><c- n>extents</c-></code> object correspond to the template arguments in the <code class="highlight"><c- n>Extents</c-></code> parameter pack that equal <code class="highlight"><c- n>dynamic_extent</c-></code>.  Let <em>DynamicRank[i]</em> denote the index of the <em>i</em>th dynamic extent in the <code class="highlight"><c- n>Extents</c-></code> template parameter pack, and let <em>DynamicIndex[r]</em> indicate the number of dynamic extents in the first <em>r</em> entries of the <code class="highlight"><c- n>Extents</c-></code> parameter pack.</p>
    <li data-md>
     <p>An <code class="highlight"><c- n>extents</c-></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 template arguments in <code class="highlight"><c- n>Extents</c-></code> are negative and not equal to <code class="highlight"><c- n>dynamic_extent</c-></code>, the program is ill-formed.</p>
   </ol>
<pre class="highlight"><c- k>namespace</c-> <c- n>std</c-> <c- p>{</c->
<c- k>namespace</c-> <c- n>experimental</c-> <c- p>{</c->
<c- k>namespace</c-> <c- n>fundamentals_v3</c-> <c- p>{</c->

<c- k>template</c-><c- o>&lt;</c-><c- b>ptrdiff_t</c-><c- p>...</c-> <c- n>Extents</c-><c- o>></c->
<c- k>class</c-> <c- nc>extents</c-> <c- p>{</c->
<c- k>public</c-><c- o>:</c->
  <c- c1>// types</c->
  <c- k>using</c-> <c- n>index_type</c-> <c- o>=</c-> <c- b>ptrdiff_t</c-><c- p>;</c->

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

  <c- k>constexpr</c-> <c- n>extents</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>=</c-><c- p>(</c-><c- k>const</c-> <c- n>extents</c-><c- o>&amp;</c-><c- p>)</c-> <c- k>noexcept</c-> <c- o>=</c-> <c- k>default</c-><c- p>;</c->
  <c- k>constexpr</c-> <c- n>extents</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>=</c-><c- p>(</c-><c- n>extents</c-><c- o>&amp;&amp;</c-><c- p>)</c-> <c- k>noexcept</c-> <c- o>=</c-> <c- k>default</c-><c- p>;</c->
  <c- k>template</c-><c- o>&lt;</c-><c- b>ptrdiff_t</c-><c- p>...</c-> <c- n>OtherExtents</c-><c- o>></c->
  <c- k>constexpr</c-> <c- n>extents</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>=</c-><c- p>(</c-><c- k>const</c-> <c- n>extents</c-><c- o>&lt;</c-><c- n>OtherExtents</c-><c- p>...</c-><c- o>>&amp;</c-> <c- n>other</c-><c- p>);</c->

  <c- c1>// [mdspan.extents.obs], Observers of the domain multidimensional index space</c->
  <c- k>static</c-> <c- k>constexpr</c-> <c- b>size_t</c-> <c- nf>rank</c-><c- p>()</c-> <c- k>noexcept</c-><c- p>;</c->
  <c- k>static</c-> <c- k>constexpr</c-> <c- b>size_t</c-> <c- nf>rank_dynamic</c-><c- p>()</c-> <c- k>noexcept</c-><c- p>;</c->
  <c- k>static</c-> <c- k>constexpr</c-> <c- n>index_type</c-> <c- nf>static_extent</c-><c- p>(</c-><c- b>size_t</c-><c- p>)</c-> <c- k>noexcept</c-><c- p>;</c->
  <c- k>constexpr</c-> <c- n>index_type</c-> <c- nf>extent</c-><c- p>(</c-><c- b>size_t</c-><c- p>)</c-> <c- k>const</c-> <c- k>noexcept</c-><c- p>;</c->

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

<c- p>}}}</c->
</pre>
   <p><b>26.7.�.2 Constructors and assignment [mdspan.extents.cons]</b></p>
<pre class="language-c++ highlight"><c- n>constexpr</c-> <c- nf>extents</c-><c- p>()</c-> <c- n>noexcept</c-><c- p>;</c->
</pre>
   <ul>
    <li data-md>
     <p><em>Effects:</em> Aggregate-initializes <code class="highlight"><c- n>dynamic_extents_</c-></code> to <code class="highlight"><c- p>{</c-> <c- p>}</c-></code>.</p>
    <li data-md>
     <p>
      <em>Ensures:</em> Let 
      <math>R</math>
       equal <code class="highlight"><c- n>rank</c-><c- p>()</c-></code>. 
      <math>∀ </math>
      <code class="highlight"><c- n>r</c-></code> ∈ [0, R), 
         if <code class="highlight"><c- n>static_extent</c-><c- p>(</c-><c- n>r</c-><c- p>)</c-></code> equals <code class="highlight"><c- n>dynamic_extent</c-></code>, then <code class="highlight"><c- n>extent</c-><c- p>(</c-><c- n>r</c-><c- p>)</c-></code> equals <code class="highlight"><c- mi>0</c-></code>.
     </p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><c- n>constexpr</c-> <c- nf>extents</c-><c- p>(</c-><c- k>const</c-> <c- n>extents</c-><c- o>&amp;</c-> <c- n>other</c-><c- p>);</c->
<c- n>constexpr</c-> <c- nf>extents</c-><c- p>(</c-><c- n>extents</c-><c- o>&amp;&amp;</c-> <c- n>other</c-><c- p>);</c->
</pre>
   <ul>
    <li data-md>
     <p><em>Effects:</em> Initializes <code class="highlight"><c- n>dynamic_extents_</c-></code> with <code class="highlight"><c- n>other</c-><c- p>.</c-><c- n>dynamic_extents_</c-></code>.</p>
    <li data-md>
     <p>
      <em>Ensures:</em> Let 
      <math>R</math>
       equal <code class="highlight"><c- n>rank</c-><c- p>()</c-></code>. 
      <math>∀ </math>
      <code class="highlight"><c- n>r</c-></code> ∈ [0, R), <code class="highlight"><c- n>extent</c-><c- p>(</c-><c- n>r</c-><c- p>)</c-></code> equals <code class="highlight"><c- n>other</c-><c- p>.</c-><c- n>extent</c-><c- p>(</c-><c- n>r</c-><c- p>)</c-></code>.
     </p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><c- n>template</c-><c- o>&lt;</c-><c- b>ptrdiff_t</c-><c- p>...</c-> <c- n>OtherExtents</c-><c- o>></c->
<c- n>constexpr</c-> <c- n>extents</c-><c- p>(</c-><c- k>const</c-> <c- n>extents</c-><c- o>&lt;</c-><c- n>OtherExtents</c-><c- p>...</c-><c- o>>&amp;</c-> <c- n>other</c-><c- p>);</c->
</pre>
   <ul>
    <li data-md>
     <p>
      <em>Requires:</em> Let 
      <math>R</math>
       equal <code class="highlight"><c- n>rank</c-><c- p>()</c-></code>. 
      <math>∀ </math>
      <code class="highlight"><c- n>r</c-></code> ∈ [0, R), 
         if <code class="highlight"><c- n>static_extent</c-><c- p>(</c-><c- n>r</c-><c- p>)</c-></code> does not equal <code class="highlight"><c- n>dynamic_extent</c-></code>, 
         then <code class="highlight"><c- n>static_extent</c-><c- p>(</c-><c- n>r</c-><c- p>)</c-></code> equals <code class="highlight"><c- n>other</c-><c- p>.</c-><c- n>extent</c-><c- p>(</c-><c- n>r</c-><c- p>)</c-></code>.
     </p>
    <li data-md>
     <p><em>Constraints:</em> <code class="highlight"><c- k>sizeof</c-><c- p>...(</c-><c- n>Extents</c-><c- p>)</c-></code> equals <code class="highlight"><c- k>sizeof</c-><c- p>...(</c-><c- n>OtherExtents</c-><c- p>)</c-></code>.</p>
    <li data-md>
     <p>
      <em>Effects:</em> Let 
      <math>R</math>
       equal <code class="highlight"><c- n>rank</c-><c- p>()</c-></code>. 
      <math>∀ </math>
      <code class="highlight"><c- n>r</c-></code> ∈ [0, R), 
         if <code class="highlight"><c- n>static_extent</c-><c- p>(</c-><c- n>r</c-><c- p>)</c-></code> equals <code class="highlight"><c- n>dynamic_extent</c-></code>, 
         then this initializes <code class="highlight"><c- n>dynamic_extents_</c-><c- p>[</c-></code><em>DynamicRank[</em><code class="highlight"><c- n>r</c-></code><em>]</em><code class="highlight"><c- p>]</c-></code> with <code class="highlight"><c- n>other</c-><c- p>.</c-><c- n>extent</c-><c- p>(</c-><c- n>r</c-><c- p>)</c-></code>.
     </p>
    <li data-md>
     <p><em>Ensures:</em> <code class="highlight"><c- o>*</c-><c- k>this</c-> <c- o>==</c-> <c- n>other</c-></code> is <code class="highlight">true</code>.</p>
    <li data-md>
     <p><em>Throws:</em> Nothing.</p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><c- n>template</c-><c- o>&lt;</c-><c- n>class</c-><c- p>...</c-> <c- n>IndexType</c-><c- o>></c->
<c- n>constexpr</c-> <c- n>extents</c-><c- p>(</c-><c- n>IndexType</c-><c- p>...</c-> <c- n>dynamic_extents</c-><c- p>)</c-> <c- n>noexcept</c-><c- p>;</c->
</pre>
   <ul>
    <li data-md>
     <p><em>Requires:</em> <code class="highlight"><c- p>(</c-><c- n>dynamic_extents</c-><c- o>>=</c-><c- mi>0</c-><c- p>)</c-> <c- o>&amp;&amp;</c-> <c- p>...</c-></code> is <code class="highlight">true</code>.</p>
    <li data-md>
     <p><em>Constraints:</em></p>
     <ul>
      <li data-md>
       <p><code class="highlight"><c- n>is_convertible_v</c-><c- o>&lt;</c-><c- n>IndexType</c-><c- p>,</c-> <c- n>index_type</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- p>...</c-></code> is <code class="highlight">true</code>, and</p>
      <li data-md>
       <p><code class="highlight"><c- k>sizeof</c-><c- p>...(</c-><c- n>dynamic_extents</c-><c- p>)</c-><c- o>==</c-><c- n>rank_dynamic</c-><c- p>()</c-></code> is <code class="highlight">true</code>.</p>
     </ul>
    <li data-md>
     <p><em>Effects:</em> Aggregate-initializes <code class="highlight"><c- n>dynamic_extents_</c-></code> to <code class="highlight"><c- p>{</c-><c- n>dynamic_extents</c-><c- p>...}</c-></code>.</p>
    <li data-md>
     <p><em>Ensures:</em> <code class="highlight"><c- n>extent</c-><c- p>(</c-></code><em>DynamicRank[i]</em><code class="highlight"><c- p>)</c-></code> is equal to the <em>i</em>th entry in the parameter pack <code class="highlight"><c- n>dynamic_extents</c-></code>.</p>
   </ul>
<pre class="language-c++ highlight"><c- n>template</c-><c- o>&lt;</c-><c- n>class</c-> <c- n>IndexType</c-><c- p>,</c-> <c- b>size_t</c-> <c- n>rank_dynamic</c-><c- o>></c->
<c- n>constexpr</c-> <c- n>extents</c-><c- p>(</c-><c- k>const</c-> <c- n>array</c-><c- o>&lt;</c-><c- n>IndexType</c-><c- p>,</c-> <c- n>rank_dynamic</c-><c- o>></c-> <c- o>&amp;</c-> <c- n>dynamic_extents</c-><c- p>)</c-> <c- n>noexcept</c-><c- p>;</c->
</pre>
   <ul>
    <li data-md>
     <p>
      <em>Requires:</em> Let 
      <math>D</math>
       equal <code class="highlight"><c- n>rank_dynamic</c-><c- p>()</c-></code>. 
      <math>∀ </math>
      <code class="highlight"><c- n>i</c-></code> ∈ [0, D), <code class="highlight"><c- n>dynamic_extents</c-><c- p>[</c-><c- n>i</c-><c- p>]</c-> <c- o>>=</c-> <c- mi>0</c-></code> is <code class="highlight">true</code>.
     </p>
    <li data-md>
     <p><em>Constraints:</em> <code class="highlight"><c- n>is_convertible_v</c-><c- o>&lt;</c-><c- n>IndexType</c-><c- p>,</c-> <c- n>index_type</c-><c- o>></c-></code> is <code class="highlight">true</code>.</p>
    <li data-md>
     <p><em>Effects:</em> Initializes <code class="highlight"><c- n>dynamic_extents_</c-></code> with <code class="highlight"><c- n>dynamic_extents</c-></code>.</p>
    <li data-md>
     <p><em>Ensures:</em> <code class="highlight"><c- n>extent</c-><c- p>(</c-></code><em>DynamicRank[i]</em><code class="highlight"><c- p>)</c-></code> equals <code class="highlight"><c- n>dynamic_extents</c-><c- p>[</c-><c- n>i</c-><c- p>]</c-></code>.</p>
   </ul>
<pre class="language-c++ highlight"><c- n>template</c-><c- o>&lt;</c-><c- b>ptrdiff_t</c-><c- p>...</c-> <c- n>OtherExtents</c-><c- o>></c->
<c- n>constexpr</c-> <c- n>extents</c-><c- o>&amp;</c-> <c- n>operator</c-><c- o>=</c-><c- p>(</c-><c- k>const</c-> <c- n>extents</c-><c- o>&lt;</c-><c- n>OtherExtents</c-><c- p>...</c-><c- o>>&amp;</c-> <c- n>other</c-><c- p>);</c->
</pre>
   <ul>
    <li data-md>
     <p>
      <em>Requires:</em> Let 
      <math>R</math>
       equal <code class="highlight"><c- n>rank</c-><c- p>()</c-></code>. 
      <math>∀ </math>
      <code class="highlight"><c- n>r</c-></code> ∈ [0, R), <code class="highlight"><c- n>static_extent</c-><c- p>(</c-><c- n>r</c-><c- p>)</c-> <c- o>!=</c-> <c- n>dynamic_extent</c-> <c- o>||</c-> <c- n>static_extent</c-><c- p>(</c-><c- n>r</c-><c- p>)</c-> <c- o>==</c-> <c- n>other</c-><c- p>.</c-><c- n>extent</c-><c- p>(</c-><c- n>r</c-><c- p>)</c-></code> is <code class="highlight">true</code>.
     </p>
    <li data-md>
     <p><em>Constraints:</em> <code class="highlight"><c- k>sizeof</c-><c- p>...(</c-><c- n>Extents</c-><c- p>)</c-><c- o>==</c-><c- k>sizeof</c-><c- p>...(</c-><c- n>OtherExtents</c-><c- p>)</c-></code> is <code class="highlight">true</code>.</p>
    <li data-md>
     <p>
      <em>Effects:</em> Let 
      <math>R</math>
       equal <code class="highlight"><c- n>rank</c-><c- p>()</c-></code>. 
      <math>∀ </math>
      <code class="highlight"><c- n>r</c-></code> ∈ [0, R),
         if <code class="highlight"><c- n>static_extent</c-><c- p>(</c-><c- n>r</c-><c- p>)</c-></code> equals <code class="highlight"><c- n>dynamic_extent</c-></code>, 
         assigns <code class="highlight"><c- n>dynamic_extents_</c-><c- p>[</c-></code><em>DynamicRank[</em><code class="highlight"><c- n>r</c-></code><em>]</em><code class="highlight"><c- p>]</c-></code> to <code class="highlight"><c- n>other</c-><c- p>.</c-><c- n>extent</c-><c- p>(</c-><c- n>r</c-><c- p>)</c-></code>.
     </p>
    <li data-md>
     <p><em>Ensures:</em> <code class="highlight"><c- o>*</c-><c- k>this</c-><c- o>==</c-><c- n>other</c-></code> is <code class="highlight">true</code>.</p>
    <li data-md>
     <p><em>Returns:</em> <code class="highlight"><c- o>*</c-><c- k>this</c-></code>.</p>
    <li data-md>
     <p><em>Throws:</em> Nothing.</p>
   </ul>
   <p><br> <b>26.7.�.3 Observers of the domain multidimensional index space [mdspan.extents.obs]</b></p>
   <p><br></p>
<pre class="language-c++ highlight"><c- k>static</c-> <c- n>constexpr</c-> <c- b>size_t</c-> <c- nf>rank</c-><c- p>()</c-> <c- k>const</c-> <c- n>noexcept</c-><c- p>;</c->
</pre>
   <ul>
    <li data-md>
     <p><em>Returns:</em> <code class="highlight"><c- k>sizeof</c-><c- p>...(</c-><c- n>Extents</c-><c- p>)</c-></code></p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><c- k>static</c-> <c- n>constexpr</c-> <c- b>size_t</c-> <c- nf>rank_dynamic</c-><c- p>()</c-> <c- k>const</c-> <c- n>noexcept</c-><c- p>;</c->
</pre>
   <ul>
    <li data-md>
     <p><em>Returns:</em></p>
     <ul>
      <li data-md>
       <p>If <code class="highlight"><c- k>sizeof</c-><c- p>...(</c-><c- n>Extents</c-><c- p>)</c-><c- o>==</c-><c- mi>0</c-></code> is <code class="highlight">true</code>, then zero;</p>
      <li data-md>
       <p>Otherwise, <code class="highlight"><c- p>((</c-><c- n>Extents</c-><c- o>==</c-><c- n>dynamic_extent</c-><c- p>)</c-><c- o>+</c-><c- p>...)</c-></code>.</p>
     </ul>
   </ul>
   <p><em>[Note:</em> This is the number of dynamic extents. <em>—end note]</em></p>
   <p><br></p>
<pre class="language-c++ highlight"><c- k>static</c-> <c- n>constexpr</c-> <c- n>index_type</c-> <c- nf>static_extent</c-><c- p>(</c-><c- b>size_t</c-> <c- n>r</c-><c- p>)</c-> <c- k>const</c-> <c- n>noexcept</c-><c- p>;</c->
</pre>
   <ul>
    <li data-md>
     <p><em>Returns:</em></p>
     <ul>
      <li data-md>
       <p>If 0 &lt;= <code class="highlight"><c- n>r</c-></code> &lt; <code class="highlight"><c- n>rank</c-><c- p>()</c-></code>, then the <code class="highlight"><c- n>r</c-></code>th entry
  in the <code class="highlight"><c- n>Extents</c-></code> parameter pack;</p>
      <li data-md>
       <p>Otherwise, 1.</p>
     </ul>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><c- n>constexpr</c-> <c- n>index_type</c-> <c- nf>extent</c-><c- p>(</c-><c- b>size_t</c-> <c- n>r</c-><c- p>)</c-> <c- k>const</c-> <c- n>noexcept</c-><c- p>;</c->
</pre>
   <ul>
    <li data-md>
     <p><em>Returns:</em></p>
     <ul>
      <li data-md>
       <p>If <code class="highlight"><c- n>static_extent</c-><c- p>(</c-><c- n>r</c-><c- p>)</c-><c- o>==</c-><c- n>dynamic_extent</c-></code>, then <code class="highlight"><c- n>dynamic_extents_</c-><c- p>[</c-></code><em>DynamicRank[</em><code class="highlight"><c- n>r</c-></code><em>]</em><code class="highlight"><c- p>]</c-></code>;</p>
      <li data-md>
       <p>Otherwise, <code class="highlight"><c- n>static_extent</c-><c- p>(</c-><c- n>r</c-><c- p>)</c-></code>.</p>
     </ul>
   </ul>
   <p><br> <b>26.7.�.4 <code class="highlight"><c- n>extents</c-></code> comparison operators [mdspan.extents.compare]</b></p>
<pre class="language-c++ highlight"><c- n>template</c-><c- o>&lt;</c-><c- b>ptrdiff_t</c-><c- p>...</c-> <c- n>LHS</c-><c- p>,</c-> <c- b>ptrdiff_t</c-><c- p>...</c-> <c- n>RHS</c-><c- o>></c->
  <c- n>constexpr</c-> <c- b>bool</c-> <c- n>operator</c-><c- o>==</c-><c- p>(</c-><c- k>const</c-> <c- n>extents</c-><c- o>&lt;</c-><c- n>LHS</c-><c- p>...</c-><c- o>>&amp;</c-> <c- n>lhs</c-><c- p>,</c-> <c- k>const</c-> <c- n>extents</c-><c- o>&lt;</c-><c- n>RHS</c-><c- p>...</c-><c- o>>&amp;</c-> <c- n>rhs</c-><c- p>)</c-> <c- n>noexcept</c-><c- p>;</c->
</pre>
   <ul>
    <li data-md>
     <p><em>Returns:</em></p>
     <ul>
      <li data-md>
       <p>If <code class="highlight"><c- n>lhs</c-><c- p>.</c-><c- n>rank</c-><c- p>()</c-><c- o>==</c-><c- n>rhs</c-><c- p>.</c-><c- n>rank</c-><c- p>()</c-> <c- o>&amp;&amp;</c-> <c- n>lhs</c-><c- p>.</c-><c- n>extents</c-><c- p>(</c-><c- n>r</c-><c- p>)</c-><c- o>==</c-><c- n>rhs</c-><c- p>.</c-><c- n>extents</c-><c- p>(</c-><c- n>r</c-><c- p>)</c-></code> is <code class="highlight">true</code> for all <code class="highlight"><c- n>r</c-></code> in the range <code class="highlight"><c- p>[</c-><c- mi>0</c-><c- p>,</c-> <c- n>lhs</c-><c- p>.</c-><c- n>rank</c-><c- p>())</c-></code>, then <code class="highlight">true</code>;</p>
      <li data-md>
       <p>Otherwise, <code class="highlight">false</code>.</p>
     </ul>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><c- n>template</c-><c- o>&lt;</c-><c- b>ptrdiff_t</c-><c- p>...</c-> <c- n>LHS</c-><c- p>,</c-> <c- b>ptrdiff_t</c-><c- p>...</c-> <c- n>RHS</c-><c- o>></c->
  <c- n>constexpr</c-> <c- b>bool</c-> <c- n>operator</c-><c- o>!=</c-><c- p>(</c-><c- k>const</c-> <c- n>extents</c-><c- o>&lt;</c-><c- n>LHS</c-><c- p>...</c-><c- o>>&amp;</c-> <c- n>lhs</c-><c- p>,</c-> <c- k>const</c-> <c- n>extents</c-><c- o>&lt;</c-><c- n>RHS</c-><c- p>...</c-><c- o>>&amp;</c-> <c- n>rhs</c-><c- p>)</c-> <c- n>noexcept</c-><c- p>;</c->
</pre>
   <ul>
    <li data-md>
     <p><em>Returns:</em> <code class="highlight"><c- o>!</c-><c- p>(</c-><c- n>lhs</c-><c- o>==</c-><c- n>rhs</c-><c- p>)</c-></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> meets the requirements in Table �.</p>
    <li data-md>
     <p>A <em>layout mapping</em> meets the requirements of <em>Cpp17DefaultConstructible</em>, <em>Cpp17CopyAssignable</em>, <em>Cpp17EqualityComparable</em>, and the requirements in Table �.</p>
    <li data-md>
     <p>In Table �:</p>
     <ul>
      <li data-md>
       <p><code class="highlight"><c- n>MP</c-></code> denotes a layout mapping policy.</p>
      <li data-md>
       <p><code class="highlight"><c- n>E</c-></code> denotes a specialization of <code class="highlight"><c- n>extents</c-></code>.</p>
      <li data-md>
       <p><code class="highlight"><c- n>e</c-></code> denotes an object of type <code class="highlight"><c- n>E</c-></code> defining a multidimensional index space.</p>
      <li data-md>
       <p><code class="highlight"><c- n>r</c-></code> is a value of an integral type such that 0 &lt;= <code class="highlight"><c- n>r</c-></code> &lt; <code class="highlight"><c- n>e</c-><c- p>.</c-><c- n>rank</c-><c- p>()</c-></code>.</p>
      <li data-md>
       <p>
        If <code class="highlight"><c- n>k</c-><c- p>...</c-></code> is a pack of an integer type, we say that "<code class="highlight"><c- n>k</c-><c- p>...</c-></code> is in <code class="highlight"><c- n>e</c-></code>"
  if <code class="highlight"><c- n>k</c-><c- p>...</c-></code> denotes a multi-index in <code class="highlight"><c- n>e</c-></code>.
  Let the packs of integer type <code class="highlight"><c- n>i</c-><c- p>...</c-></code> and <code class="highlight"><c- n>j</c-><c- p>...</c-></code> be in <code class="highlight"><c- n>e</c-></code>.
  Denote the 
        <math>r</math>
        -th member of packs <code class="highlight"><c- n>i</c-><c- p>...</c-></code> and <code class="highlight"><c- n>j</c-><c- p>...</c-></code> by 
        <math>i</math>
        <sub>r</sub> and 
        <math>j</math>
        <sub>r</sub>, respectively. 
  Let <code class="highlight"><c- n>r</c-></code> equal 
        <math>r</math>
        . <code class="highlight"><c- k>sizeof</c-><c- p>...(</c-><c- n>i</c-><c- p>)</c-><c- o>==</c-><c- n>E</c-><c- o>::</c-><c- n>rank</c-><c- p>()</c-></code> is <code class="highlight">true</code>, 
  0 &lt;= 
        <math>i</math>
        <sub>r</sub> &lt; <code class="highlight"><c- n>e</c-><c- p>.</c-><c- n>extent</c-><c- p>(</c-><c- n>r</c-><c- p>)</c-></code>, <code class="highlight"><c- k>sizeof</c-><c- p>...(</c-><c- n>j</c-><c- p>)</c-><c- o>==</c-><c- n>E</c-><c- o>::</c-><c- n>rank</c-><c- p>()</c-></code>, and
  0 &lt;= 
        <math>j</math>
        <sub>r</sub> &lt; <code class="highlight"><c- n>e</c-><c- p>.</c-><c- n>extent</c-><c- p>(</c-><c- n>r</c-><c- p>)</c-></code>.
       </p>
      <li data-md>
       <p><code class="highlight"><c- n>M</c-></code> denotes a layout mapping class.</p>
      <li data-md>
       <p><code class="highlight"><c- n>m</c-></code> denotes an object of type <code class="highlight"><c- n>M</c-></code> that maps a pack <code class="highlight"><c- n>i</c-><c- p>...</c-></code> denoting a multi-index 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>Returns
      <th>Requires
     <tr>
      <td><code class="highlight"><c- n>MP</c-><c- o>::</c-><c- k>template</c-> <c- n>mapping</c-><c- o>&lt;</c-><c- n>E</c-><c- o>></c-></code>
      <td><code class="highlight"><c- n>M</c-></code>
      <td>
      <td>
     <tr>
      <td><code class="highlight"><c- n>m</c-><c- p>.</c-><c- n>extents</c-><c- p>()</c-></code>
      <td><code class="highlight"><c- n>E</c-></code>
      <td>
       <p><em>Returns:</em> <code class="highlight"><c- n>e</c-></code>.</p>
      <td>
     <tr>
      <td><code class="highlight"><c- n>m</c-><c- p>(</c-><c- n>i</c-><c- p>...)</c-></code>
      <td><code class="highlight"><c- n>E</c-><c- o>::</c-><c- n>index_type</c-></code>
      <td><em>Returns:</em> Mapping of a multi-index <code class="highlight"><c- n>i</c-><c- p>...</c-></code> . 
      <td><em>Requires:</em> 0 &lt;= <code class="highlight"><c- n>m</c-><c- p>(</c-><c- n>i</c-><c- p>...)</c-></code>. 
     <tr>
      <td><code class="highlight"><c- n>m</c-><c- p>.</c-><c- n>required_span_size</c-><c- p>()</c-></code>
      <td><code class="highlight"><c- n>E</c-><c- o>::</c-><c- n>index_type</c-></code>
      <td><em>Returns:</em> If the multidimensional index space that <code class="highlight"><c- n>e</c-></code> defines is empty, then zero,
      else 1 plus the maximum value of <code class="highlight"><c- n>m</c-><c- p>(</c-><c- n>i</c-><c- p>...)</c-></code> for all <code class="highlight"><c- n>i</c-><c- p>...</c-></code> in <code class="highlight"><c- n>e</c-></code>.
      <td>
     <tr>
      <td><code class="highlight"><c- n>m</c-><c- p>.</c-><c- n>is_unique</c-><c- p>()</c-></code>
      <td><code class="highlight"><c- b>bool</c-></code>
      <td><em>Returns:</em> <code class="highlight">true</code> if for every <code class="highlight"><c- n>i</c-><c- p>...</c-><c- o>!=</c-><c- n>j</c-><c- p>...</c-></code>, <code class="highlight"><c- n>m</c-><c- p>(</c-><c- n>i</c-><c- p>...)</c-><c- o>!=</c-><c- n>m</c-><c- p>(</c-><c- n>j</c-><c- p>...)</c-></code> is <code class="highlight">true</code>. 
      <td>
     <tr>
      <td><code class="highlight"><c- n>m</c-><c- p>.</c-><c- n>is_contiguous</c-><c- p>()</c-></code>
      <td><code class="highlight"><c- b>bool</c-></code>
      <td><em>Returns:</em> <code class="highlight">true</code> if the set defined by <code class="highlight"><c- n>m</c-><c- p>(</c-><c- n>i</c-><c- p>)...</c-></code> equals the set {0, ..., <code class="highlight"><c- n>m</c-><c- p>.</c-><c- n>required_span_size</c-><c- p>()</c-><c- o>-</c-><c- mi>1</c-></code>}. 
      <td>
     <tr>
      <td><code class="highlight"><c- n>m</c-><c- p>.</c-><c- n>is_strided</c-><c- p>()</c-></code>
      <td><code class="highlight"><c- b>bool</c-></code>
      <td>
       <em>Returns:</em> <code class="highlight">true</code> if there exists an integer 
       <math>σ</math>
       <sub>r</sub> such that, for all <code class="highlight"><c- n>j</c-><c- p>...</c-></code> and <code class="highlight"><c- n>i</c-><c- p>...</c-></code> in <code class="highlight"><c- n>e</c-></code>,
       if all members of <code class="highlight"><c- n>j</c-><c- p>...</c-></code> and <code class="highlight"><c- n>i</c-><c- p>...</c-></code> are equal
       except for exactly one r-th member where 
       <math>j</math>
       <sub>r</sub> equals 
       <math>i</math>
       <sub>r</sub> + 1, 
       then <code class="highlight"><c- n>m</c-><c- p>(</c-><c- n>j</c-><c- p>...)</c-> <c- o>-</c-> <c- n>m</c-><c- p>(</c-><c- n>i</c-><c- p>...)</c-></code> equals 
       <math>σ</math>
       <sub>r</sub>.
      <td>
     <tr>
      <td><code class="highlight"><c- n>M</c-><c- o>::</c-><c- n>is_always_unique</c-><c- p>()</c-></code>
      <td><code class="highlight"><c- b>bool</c-></code>
      <td><em>Returns:</em> <code class="highlight">true</code> if <code class="highlight"><c- n>m</c-><c- p>.</c-><c- n>is_unique</c-><c- p>()</c-></code> is <code class="highlight">true</code> for any object of type <code class="highlight"><c- n>M</c-></code>.
      <td>
     <tr>
      <td><code class="highlight"><c- n>M</c-><c- o>::</c-><c- n>is_always_contiguous</c-><c- p>()</c-></code>
      <td><code class="highlight"><c- b>bool</c-></code>
      <td><em>Returns:</em> <code class="highlight">true</code> if <code class="highlight"><c- n>m</c-><c- p>.</c-><c- n>is_contiguous</c-><c- p>()</c-></code> is <code class="highlight">true</code> for any object of type <code class="highlight"><c- n>M</c-></code>.
      <td>
     <tr>
      <td><code class="highlight"><c- n>M</c-><c- o>::</c-><c- n>is_always_strided</c-><c- p>()</c-></code>
      <td><code class="highlight"><c- b>bool</c-></code>
      <td><em>Returns:</em> true if <code class="highlight"><c- n>m</c-><c- p>.</c-><c- n>is_strided</c-><c- p>()</c-></code> is <code class="highlight">true</code> for any object of type <code class="highlight"><c- n>M</c-></code>.
      <td>
     <tr>
      <td><code class="highlight"><c- n>m</c-><c- p>.</c-><c- n>stride</c-><c- p>(</c-><c- n>r</c-><c- p>)</c-></code>
      <td><code class="highlight"><c- n>E</c-><c- o>::</c-><c- n>index_type</c-></code>
      <td>
       <em>Returns:</em> 
       <math>σ</math>
       <sub>r</sub>, as defined for <code class="highlight"><c- n>m</c-><c- p>.</c-><c- n>is_strided</c-><c- p>()</c-></code> above.
      We say that 
       <math>σ</math>
       <sub>r</sub> is the <em>stride</em> of ordinate <code class="highlight"><c- n>r</c-></code>. 
      <td><em>Requires:</em> <code class="highlight"><c- n>m</c-><c- p>.</c-><c- n>is_strided</c-><c- p>()</c-></code> is <code class="highlight">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"><c- n>layout_left</c-></code> meets the requirements of layout mapping policy. <em>[Note:</em> Thus, any well-formed specialization of <code class="highlight"><c- n>layout_left</c-><c- o>::</c-><c- k>template</c-> <c- n>mapping</c-></code> meets the requirements of layout mapping. <em>—end note]</em></p>
    <li data-md>
     <p><code class="highlight"><c- n>layout_left</c-></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"><c- n>Extents</c-></code> is not a (possibly cv-qualified) specialization of <code class="highlight"><c- n>extents</c-></code>, then the program is ill-formed.</p>
   </ol>
<pre class="highlight"><c- k>namespace</c-> <c- n>std</c-> <c- p>{</c->
<c- k>namespace</c-> <c- n>experimental</c-> <c- p>{</c->
<c- k>namespace</c-> <c- n>fundamentals_v3</c-> <c- p>{</c->

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

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

    <c- c1>// [mdspan.layout.left.ops], layout_left::mapping operations</c->
    <c- n>Extents</c-> <c- nf>extents</c-><c- p>()</c-> <c- k>const</c-> <c- k>noexcept</c-><c- p>;</c->

    <c- k>constexpr</c-> <c- k>typename</c-> <c- n>Extents</c-><c- o>::</c-><c- n>index_type</c-> <c- n>required_span_size</c-><c- p>()</c-> <c- k>const</c-> <c- k>noexcept</c-><c- p>;</c->

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

    <c- k>static</c-> <c- k>constexpr</c-> <c- b>bool</c-> <c- nf>is_always_unique</c-><c- p>();</c->
    <c- k>static</c-> <c- k>constexpr</c-> <c- b>bool</c-> <c- nf>is_always_contiguous</c-><c- p>();</c->
    <c- k>static</c-> <c- k>constexpr</c-> <c- b>bool</c-> <c- nf>is_always_strided</c-><c- p>();</c->

    <c- k>constexpr</c-> <c- b>bool</c-> <c- nf>is_unique</c-><c- p>()</c-> <c- k>const</c-><c- p>;</c->
    <c- k>constexpr</c-> <c- b>bool</c-> <c- nf>is_contiguous</c-><c- p>()</c-> <c- k>const</c-><c- p>;</c->
    <c- k>constexpr</c-> <c- b>bool</c-> <c- nf>is_strided</c-><c- p>()</c-> <c- k>const</c-><c- p>;</c->

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

    <c- k>typename</c-> <c- n>Extents</c-><c- o>::</c-><c- n>index_type</c-> <c- n>stride</c-><c- p>(</c-><c- b>size_t</c-> <c- n>rank</c-><c- p>)</c-> <c- k>const</c-> <c- k>noexcept</c-><c- p>;</c->

  <c- k>private</c-><c- o>:</c->
    <c- n>Extents</c-> <c- n>extents_</c-><c- p>;</c-> <c- c1>// </c-><i><c- c1>exposition only</c-></i>
  <c- p>};</c->
<c- p>};</c->

<c- p>}}}</c->
</pre>
   <p><br></p>
   <p><b>26.7.�.2.1 <code class="highlight"><c- n>layout_left</c-><c- o>::</c-><c- n>mapping</c-></code> constructors [mdspan.layout.left.cons]</b></p>
   <p><br></p>
<pre class="language-c++ highlight"><c- n>constexpr</c-> <c- nf>mapping</c-><c- p>()</c-> <c- n>noexcept</c-><c- p>;</c->
</pre>
   <ul>
    <li data-md>
     <p><em>Effects:</em> Default-initializes <code class="highlight"><c- n>extents_</c-></code>.</p>
    <li data-md>
     <p><em>Ensures:</em> <code class="highlight"><c- n>extents</c-><c- p>()</c-><c- o>==</c-><c- n>Extents</c-><c- p>()</c-></code> is <code class="highlight">true</code>.</p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><c- n>constexpr</c-> <c- nf>mapping</c-><c- p>(</c-><c- k>const</c-> <c- n>mapping</c-><c- o>&amp;</c-> <c- n>other</c-><c- p>)</c-> <c- n>noexcept</c-><c- p>;</c->
</pre>
   <ul>
    <li data-md>
     <p><em>Effects:</em> Initializes <code class="highlight"><c- n>extents_</c-></code> with <code class="highlight"><c- n>other</c-><c- p>.</c-><c- n>extents_</c-></code>.</p>
    <li data-md>
     <p><em>Ensures:</em> <code class="highlight"><c- n>extents</c-><c- p>()</c-><c- o>==</c-><c- n>other</c-><c- p>.</c-><c- n>extents</c-><c- p>()</c-></code> is <code class="highlight">true</code>.</p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><c- n>constexpr</c-> <c- nf>mapping</c-><c- p>(</c-><c- n>mapping</c-><c- o>&amp;&amp;</c-> <c- n>other</c-><c- p>)</c-> <c- n>noexcept</c-><c- p>;</c->
</pre>
   <ul>
    <li data-md>
     <p><em>Effects:</em> Initializes <code class="highlight"><c- n>extents_</c-></code> with <code class="highlight"><c- n>move</c-><c- p>(</c-><c- n>other</c-><c- p>.</c-><c- n>extents_</c-><c- p>)</c-></code>.</p>
    <li data-md>
     <p><em>Ensures:</em> <code class="highlight"><c- n>extents</c-><c- p>()</c-></code> equals the result of <code class="highlight"><c- n>other</c-><c- p>.</c-><c- n>extents</c-><c- p>()</c-></code> before the invocation of the move.</p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><c- n>constexpr</c-> <c- nf>mapping</c-><c- p>(</c-><c- k>const</c-> <c- n>Extents</c-> <c- o>&amp;</c-> <c- n>e</c-><c- p>)</c-> <c- n>noexcept</c-><c- p>;</c->
</pre>
   <ul>
    <li data-md>
     <p><em>Effects:</em> Initializes <code class="highlight"><c- n>extents_</c-></code> with <code class="highlight"><c- n>e</c-></code>.</p>
    <li data-md>
     <p><em>Ensures:</em> <code class="highlight"><c- n>extents</c-><c- p>()</c-><c- o>==</c-><c- n>e</c-></code> is <code class="highlight">true</code>.</p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><c- n>template</c-><c- o>&lt;</c-><c- n>class</c-> <c- n>OtherExtents</c-><c- o>></c->
<c- n>constexpr</c-> <c- n>mapping</c-><c- p>(</c-><c- k>const</c-> <c- n>mapping</c-><c- o>&lt;</c-><c- n>OtherExtents</c-><c- o>>&amp;</c-> <c- n>other</c-><c- p>);</c->
</pre>
   <ul>
    <li data-md>
     <p><em>Requires:</em> <code class="highlight"><c- n>other</c-><c- p>.</c-><c- n>extents</c-><c- p>()</c-></code> meets the requirements for use in the initialization of <code class="highlight"><c- n>extents_</c-></code>.</p>
    <li data-md>
     <p><em>Effects:</em> Initializes <code class="highlight"><c- n>extents_</c-></code> with <code class="highlight"><c- n>other</c-><c- p>.</c-><c- n>extents</c-><c- p>()</c-></code>.</p>
    <li data-md>
     <p><em>Ensures:</em> <code class="highlight"><c- n>extents</c-><c- p>()</c-><c- o>==</c-><c- n>other</c-><c- p>.</c-><c- n>extents</c-><c- p>()</c-></code> is <code class="highlight">true</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"><c- n>layout_left</c-><c- o>::</c-><c- n>mapping</c-></code> operations [mdspan.layout.left.ops]</b></p>
   <p><br></p>
<pre class="language-c++ highlight"><c- n>Extents</c-> <c- nf>extents</c-><c- p>()</c-> <c- k>const</c-> <c- n>noexcept</c-><c- p>;</c->
</pre>
   <ul>
    <li data-md>
     <p><em>Returns:</em> <code class="highlight"><c- n>extents_</c-></code>.</p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><c- kr>typename</c-> <c- n>Extents</c-><c- o>::</c-><c- n>index_type</c-> <c- n>required_span_size</c-><c- p>()</c-> <c- k>const</c-> <c- n>noexcept</c-><c- p>;</c->
</pre>
   <ul>
    <li data-md>
     <p><em>Returns:</em> The product of <code class="highlight"><c- n>extents</c-><c- p>().</c-><c- n>extent</c-><c- p>(</c-><c- n>r</c-><c- p>)</c-></code> for all <code class="highlight"><c- n>r</c-></code> where 0 &lt;= <code class="highlight"><c- n>r</c-></code> &lt; <code class="highlight"><c- n>extents</c-><c- p>().</c-><c- n>rank</c-><c- p>()</c-></code>.</p>
   </ul>
   <p><br></p>
<pre class="highlight"><c- k>template</c-><c- o>&lt;</c-><c- n>class</c-><c- p>...</c-> <c- n>Indices</c-><c- o>></c->
  <c- k>typename</c-> <c- n>Extents</c-><c- o>::</c-><c- n>index_type</c-> <c- k>operator</c-><c- p>()(</c-><c- n>Indices</c-><c- p>...</c-> <c- n>i</c-><c- p>)</c-> <c- k>const</c-><c- p>;</c->
</pre>
   <ul>
    <li data-md>
     <p><em>Constraints:</em></p>
     <ul>
      <li data-md>
       <p><code class="highlight"><c- k>sizeof</c-><c- p>...(</c-><c- n>Indices</c-><c- p>)</c-><c- o>==</c-><c- n>extents</c-><c- p>().</c-><c- n>rank</c-><c- p>()</c-></code> is <code class="highlight">true</code>, and</p>
      <li data-md>
       <p><code class="highlight"><c- n>is_convertible_v</c-><c- o>&lt;</c-><c- n>Indices</c-><c- p>,</c-> <c- k>typename</c-> <c- n>Extents</c-><c- o>::</c-><c- n>index_type</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- p>...</c-></code> is <code class="highlight">true</code>.</p>
     </ul>
    <li data-md>
     <p><em>Requires:</em> 0 &lt;= <code class="highlight"><c- n>array</c-><c- p>{</c-><c- n>i</c-><c- p>...}[</c-><c- n>r</c-><c- p>]</c-></code> &lt; <code class="highlight"><c- n>extents</c-><c- p>().</c-><c- n>extent</c-><c- p>(</c-><c- n>r</c-><c- p>)</c-></code> for all <code class="highlight"><c- n>r</c-></code> in the range <code class="highlight"><c- p>[</c-><c- mi>0</c-><c- p>,</c-> <c- n>extents</c-><c- p>().</c-><c- n>rank</c-><c- p>())</c-></code>.</p>
    <li data-md>
     <p>
      <em>Returns:</em> Let 
      <math>i</math>
      <sub>k</sub> denote the k-th member of <code class="highlight"><c- n>i</c-><c- p>...</c-></code>, and let R equal <code class="highlight"><c- n>extents</c-><c- p>().</c-><c- n>rank</c-><c- p>()</c-></code>:
     </p>
     <ul>
      <li data-md>
       <p>If R is zero, then zero;</p>
      <li data-md>
       <p>
        Otherwise, the sum of 
        <math>i</math>
        <sub><code class="highlight"><c- n>k</c-></code></sub> ⨯ <code class="highlight"><c- n>stride</c-><c- p>(</c-><c- n>k</c-><c- p>)</c-></code> for 0 &lt;= <code class="highlight"><c- n>k</c-></code> &lt; R.
       </p>
     </ul>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><c- k>static</c-> <c- n>constexpr</c-> <c- b>bool</c-> <c- nf>is_always_unique</c-><c- p>();</c->
<c- k>static</c-> <c- n>constexpr</c-> <c- b>bool</c-> <c- nf>is_always_contiguous</c-><c- p>();</c->
<c- k>static</c-> <c- n>constexpr</c-> <c- b>bool</c-> <c- nf>is_always_strided</c-><c- p>();</c->
<c- n>constexpr</c-> <c- b>bool</c-> <c- nf>is_unique</c-><c- p>()</c-> <c- k>const</c-><c- p>;</c->
<c- n>constexpr</c-> <c- b>bool</c-> <c- nf>is_contiguous</c-><c- p>()</c-> <c- k>const</c-><c- p>;</c->
<c- n>constexpr</c-> <c- b>bool</c-> <c- nf>is_strided</c-><c- p>()</c-> <c- k>const</c-><c- p>;</c->
</pre>
   <ul>
    <li data-md>
     <p><em>Returns:</em> <code class="highlight">true</code>.</p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><c- kr>typename</c-> <c- n>Extents</c-><c- o>::</c-><c- n>index_type</c-> <c- n>stride</c-><c- p>(</c-><c- b>size_t</c-> <c- n>r</c-><c- p>)</c-> <c- k>const</c-><c- p>;</c->
</pre>
   <ul>
    <li data-md>
     <p><em>Returns:</em></p>
     <ul>
      <li data-md>
       <p>If <code class="highlight"><c- n>r</c-></code> is zero, then one;</p>
      <li data-md>
       <p>
        Otherwise, the product of <code class="highlight"><c- n>extents</c-><c- p>().</c-><c- n>extent</c-><c- p>(</c-><c- n>k</c-><c- p>)</c-></code> for 0 &lt;= <code class="highlight"><c- n>k</c-></code> &lt; <code class="highlight"><c- n>r</c-></code>, where 
        <math>i</math>
        <sub><code class="highlight"><c- n>k</c-></code></sub> denotes the <code class="highlight"><c- n>k</c-></code>-th member of <code class="highlight"><c- n>i</c-><c- p>...</c-></code> .
       </p>
     </ul>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><c- n>template</c-><c- o>&lt;</c-><c- n>class</c-> <c- n>OtherExtents</c-><c- o>></c->
  <c- n>constexpr</c-> <c- b>bool</c-> <c- n>operator</c-><c- o>==</c-><c- p>(</c-><c- k>const</c-> <c- n>mapping</c-><c- o>&lt;</c-><c- n>OtherExtents</c-><c- o>>&amp;</c-> <c- n>other</c-><c- p>)</c-> <c- k>const</c-> <c- n>noexcept</c-><c- p>;</c->
</pre>
   <ul>
    <li data-md>
     <p><em>Returns:</em> <code class="highlight"><c- n>extents</c-><c- p>()</c-><c- o>==</c-><c- n>other</c-><c- p>.</c-><c- n>extents</c-><c- p>()</c-></code> is <code class="highlight">true</code>.</p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><c- n>template</c-><c- o>&lt;</c-><c- n>class</c-> <c- n>OtherExtents</c-><c- o>></c->
  <c- n>constexpr</c-> <c- b>bool</c-> <c- n>operator</c-><c- o>!=</c-><c- p>(</c-><c- k>const</c-> <c- n>mapping</c-><c- o>&lt;</c-><c- n>OtherExtents</c-><c- o>>&amp;</c-> <c- n>other</c-><c- p>)</c-> <c- k>const</c-> <c- n>noexcept</c-><c- p>;</c->
</pre>
   <ul>
    <li data-md>
     <p><em>Returns:</em> <code class="highlight"><c- n>extents</c-><c- p>()</c-><c- o>!=</c-><c- n>other</c-><c- p>.</c-><c- n>extents</c-><c- p>()</c-></code> is <code class="highlight">true</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"><c- n>layout_right</c-></code> meets the requirements of layout mapping policy. <em>[Note:</em> Thus, any well-formed specialization of <code class="highlight"><c- n>layout_right</c-><c- o>::</c-><c- k>template</c-> <c- n>mapping</c-></code> meets the requirements of layout mapping. <em>—end note]</em></p>
    <li data-md>
     <p>The layout mapping property <code class="highlight"><c- n>layout_right</c-></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"><c- n>Extents</c-></code> is not a (possibly cv-qualified) specialization of <code class="highlight"><c- n>extents</c-></code>, the program is ill-formed.</p>
   </ol>
<pre class="highlight"><c- k>namespace</c-> <c- n>std</c-> <c- p>{</c->
<c- k>namespace</c-> <c- n>experimental</c-> <c- p>{</c->
<c- k>namespace</c-> <c- n>fundamentals_v3</c-> <c- p>{</c->

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

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

    <c- c1>// [mdspan.layout.right.ops], layout_right::mapping operations</c->
    <c- n>Extents</c-> <c- nf>extents</c-><c- p>()</c-> <c- k>const</c-> <c- k>noexcept</c-><c- p>;</c->

    <c- k>constexpr</c-> <c- k>typename</c-> <c- n>Extents</c-><c- o>::</c-><c- n>index_type</c-> <c- n>required_span_size</c-><c- p>()</c-> <c- k>const</c-> <c- k>noexcept</c-><c- p>;</c->

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

    <c- k>static</c-> <c- k>constexpr</c-> <c- b>bool</c-> <c- nf>is_always_unique</c-><c- p>()</c-> <c- k>noexcept</c-><c- p>;</c->
    <c- k>static</c-> <c- k>constexpr</c-> <c- b>bool</c-> <c- nf>is_always_contiguous</c-><c- p>()</c-> <c- k>noexcept</c-><c- p>;</c->
    <c- k>static</c-> <c- k>constexpr</c-> <c- b>bool</c-> <c- nf>is_always_strided</c-><c- p>()</c-> <c- k>noexcept</c-><c- p>;</c->

    <c- k>constexpr</c-> <c- b>bool</c-> <c- nf>is_unique</c-><c- p>()</c-> <c- k>const</c-> <c- k>noexcept</c-><c- p>;</c->
    <c- k>constexpr</c-> <c- b>bool</c-> <c- nf>is_contiguous</c-><c- p>()</c-> <c- k>const</c-> <c- k>noexcept</c-><c- p>;</c->
    <c- k>constexpr</c-> <c- b>bool</c-> <c- nf>is_strided</c-><c- p>()</c-> <c- k>const</c-> <c- k>noexcept</c-><c- p>;</c->

    <c- k>typename</c-> <c- n>Extents</c-><c- o>::</c-><c- n>index_type</c-> <c- n>stride</c-><c- p>(</c-><c- b>size_t</c-> <c- n>rank</c-><c- p>)</c-> <c- k>const</c-> <c- k>noexcept</c-><c- p>;</c->

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

  <c- k>private</c-><c- o>:</c->
    <c- n>Extents</c-> <c- n>extents_</c-><c- p>;</c-> <c- c1>// </c-><i><c- c1>exposition only</c-></i>
  <c- p>};</c->
<c- p>};</c->
<c- p>}</c->
</pre>
   <p><br></p>
   <p><b>26.7.�.3.1 <code class="highlight"><c- n>layout_right</c-><c- o>::</c-><c- n>mapping</c-></code> constructors [mdspan.layout.right.cons]</b></p>
   <p><br></p>
<pre class="language-c++ highlight"><c- n>constexpr</c-> <c- nf>mapping</c-><c- p>()</c-> <c- n>noexcept</c-><c- p>;</c->
</pre>
   <ul>
    <li data-md>
     <p><em>Effects:</em> Default-initializes <code class="highlight"><c- n>extents_</c-></code>.</p>
    <li data-md>
     <p><em>Ensures:</em> <code class="highlight"><c- n>extents</c-><c- p>()</c-><c- o>==</c-><c- n>Extents</c-><c- p>()</c-></code> is <code class="highlight">true</code>.</p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><c- n>constexpr</c-> <c- nf>mapping</c-><c- p>(</c-><c- k>const</c-> <c- n>mapping</c-><c- o>&amp;</c-> <c- n>other</c-><c- p>)</c-> <c- n>noexcept</c-><c- p>;</c->
</pre>
   <ul>
    <li data-md>
     <p><em>Effects:</em> Initializes <code class="highlight"><c- n>extents_</c-></code> with <code class="highlight"><c- n>other</c-><c- p>.</c-><c- n>extents_</c-></code>.</p>
    <li data-md>
     <p><em>Ensures:</em> <code class="highlight"><c- n>extents</c-><c- p>()</c-><c- o>==</c-><c- n>other</c-><c- p>.</c-><c- n>extents</c-><c- p>()</c-></code> is <code class="highlight">true</code>.</p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><c- n>constexpr</c-> <c- nf>mapping</c-><c- p>(</c-><c- n>mapping</c-><c- o>&amp;&amp;</c-> <c- n>other</c-><c- p>)</c-> <c- n>noexcept</c-><c- p>;</c->
</pre>
   <ul>
    <li data-md>
     <p><em>Effects:</em> Initializes <code class="highlight"><c- n>extents_</c-></code> with <code class="highlight"><c- n>move</c-><c- p>(</c-><c- n>other</c-><c- p>.</c-><c- n>extents_</c-><c- p>)</c-></code>.</p>
    <li data-md>
     <p><em>Ensures:</em> <code class="highlight"><c- n>extents</c-><c- p>()</c-></code> equals the result of <code class="highlight"><c- n>other</c-><c- p>.</c-><c- n>extents</c-><c- p>()</c-></code> before the invocation of the move.</p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><c- n>constexpr</c-> <c- nf>mapping</c-><c- p>(</c-><c- n>Extents</c-> <c- n>e</c-><c- p>)</c-> <c- n>noexcept</c-><c- p>;</c->
</pre>
   <ul>
    <li data-md>
     <p><em>Effects:</em> Initializes <code class="highlight"><c- n>extents_</c-></code> with <code class="highlight"><c- n>e</c-></code>.</p>
    <li data-md>
     <p><em>Ensures:</em> <code class="highlight"><c- n>extents</c-><c- p>()</c-><c- o>==</c-><c- n>e</c-></code> is <code class="highlight">true</code>.</p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><c- n>template</c-><c- o>&lt;</c-><c- n>class</c-> <c- n>OtherExtents</c-><c- o>></c->
  <c- n>constexpr</c-> <c- n>mapping</c-><c- p>(</c-><c- k>const</c-> <c- n>mapping</c-><c- o>&lt;</c-><c- n>OtherExtents</c-><c- o>>&amp;</c-> <c- n>other</c-><c- p>);</c->
</pre>
   <ul>
    <li data-md>
     <p><em>Requires:</em> <code class="highlight"><c- n>other</c-><c- p>.</c-><c- n>extents</c-><c- p>()</c-></code> meets the requirements for use in the initialization of <code class="highlight"><c- n>extents_</c-></code>.</p>
    <li data-md>
     <p><em>Effects:</em> Initializes <code class="highlight"><c- n>extents_</c-></code> with <code class="highlight"><c- n>other</c-><c- p>.</c-><c- n>extents</c-><c- p>()</c-></code>.</p>
    <li data-md>
     <p><em>Ensures:</em> <code class="highlight"><c- n>extents</c-><c- p>()</c-><c- o>==</c-><c- n>other</c-><c- p>.</c-><c- n>extents</c-><c- p>()</c-></code> is <code class="highlight">true</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"><c- n>layout_right</c-><c- o>::</c-><c- n>mapping</c-></code> operations [mdspan.layout.right.ops]</b></p>
   <p><br></p>
<pre class="language-c++ highlight"><c- n>Extents</c-> <c- nf>extents</c-><c- p>()</c-> <c- k>const</c-> <c- n>noexcept</c-><c- p>;</c->
</pre>
   <ul>
    <li data-md>
     <p><em>Returns:</em> <code class="highlight"><c- n>extents_</c-></code>.</p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><c- kr>typename</c-> <c- n>Extents</c-><c- o>::</c-><c- n>index_type</c-> <c- n>required_span_size</c-><c- p>()</c-> <c- k>const</c-> <c- n>noexcept</c-><c- p>;</c->
</pre>
   <ul>
    <li data-md>
     <p><em>Returns:</em> The product of <code class="highlight"><c- n>extents</c-><c- p>().</c-><c- n>extent</c-><c- p>(</c-><c- n>r</c-><c- p>)</c-></code> for all <code class="highlight"><c- n>r</c-></code> where 0 &lt;= <code class="highlight"><c- n>r</c-></code> &lt; <code class="highlight"><c- n>extents</c-><c- p>().</c-><c- n>rank</c-><c- p>()</c-></code>.</p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><c- n>template</c-><c- o>&lt;</c-><c- n>class</c-><c- p>...</c-> <c- n>Indices</c-><c- o>></c->
  <c- kr>typename</c-> <c- n>Extents</c-><c- o>::</c-><c- n>index_type</c-> <c- n>operator</c-><c- p>()(</c-><c- n>Indices</c-><c- p>...</c-> <c- n>i</c-><c- p>)</c-> <c- k>const</c-> <c- n>noexcept</c-><c- p>;</c->
</pre>
   <ul>
    <li data-md>
     <p><em>Constraints:</em></p>
     <ul>
      <li data-md>
       <p><code class="highlight"><c- k>sizeof</c-><c- p>...(</c-><c- n>Indices</c-><c- p>)</c-><c- o>==</c-><c- n>extents</c-><c- p>().</c-><c- n>rank</c-><c- p>()</c-></code> is <code class="highlight">true</code>, and</p>
      <li data-md>
       <p><code class="highlight"><c- n>is_convertible_v</c-><c- o>&lt;</c-><c- n>Indices</c-><c- p>,</c-> <c- k>typename</c-> <c- n>Extents</c-><c- o>::</c-><c- n>index_type</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- p>...</c-></code> is <code class="highlight">true</code>.</p>
     </ul>
    <li data-md>
     <p><em>Requires:</em> 0 &lt;= <code class="highlight"><c- n>array</c-><c- p>{</c-><c- n>i</c-><c- p>...}[</c-><c- n>r</c-><c- p>]</c-></code> &lt; <code class="highlight"><c- n>extents</c-><c- p>().</c-><c- n>extent</c-><c- p>(</c-><c- n>r</c-><c- p>)</c-></code> for all <code class="highlight"><c- n>r</c-></code> in the range <code class="highlight"><c- p>[</c-><c- mi>0</c-><c- p>,</c-> <c- n>extents</c-><c- p>().</c-><c- n>rank</c-><c- p>())</c-></code>.</p>
    <li data-md>
     <p>
      <em>Returns:</em> Let 
      <math>i</math>
      <sub>k</sub> denote the k-th member of <code class="highlight"><c- n>i</c-><c- p>...</c-></code>, and let R equal <code class="highlight"><c- n>extents</c-><c- p>().</c-><c- n>rank</c-><c- p>()</c-></code>:
     </p>
     <ul>
      <li data-md>
       <p>If R is zero, then zero;</p>
      <li data-md>
       <p>
        Otherwise, the sum of 
        <math>i</math>
        <sub><code class="highlight"><c- n>k</c-></code></sub> ⨯ <code class="highlight"><c- n>stride</c-><c- p>(</c-><c- n>k</c-><c- p>)</c-></code> for 0 &lt;= <code class="highlight"><c- n>k</c-></code> &lt; R.
       </p>
     </ul>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><c- k>static</c-> <c- n>constexpr</c-> <c- b>bool</c-> <c- nf>is_always_unique</c-><c- p>()</c-> <c- n>noexcept</c-><c- p>;</c->
<c- k>static</c-> <c- n>constexpr</c-> <c- b>bool</c-> <c- nf>is_always_contiguous</c-><c- p>()</c-> <c- n>noexcept</c-><c- p>;</c->
<c- k>static</c-> <c- n>constexpr</c-> <c- b>bool</c-> <c- nf>is_always_strided</c-><c- p>()</c-> <c- n>noexcept</c-><c- p>;</c->
<c- n>constexpr</c-> <c- b>bool</c-> <c- nf>is_unique</c-><c- p>()</c-> <c- k>const</c-> <c- n>noexcept</c-><c- p>;</c->
<c- n>constexpr</c-> <c- b>bool</c-> <c- nf>is_contiguous</c-><c- p>()</c-> <c- k>const</c-> <c- n>noexcept</c-><c- p>;</c->
<c- n>constexpr</c-> <c- b>bool</c-> <c- nf>is_strided</c-><c- p>()</c-> <c- k>const</c-> <c- n>noexcept</c-><c- p>;</c->
</pre>
   <ul>
    <li data-md>
     <p><em>Returns:</em> <code class="highlight">true</code>.</p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><c- kr>typename</c-> <c- n>Extents</c-><c- o>::</c-><c- n>index_type</c-> <c- n>stride</c-><c- p>(</c-><c- b>size_t</c-> <c- n>r</c-><c- p>)</c-> <c- k>const</c-> <c- n>noexcept</c-><c- p>;</c->
</pre>
   <ul>
    <li data-md>
     <p><em>Returns:</em> Equivalent to <code class="highlight"><c- n>s</c-></code> in the following:</p>
<pre class="highlight"><c- n>Extents</c-><c- o>::</c-><c- n>index_type</c-> <c- n>s</c-> <c- o>=</c-> <c- mi>1</c-><c- p>;</c->
<c- k>for</c-><c- p>(</c-><c- b>size_t</c-> <c- n>k</c-><c- o>=</c-><c- n>r</c-><c- o>+</c-><c- mi>1</c-><c- p>;</c-> <c- n>k</c-><c- o>&lt;</c-><c- n>extents</c-><c- p>().</c-><c- n>rank</c-><c- p>();</c-> <c- o>++</c-><c- n>k</c-><c- p>)</c->
  <c- n>s</c-> <c- o>*=</c-> <c- n>extents</c-><c- p>().</c-><c- n>extent</c-><c- p>(</c-><c- n>r</c-><c- p>);</c->
</pre>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><c- n>template</c-><c- o>&lt;</c-><c- n>class</c-> <c- n>OtherExtents</c-><c- o>></c->
  <c- n>constexpr</c-> <c- b>bool</c-> <c- n>operator</c-><c- o>==</c-><c- p>(</c-><c- k>const</c-> <c- n>mapping</c-><c- o>&lt;</c-><c- n>OtherExtents</c-><c- o>>&amp;</c-> <c- n>other</c-><c- p>)</c-> <c- k>const</c-> <c- n>noexcept</c-><c- p>;</c->
</pre>
   <ul>
    <li data-md>
     <p><em>Returns:</em> <code class="highlight"><c- n>extents</c-><c- p>()</c-><c- o>==</c-><c- n>other</c-><c- p>.</c-><c- n>extents</c-><c- p>()</c-></code> is <code class="highlight">true</code>.</p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><c- n>template</c-><c- o>&lt;</c-><c- n>class</c-> <c- n>OtherExtents</c-><c- o>></c->
  <c- n>constexpr</c-> <c- b>bool</c-> <c- n>operator</c-><c- o>!=</c-><c- p>(</c-><c- k>const</c-> <c- n>mapping</c-><c- o>&lt;</c-><c- n>OtherExtents</c-><c- o>>&amp;</c-> <c- n>other</c-><c- p>)</c-> <c- k>const</c-> <c- n>noexcept</c-><c- p>;</c->
</pre>
   <ul>
    <li data-md>
     <p><em>Returns:</em> <code class="highlight"><c- n>extents</c-><c- p>()</c-><c- o>!=</c-><c- n>other</c-><c- p>.</c-><c- n>extents</c-><c- p>()</c-></code> is <code class="highlight">true</code>.</p>
   </ul>
   <p><br> <br> <b>26.7.�.4 Class <code class="highlight"><c- n>layout_stride</c-></code> [mdspan.layout.stride]</b></p>
   <ol>
    <li data-md>
     <p><code class="highlight"><c- n>layout_stride</c-></code> meets the requirements of layout mapping policy.</p>
    <li data-md>
     <p>The layout mapping property <code class="highlight"><c- n>layout_stride</c-></code> gives a layout mapping where the strides are user defined.</p>
    <li data-md>
     <p>If <code class="highlight"><c- n>Extents</c-></code> is not a (possibly cv-qualified) specialization of <code class="highlight"><c- n>extents</c-></code>, the program is ill-formed.</p>
   </ol>
   <p><br></p>
<pre class="highlight"><c- k>namespace</c-> <c- n>std</c-> <c- p>{</c->
<c- k>namespace</c-> <c- n>experimental</c-> <c- p>{</c->
<c- k>namespace</c-> <c- n>fundamentals_v3</c-> <c- p>{</c->

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

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

    <c- c1>// [mdspan.layout.stride.ops], layout_stride::mapping operations</c->
    <c- n>Extents</c-> <c- nf>extents</c-><c- p>()</c-> <c- k>const</c-> <c- k>noexcept</c-><c- p>;</c->
    <c- n>array</c-><c- o>&lt;</c-><c- k>typename</c-> <c- n>Extents</c-><c- o>::</c-><c- n>index_type</c-><c- p>,</c-> <c- n>Extents</c-><c- o>::</c-><c- n>rank</c-><c- p>()</c-><c- o>></c-> <c- n>strides</c-><c- p>()</c-> <c- k>const</c-> <c- k>noexcept</c-><c- p>;</c->

    <c- k>constexpr</c-> <c- k>typename</c-> <c- n>Extents</c-><c- o>::</c-><c- n>index_type</c-> <c- n>required_span_size</c-><c- p>()</c-> <c- k>const</c-> <c- k>noexcept</c-><c- p>;</c->

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

    <c- k>static</c-> <c- k>constexpr</c-> <c- b>bool</c-> <c- nf>is_always_unique</c-><c- p>()</c-> <c- k>noexcept</c-><c- p>;</c->
    <c- k>static</c-> <c- k>constexpr</c-> <c- b>bool</c-> <c- nf>is_always_contiguous</c-><c- p>()</c-> <c- k>noexcept</c-><c- p>;</c->
    <c- k>static</c-> <c- k>constexpr</c-> <c- b>bool</c-> <c- nf>is_always_strided</c-><c- p>()</c-> <c- k>noexcept</c-><c- p>;</c->

    <c- k>constexpr</c-> <c- b>bool</c-> <c- nf>is_unique</c-><c- p>()</c-> <c- k>const</c-> <c- k>noexcept</c-><c- p>;</c->
    <c- k>constexpr</c-> <c- b>bool</c-> <c- nf>is_contiguous</c-><c- p>()</c-> <c- k>const</c-> <c- k>noexcept</c-><c- p>;</c->
    <c- k>constexpr</c-> <c- b>bool</c-> <c- nf>is_strided</c-><c- p>()</c-> <c- k>const</c-> <c- k>noexcept</c-><c- p>;</c->

    <c- k>typename</c-> <c- n>Extents</c-><c- o>::</c-><c- n>index_type</c-> <c- n>stride</c-><c- p>(</c-><c- b>size_t</c-> <c- n>rank</c-><c- p>)</c-> <c- k>const</c-> <c- k>noexcept</c-><c- p>;</c->

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

  <c- k>private</c-><c- o>:</c->
    <c- n>Extents</c-> <c- n>extents_</c-><c- p>;</c-> <c- c1>// </c-><i><c- c1>exposition only</c-></i>
    <c- n>array</c-><c- o>&lt;</c-><c- k>typename</c-> <c- n>Extents</c-><c- o>::</c-><c- n>index_type</c-><c- p>,</c-> <c- n>Extents</c-><c- o>::</c-><c- n>rank</c-><c- p>()</c-><c- o>></c-> <c- n>strides_</c-><c- p>;</c-> <c- c1>// </c-><i><c- c1>exposition only</c-></i>
  <c- p>};</c->
<c- p>};</c->
<c- p>}}}</c->
</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"><c- n>constexpr</c-> <c- nf>mapping</c-><c- p>()</c-> <c- n>noexcept</c-><c- p>;</c->
</pre>
   <ul>
    <li data-md>
     <p><em>Effects:</em> Default-initializes <code class="highlight"><c- n>extents_</c-></code>.</p>
    <li data-md>
     <p><em>Ensures:</em></p>
     <ul>
      <li data-md>
       <p><code class="highlight"><c- n>extents</c-><c- p>()</c-><c- o>==</c-><c- n>Extents</c-><c- p>()</c-></code> is <code class="highlight">true</code>, and</p>
      <li data-md>
       <p><code class="highlight"><c- n>strides</c-><c- p>()</c-><c- o>==</c-><c- n>array</c-><c- o>&lt;</c-><c- k>typename</c-> <c- n>Extents</c-><c- o>::</c-><c- n>index_type</c-><c- p>,</c-> <c- n>Extents</c-><c- o>::</c-><c- n>rank</c-><c- p>()</c-><c- o>></c-><c- p>()</c-></code> is <code class="highlight">true</code>.</p>
     </ul>
   </ul>
<pre class="language-c++ highlight"><c- n>constexpr</c-> <c- nf>mapping</c-><c- p>(</c-><c- k>const</c-> <c- n>mapping</c-><c- o>&amp;</c-> <c- n>other</c-><c- p>)</c-> <c- n>noexcept</c-><c- p>;</c->
</pre>
   <ul>
    <li data-md>
     <p><em>Effects:</em> Initializes <code class="highlight"><c- n>extents_</c-></code> with <code class="highlight"><c- n>other</c-><c- p>.</c-><c- n>extents_</c-></code>.</p>
    <li data-md>
     <p><em>Ensures:</em></p>
     <ul>
      <li data-md>
       <p><code class="highlight"><c- n>extents</c-><c- p>()</c-><c- o>==</c-><c- n>other</c-><c- p>.</c-><c- n>extents</c-><c- p>()</c-></code> is <code class="highlight">true</code>, and</p>
      <li data-md>
       <p><code class="highlight"><c- n>strides</c-><c- p>()</c-><c- o>==</c-><c- n>other</c-><c- p>.</c-><c- n>strides</c-><c- p>()</c-></code> is <code class="highlight">true</code>.</p>
     </ul>
   </ul>
<pre class="language-c++ highlight"><c- n>constexpr</c-> <c- nf>mapping</c-><c- p>(</c-><c- n>mapping</c-><c- o>&amp;&amp;</c-> <c- n>other</c-><c- p>)</c-> <c- n>noexcept</c-><c- p>;</c->
</pre>
   <ul>
    <li data-md>
     <p><em>Effects:</em> Initializes <code class="highlight"><c- n>extents_</c-></code> with <code class="highlight"><c- n>move</c-><c- p>(</c-><c- n>other</c-><c- p>.</c-><c- n>extents_</c-><c- p>)</c-></code>.</p>
    <li data-md>
     <p><em>Ensures:</em></p>
     <ul>
      <li data-md>
       <p><code class="highlight"><c- n>extents</c-><c- p>()</c-></code> equals the result of <code class="highlight"><c- n>other</c-><c- p>.</c-><c- n>extents</c-><c- p>()</c-></code> before the invocation of the move, and</p>
      <li data-md>
       <p><code class="highlight"><c- n>strides</c-><c- p>()</c-></code> equals the result of <code class="highlight"><c- n>other</c-><c- p>.</c-><c- n>strides</c-><c- p>()</c-></code> before the invocation of the move.</p>
     </ul>
   </ul>
<pre class="language-c++ highlight"><c- n>constexpr</c-> <c- nf>mapping</c-><c- p>(</c-><c- n>Extents</c-> <c- n>e</c-><c- p>,</c-> <c- n>array</c-><c- o>&lt;</c-><c- kr>typename</c-> <c- n>Extents</c-><c- o>::</c-><c- n>index_type</c-><c- p>,</c-> <c- n>Extents</c-><c- o>::</c-><c- n>rank</c-><c- p>()</c-><c- o>></c-> <c- n>s</c-><c- p>)</c-> <c- n>noexcept</c-><c- p>;</c->
</pre>
   Let R equal <code class="highlight"><c- n>Extents</c-><c- o>::</c-><c- n>rank</c-><c- p>()</c-></code>.
If 
   <math>p</math>
    is a permutation of the integers 0, ..., R-1,
then let <code class="highlight"><c- n>p</c-></code> be an exposition-only array of <code class="highlight"><c- b>size_t</c-></code> of length R
such that <code class="highlight"><c- n>p</c-><c- p>[</c-><c- n>i</c-><c- p>]</c-></code> equals 
   <math>p</math>
   <sub><code class="highlight"><c- n>i</c-></code></sub> for 0 &lt;= <code class="highlight"><c- n>i</c-></code> &lt; R. 
   <ul>
    <li data-md>
     <p><em>Requires:</em></p>
     <ul>
      <li data-md>
       <p><code class="highlight"><c- n>s</c-><c- p>[</c-><c- n>i</c-><c- p>]</c-> <c- o>></c-> <c- mi>0</c-></code> is <code class="highlight">true</code> for 0 &lt; <code class="highlight"><c- n>i</c-></code> &lt;= R.</p>
      <li data-md>
       <p>
        If R is nonzero, then
  there exists a permutation 
        <math>p</math>
         of the integers 0, ..., R-1 such that <code class="highlight"><c- n>s</c-><c- p>(</c-><c- n>p</c-><c- p>[</c-><c- n>i</c-><c- p>])</c-> <c- o>>=</c-> <c- n>s</c-><c- p>(</c-><c- n>p</c-><c- p>[</c-><c- n>i</c-><c- o>-</c-><c- mi>1</c-><c- p>])</c-><c- o>*</c-><c- n>e</c-><c- p>.</c-><c- n>extent</c-><c- p>(</c-><c- n>p</c-><c- p>[</c-><c- n>i</c-><c- o>-</c-><c- mi>1</c-><c- p>])</c-></code> is <code class="highlight">true</code> for 1 &lt;= <code class="highlight"><c- n>i</c-></code> &lt; R.
       </p>
     </ul>
    <li data-md>
     <p><em>Effects:</em></p>
     <ul>
      <li data-md>
       <p>Initializes <code class="highlight"><c- n>extents_</c-></code> with <code class="highlight"><c- n>e</c-></code>, and</p>
      <li data-md>
       <p>initializes <code class="highlight"><c- n>strides_</c-></code> with <code class="highlight"><c- n>s</c-></code>.</p>
     </ul>
    <li data-md>
     <p><em>Ensures:</em></p>
     <ul>
      <li data-md>
       <p><code class="highlight"><c- n>extents</c-><c- p>()</c-><c- o>==</c-><c- n>e</c-></code> is <code class="highlight">true</code>, and</p>
      <li data-md>
       <p><code class="highlight"><c- n>strides</c-><c- p>()</c-><c- o>==</c-><c- n>s</c-></code> is <code class="highlight">true</code>.</p>
     </ul>
    <li data-md>
     <p><em>Throws:</em> Nothing.</p>
   </ul>
<pre class="language-c++ highlight"><c- n>template</c-><c- o>&lt;</c-><c- n>class</c-> <c- n>OtherExtents</c-><c- o>></c->
  <c- n>constexpr</c-> <c- n>mapping</c-><c- p>(</c-><c- k>const</c-> <c- n>mapping</c-><c- o>&lt;</c-><c- n>OtherExtents</c-><c- o>>&amp;</c-> <c- n>other</c-><c- p>);</c->
</pre>
   <ul>
    <li data-md>
     <p><em>Requires:</em> <code class="highlight"><c- n>other</c-><c- p>.</c-><c- n>extents</c-><c- p>()</c-></code> meets the requirements for use in the initialization of <code class="highlight"><c- n>extents_</c-></code>.</p>
    <li data-md>
     <p><em>Effects:</em></p>
     <ul>
      <li data-md>
       <p>Initializes <code class="highlight"><c- n>extents_</c-></code> with <code class="highlight"><c- n>other</c-><c- p>.</c-><c- n>extents</c-><c- p>()</c-></code>, and</p>
      <li data-md>
       <p>initializes <code class="highlight"><c- n>strides_</c-></code> with <code class="highlight"><c- n>other</c-><c- p>.</c-><c- n>strides</c-><c- p>()</c-></code>.</p>
     </ul>
    <li data-md>
     <p><em>Ensures:</em></p>
     <ul>
      <li data-md>
       <p><code class="highlight"><c- n>extents</c-><c- p>()</c-><c- o>==</c-><c- n>other</c-><c- p>.</c-><c- n>extents</c-><c- p>()</c-></code> is <code class="highlight">true</code>, and</p>
      <li data-md>
       <p><code class="highlight"><c- n>strides</c-><c- p>()</c-><c- o>==</c-><c- n>other</c-><c- p>.</c-><c- n>strides</c-><c- p>()</c-></code> is <code class="highlight">true</code>.</p>
     </ul>
    <li data-md>
     <p><em>Throws:</em> Nothing.</p>
   </ul>
   <p><b>26.7.�.4.2 layout_stride::mapping operations [mdspan.layout.stride.ops]</b></p>
<pre class="language-c++ highlight"><c- n>Extents</c-> <c- nf>extents</c-><c- p>()</c-> <c- k>const</c-> <c- n>noexcept</c-><c- p>;</c->
</pre>
   <ul>
    <li data-md>
     <p><em>Returns:</em> <code class="highlight"><c- n>extents_</c-></code>.</p>
   </ul>
<pre class="language-c++ highlight"><c- n>array</c-><c- o>&lt;</c-><c- kr>typename</c-> <c- n>Extents</c-><c- o>::</c-><c- n>index_type</c-><c- p>,</c-> <c- n>Extents</c-><c- o>::</c-><c- n>rank</c-><c- p>()</c-><c- o>></c-> <c- n>strides</c-><c- p>()</c-> <c- k>const</c-> <c- n>noexcept</c-><c- p>;</c->
</pre>
   <ul>
    <li data-md>
     <p><em>Returns:</em> <code class="highlight"><c- n>strides_</c-></code>.</p>
   </ul>
<pre class="language-c++ highlight"><c- kr>typename</c-> <c- n>Extents</c-><c- o>::</c-><c- n>index_type</c-> <c- n>required_span_size</c-><c- p>()</c-> <c- k>const</c-> <c- n>noexcept</c-><c- p>;</c->
</pre>
   <ul>
    <li data-md>
     <p><em>Returns:</em> The maximum of <code class="highlight"><c- n>extents</c-><c- p>().</c-><c- n>extent</c-><c- p>(</c-><c- n>r</c-><c- p>)</c-><c- o>*</c-><c- n>stride</c-><c- p>(</c-><c- n>r</c-><c- p>)</c-></code> for all <code class="highlight"><c- n>r</c-></code> where 0 &lt;= <code class="highlight"><c- n>r</c-></code> &lt; <code class="highlight"><c- n>extents</c-><c- p>().</c-><c- n>rank</c-><c- p>()</c-></code>.</p>
   </ul>
<pre class="language-c++ highlight"><c- n>template</c-> <c- o>&lt;</c-><c- n>class</c-><c- p>...</c-> <c- n>Indices</c-><c- o>></c->
  <c- kr>typename</c-> <c- n>Extents</c-><c- o>::</c-><c- n>index_type</c-> <c- n>operator</c-><c- p>()(</c-><c- n>Indices</c-><c- p>...</c-> <c- n>i</c-><c- p>)</c-> <c- k>const</c-><c- p>;</c->
</pre>
   <ul>
    <li data-md>
     <p><em>Constraints:</em></p>
     <ul>
      <li data-md>
       <p><code class="highlight"><c- k>sizeof</c-><c- p>...(</c-><c- n>Indices</c-><c- p>)</c-><c- o>==</c-><c- n>Extents</c-><c- o>::</c-><c- n>rank</c-><c- p>()</c-></code> is <code class="highlight">true</code>, and</p>
      <li data-md>
       <p><code class="highlight"><c- n>is_convertible_v</c-><c- o>&lt;</c-><c- n>Indices</c-><c- p>,</c-> <c- k>typename</c-> <c- n>Extents</c-><c- o>::</c-><c- n>index_type</c-><c- o>></c-> <c- o>&amp;&amp;</c-> <c- p>...</c-></code> is <code class="highlight">true</code>.</p>
     </ul>
    <li data-md>
     <p><em>Requires:</em> 0 &lt;= <code class="highlight"><c- n>array</c-><c- p>{</c-><c- n>i</c-><c- p>...}[</c-><c- n>r</c-><c- p>]</c-></code> &lt; <code class="highlight"><c- n>extents</c-><c- p>().</c-><c- n>extent</c-><c- p>(</c-><c- n>r</c-><c- p>)</c-></code> for all <code class="highlight"><c- n>r</c-></code> in the range <code class="highlight"><c- p>[</c-><c- mi>0</c-><c- p>,</c-> <c- n>extents</c-><c- p>().</c-><c- n>rank</c-><c- p>())</c-></code>.</p>
    <li data-md>
     <p>
      <em>Returns:</em> Let 
      <math>i</math>
      <sub>k</sub> denote the k-th member of <code class="highlight"><c- n>i</c-><c- p>...</c-></code>, let R equal <code class="highlight"><c- n>Extents</c-><c- o>::</c-><c- n>rank</c-><c- p>()</c-></code>, and let <code class="highlight"><c- n>s</c-></code> be <code class="highlight"><c- n>strides</c-><c- p>()</c-></code>:
     </p>
     <ul>
      <li data-md>
       <p>If R is zero, then zero;</p>
      <li data-md>
       <p>
        Otherwise, the sum of 
        <math>i</math>
        <sub><code class="highlight"><c- n>k</c-></code></sub> ⨯ <code class="highlight"><c- n>s</c-><c- p>[</c-><c- n>k</c-><c- p>]</c-></code> for 0 &lt;= <code class="highlight"><c- n>k</c-></code> &lt; R.
       </p>
     </ul>
    <li data-md>
     <p><em>Throws:</em> Nothing.</p>
   </ul>
<pre class="language-c++ highlight"><c- k>static</c-> <c- n>constexpr</c-> <c- b>bool</c-> <c- nf>is_always_unique</c-><c- p>()</c-> <c- n>noexcept</c-><c- p>;</c->
<c- k>static</c-> <c- n>constexpr</c-> <c- b>bool</c-> <c- nf>is_always_strided</c-><c- p>()</c-> <c- n>noexcept</c-><c- p>;</c->
<c- n>constexpr</c-> <c- b>bool</c-> <c- nf>is_unique</c-><c- p>()</c-> <c- k>const</c-> <c- n>noexcept</c-><c- p>;</c->
<c- n>constexpr</c-> <c- b>bool</c-> <c- nf>is_strided</c-><c- p>()</c-> <c- k>const</c-> <c- n>noexcept</c-><c- p>;</c->
</pre>
   <ul>
    <li data-md>
     <p><em>Returns:</em> <code class="highlight">true</code>.</p>
   </ul>
<pre class="language-c++ highlight"><c- k>static</c-> <c- n>constexpr</c-> <c- b>bool</c-> <c- nf>is_always_contiguous</c-><c- p>()</c-> <c- n>noexcept</c-><c- p>;</c->
</pre>
   <ul>
    <li data-md>
     <p><em>Returns:</em> <code class="highlight">false</code>.</p>
   </ul>
<pre class="language-c++ highlight"><c- n>constexpr</c-> <c- b>bool</c-> <c- nf>is_contiguous</c-><c- p>()</c-> <c- k>const</c-> <c- n>noexcept</c-><c- p>;</c->
</pre>
   Let R equal <code class="highlight"><c- n>Extents</c-><c- o>::</c-><c- n>rank</c-><c- p>()</c-></code>.
If 
   <math>p</math>
    is a permutation of the integers 0, ..., R-1,
then let <code class="highlight"><c- n>p</c-></code> be an exposition-only array of <code class="highlight"><c- b>size_t</c-></code> of length R
such that <code class="highlight"><c- n>p</c-><c- p>[</c-><c- n>i</c-><c- p>]</c-></code> equals 
   <math>p</math>
   <sub><code class="highlight"><c- n>i</c-></code></sub> for 0 &lt;= <code class="highlight"><c- n>i</c-></code> &lt; R. 
   <ul>
    <li data-md>
     <p><em>Returns:</em></p>
     <ul>
      <li data-md>
       <p>If <code class="highlight"><c- n>R</c-></code> is zero, then <code class="highlight">true</code>;</p>
      <li data-md>
       <p>
        Else, if there is a permutation 
        <math>p</math>
         of the integers 0, ..., R-1 such that <code class="highlight"><c- n>min</c-><c- p>(</c-><c- n>stride</c-><c- p>(</c-><c- n>p</c-><c- p>[</c-><c- n>i</c-><c- p>])</c-></code> equals 1 for 0 &lt;= <code class="highlight"><c- n>i</c-></code> &lt; R, and <code class="highlight"><c- n>stride</c-><c- p>(</c-><c- n>p</c-><c- p>[</c-><c- n>i</c-><c- p>])</c-></code> equals <code class="highlight"><c- n>stride</c-><c- p>(</c-><c- n>p</c-><c- p>[</c-><c- n>i</c-><c- o>-</c-><c- mi>1</c-><c- p>])</c-><c- o>*</c-><c- n>extents</c-><c- p>().</c-><c- n>extent</c-><c- p>(</c-><c- n>p</c-><c- p>[</c-><c- n>i</c-><c- o>-</c-><c- mi>1</c-><c- p>])</c-></code> for 1 &lt;= <code class="highlight"><c- n>i</c-></code> &lt; R, then <code class="highlight">true</code>;
       </p>
      <li data-md>
       <p>Otherwise, <code class="highlight">false</code>.</p>
     </ul>
   </ul>
<pre class="language-c++ highlight"><c- kr>typename</c-> <c- n>Extents</c-><c- o>::</c-><c- n>index_type</c-> <c- n>stride</c-><c- p>(</c-><c- b>size_t</c-> <c- n>r</c-><c- p>)</c-> <c- k>const</c-> <c- n>noexcept</c-><c- p>;</c->
</pre>
   <ul>
    <li data-md>
     <p><em>Returns:</em> <code class="highlight"><c- n>strides_</c-><c- p>[</c-><c- n>r</c-><c- p>]</c-></code>.</p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><c- n>template</c-><c- o>&lt;</c-><c- n>class</c-> <c- n>OtherExtents</c-><c- o>></c->
  <c- n>constexpr</c-> <c- b>bool</c-> <c- n>operator</c-><c- o>==</c-><c- p>(</c-><c- k>const</c-> <c- n>mapping</c-><c- o>&lt;</c-><c- n>OtherExtents</c-><c- o>>&amp;</c-> <c- n>other</c-><c- p>)</c-> <c- k>const</c-> <c- n>noexcept</c-><c- p>;</c->
</pre>
   <ul>
    <li data-md>
     <p><em>Returns:</em> <code class="highlight"><c- n>extents</c-><c- p>()</c-><c- o>==</c-><c- n>other</c-><c- p>.</c-><c- n>extents</c-><c- p>()</c-></code>.</p>
   </ul>
   <p><br></p>
<pre class="language-c++ highlight"><c- n>template</c-><c- o>&lt;</c-><c- n>class</c-> <c- n>OtherExtents</c-><c- o>></c->
  <c- n>constexpr</c-> <c- b>bool</c-> <c- n>operator</c-><c- o>!=</c-><c- p>(</c-><c- k>const</c-> <c- n>mapping</c-><c- o>&lt;</c-><c- n>OtherExtents</c-><c- o>>&amp;</c-> <c- n>other</c-><c- p>)</c-> <c- k>const</c-> <c- n>noexcept</c-><c- p>;</c->
</pre>
   <ul>
    <li data-md>
     <p><em>Returns:</em> <code class="highlight"><c- n>extents</c-><c- p>()</c-><c- o>!=</c-><c- n>other</c-><c- p>.</c-><c- n>extents</c-><c- p>()</c-></code>.</p>
   </ul>
   <p><br> <br></p>
   <p><b>26.7.� Accessor Policy [mdspan.accessor]</b></p>
   <p>An <em>accessor policy</em> defines types and operations by which
a contiguous set of objects of a particular type are accessed.</p>
   <p><br> <b>26.7.�.1 Accessor policy requirements [mdspan.accessor.reqs]</b></p>
   <p>An accessor policy defines:</p>
   <ul>
    <li data-md>
     <p>a handle to a single element of type <code class="highlight"><c- n>element_type</c-></code>;</p>
    <li data-md>
     <p>a handle to a contiguous set of elements of type <code class="highlight"><c- n>element_type</c-></code>,
  accessible through the policy’s <code class="highlight"><c- n>access</c-></code> function;</p>
    <li data-md>
     <p>conversion of a handle to a contiguous set of elements,
  to a pointer <strong>[conv.array]</strong>; and</p>
    <li data-md>
     <p>getting a handle to the contiguous subset of elements
  beginning at an integer offset value.</p>
   </ul>
   <p><em>[Note:</em> The type of <code class="highlight"><c- n>reference</c-></code> need not be <code class="highlight"><c- n>element_type</c-><c- o>&amp;</c-></code>.
  The type of <code class="highlight"><c- n>pointer</c-></code> need not be <code class="highlight"><c- n>element_type</c-><c- o>*</c-></code>. <em>— end note]</em></p>
   <p><em>[Note:</em> The constructor of the object representing the contiguous set of objects
may impose additional restrictions on the contiguous set of objects, 
such as restricting <code class="highlight"><c- n>element_type</c-></code> to be trivially copyable or 
requiring a larger alignment than <code class="highlight"><c- n>alignment_of_v</c-><c- o>&lt;</c-><c- n>element_type</c-><c- o>></c-></code>. <em>— end note]</em></p>
   <p>In Table �:</p>
   <ul>
    <li data-md>
     <p><code class="highlight"><c- n>A</c-></code> denotes an accessor policy.</p>
    <li data-md>
     <p><code class="highlight"><c- n>a</c-></code> denotes an object of type <code class="highlight"><c- n>A</c-></code>.</p>
    <li data-md>
     <p><code class="highlight"><c- n>p</c-></code> denotes an object of type <code class="highlight"><c- n>A</c-><c- o>::</c-><c- n>pointer</c-></code>.</p>
    <li data-md>
     <p><code class="highlight"><c- n>i</c-></code> and <code class="highlight"><c- n>j</c-></code> each denote a <code class="highlight"><c- b>ptrdiff_t</c-></code> value.</p>
   </ul>
   <p>Table �: Accessor policy requirements</p>
   <table border="1">
    <tbody>
     <tr>
      <th>Expression
      <th>Return Type
      <th>Notes/Returns/Requires
     <tr>
      <td><code class="highlight"><c- n>A</c-><c- o>::</c-><c- n>element_type</c-></code>
      <td>
      <td>Type of each element in the contiguous set of elements.
     <tr>
      <td><code class="highlight"><c- n>A</c-><c- o>::</c-><c- n>pointer</c-></code>
      <td>
      <td>Type through which the range of elements are accessed. <br><em>Requires:</em> <em>Cpp17DefaultConstructible</em>, <em>Cpp17CopyConstructible</em>, and <em>Cpp17CopyAssignable</em>. 
     <tr>
      <td><code class="highlight"><c- n>A</c-><c- o>::</c-><c- n>reference</c-></code>
      <td>
      <td>Type through which an element is accessed. 
     <tr>
      <td><code class="highlight"><c- n>A</c-><c- o>::</c-><c- n>offset_policy</c-></code>
      <td>
      <td>
       Accessor policy for accessing a pointer returned by <code class="highlight"><c- n>a</c-><c- p>.</c-><c- n>offset</c-><c- p>(</c-><c- n>p</c-><c- p>,</c-><c- n>i</c-><c- p>)</c-></code>. <br> <em>Requires:</em> 
       <ul>
        <li data-md>
         <p><code class="highlight"><c- n>A</c-><c- o>::</c-><c- n>offset_policy</c-></code> meets the requirements of an accessor policy in Table �.</p>
        <li data-md>
         <p><code class="highlight"><c- n>is_convertible_v</c-><c- o>&lt;</c-><c- n>A</c-><c- p>,</c-> <c- n>A</c-><c- o>::</c-><c- n>offset_policy</c-><c- o>></c-></code> is <code class="highlight">true</code> and <code class="highlight"><c- n>A</c-><c- o>::</c-><c- n>offset_policy</c-><c- p>(</c-><c- n>a</c-><c- p>)</c-></code> is valid.</p>
       </ul>
     <tr>
      <td><code class="highlight"><c- n>a</c-><c- p>.</c-><c- n>decay</c-><c- p>(</c-><c- n>p</c-><c- p>)</c-></code>
      <td><code class="highlight"><c- n>A</c-><c- o>::</c-><c- n>element_type</c-><c- o>*</c-></code>
      <td><em>Returns:</em> A pointer that references the same location as <code class="highlight"><c- n>p</c-></code>.
     <tr>
      <td><code class="highlight"><c- n>a</c-><c- p>.</c-><c- n>access</c-><c- p>(</c-><c- n>p</c-><c- p>,</c-><c- n>i</c-><c- p>)</c-></code>
      <td><code class="highlight"><c- n>A</c-><c- o>::</c-><c- n>reference</c-></code>
      <td><em>Returns:</em> An object which provides access to the <code class="highlight"><c- n>i</c-></code>-th element in the range of elements that starts at <code class="highlight"><c- n>p</c-></code>.
     <tr>
      <td><code class="highlight"><c- n>a</c-><c- p>.</c-><c- n>offset</c-><c- p>(</c-><c- n>p</c-><c- p>,</c-><c- n>i</c-><c- p>)</c-></code>
      <td><code class="highlight"><c- n>A</c-><c- o>::</c-><c- n>offset_policy</c-><c- o>::</c-><c- n>pointer</c-></code>
      <td>
       <p><em>Returns:</em> A pointer that references the same location as <code class="highlight"><c- n>a</c-><c- p>.</c-><c- n>decay</c-><c- p>(</c-><c- n>p</c-><c- p>)</c-><c- o>+</c-><c- n>i</c-></code>.</p>
       <p><em>Requires:</em></p>
       <ul>
        <li data-md>
         <p><code class="highlight"><c- n>a</c-><c- p>.</c-><c- n>decay</c-><c- p>(</c-><c- n>p</c-><c- p>)</c-><c- o>+</c-><c- n>i</c-></code> equals <code class="highlight"><c- n>A</c-><c- o>::</c-><c- n>offset_policy</c-><c- p>(</c-><c- n>a</c-><c- p>).</c-><c- n>decay</c-><c- p>(</c-><c- n>a</c-><c- p>.</c-><c- n>offset</c-><c- p>(</c-><c- n>p</c-><c- p>,</c-><c- n>i</c-><c- p>))</c-></code></p>
        <li data-md>
         <p><code class="highlight"><c- n>A</c-><c- o>::</c-><c- n>offset_policy</c-><c- p>(</c-><c- n>a</c-><c- p>).</c-><c- n>access</c-><c- p>(</c-><c- n>a</c-><c- p>.</c-><c- n>offset</c-><c- p>(</c-><c- n>p</c-><c- p>,</c-><c- n>i</c-><c- p>),</c-><c- n>j</c-><c- p>)</c-></code> is valid if <code class="highlight"><c- n>a</c-><c- p>.</c-><c- n>access</c-><c- p>(</c-><c- n>p</c-><c- p>,</c-><c- n>i</c-><c- o>+</c-><c- n>j</c-><c- p>)</c-></code> is valid.</p>
       </ul>
   </table>
   <p><br> <b>26.7.�.2 Class <code class="highlight"><c- n>accessor_basic</c-></code> [mdspan.accessor.basic]</b></p>
   <ol>
    <li data-md>
     <p><code class="highlight"><c- n>accessor_basic</c-></code> meets the requirements of accessor policy.</p>
    <li data-md>
     <p>If <code class="highlight"><c- n>T</c-></code> is not an object type or is an array type, the program is ill-formed.</p>
   </ol>
<pre class="language-c++ highlight"><c- n>namespace</c-> <c- n>std</c-> <c- p>{</c->
<c- n>namespace</c-> <c- n>experimental</c-> <c- p>{</c->
<c- n>namespace</c-> <c- n>fundamentals_v3</c-> <c- p>{</c->

  <c- n>template</c-><c- o>&lt;</c-><c- n>class</c-> <c- n>ElementType</c-><c- o>></c->
  <c- k>struct</c-> <c- n>accessor_basic</c-> <c- p>{</c->
    <c- n>using</c-> <c- n>offset_policy</c-> <c- o>=</c-> <c- n>accessor_basic</c-><c- p>;</c->
    <c- n>using</c-> <c- n>element_type</c-> <c- o>=</c-> <c- n>ElementType</c-><c- p>;</c->
    <c- n>using</c-> <c- n>reference</c-> <c- o>=</c-> <c- n>ElementType</c-><c- o>&amp;</c-><c- p>;</c->
    <c- n>using</c-> <c- n>pointer</c-> <c- o>=</c-> <c- n>ElementType</c-><c- o>*</c-><c- p>;</c->

    <c- n>constexpr</c-> <c- kr>typename</c-> <c- n>offset_policy</c-><c- o>::</c-><c- n>pointer</c->
      <c- n>offset</c-><c- p>(</c-><c- n>pointer</c-> <c- n>p</c-><c- p>,</c-> <c- b>ptrdiff_t</c-> <c- n>i</c-><c- p>)</c-> <c- k>const</c-> <c- n>noexcept</c-><c- p>;</c->

    <c- n>constexpr</c-> <c- n>reference</c-> <c- nf>access</c-><c- p>(</c-><c- n>pointer</c-> <c- n>p</c-><c- p>,</c-> <c- b>ptrdiff_t</c-> <c- n>i</c-><c- p>)</c-> <c- k>const</c-> <c- n>noexcept</c-><c- p>;</c->

    <c- n>constexpr</c-> <c- n>pointer</c-> <c- nf>decay</c-><c- p>(</c-><c- n>pointer</c-> <c- n>p</c-><c- p>)</c-> <c- k>const</c-> <c- n>noexcept</c-><c- p>;</c->
  <c- p>};</c->

<c- p>}}}</c->
</pre>
<pre class="language-c++ highlight"><c- n>constexpr</c-> <c- kr>typename</c-> <c- n>offset_policy</c-><c- o>::</c-><c- n>pointer</c->
  <c- n>offset</c-><c- p>(</c-><c- n>pointer</c-> <c- n>p</c-><c- p>,</c-> <c- b>ptrdiff_t</c-> <c- n>i</c-> <c- p>)</c-> <c- k>const</c-> <c- n>noexcept</c-><c- p>;</c->
</pre>
   <ul>
    <li data-md>
     <p><em>Requires:</em> <code class="highlight"><c- n>p</c-> <c- o>+</c-> <c- n>i</c-></code> is dereferenceable.</p>
    <li data-md>
     <p><em>Returns:</em> <code class="highlight"><c- n>p</c-> <c- o>+</c-> <c- n>i</c-></code>. <br></p>
   </ul>
<pre class="language-c++ highlight"><c- n>constexpr</c-> <c- n>reference</c-> <c- nf>access</c-><c- p>(</c-><c- n>pointer</c-> <c- n>p</c-><c- p>,</c-> <c- b>ptrdiff_t</c-> <c- n>i</c-><c- p>)</c-> <c- k>const</c-> <c- n>noexcept</c-><c- p>;</c->
</pre>
   <ul>
    <li data-md>
     <p><em>Requires:</em> <code class="highlight"><c- n>p</c-> <c- o>+</c-> <c- n>i</c-></code> is dereferenceable.</p>
    <li data-md>
     <p><em>Returns:</em> <code class="highlight"><c- n>p</c-><c- p>[</c-><c- n>i</c-><c- p>]</c-></code>. <br></p>
   </ul>
<pre class="language-c++ highlight"><c- n>constexpr</c-> <c- n>pointer</c-> <c- nf>decay</c-><c- p>(</c-><c- n>pointer</c-> <c- n>p</c-><c- p>)</c-> <c- k>const</c-> <c- n>noexcept</c-><c- p>;</c->
</pre>
   <ul>
    <li data-md>
     <p><em>Returns:</em> <code class="highlight"><c- n>p</c-></code>. <br></p>
   </ul>
   <p><br> <br> <b>26.7.� Class template <code class="highlight"><c- n>basic_mdspan</c-></code> [mdspan.basic]</b></p>
   <ol>
    <li data-md>
     <p>The <code class="highlight"><c- n>basic_mdspan</c-></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"><c- n>span</c-></code>.</p>
    <li data-md>
     <p>
      The multi-index domain space is the Cartesian product of the extents: 
      <math>[0, </math>
      <code class="highlight"><c- n>extent</c-><c- p>(</c-><c- mi>0</c-><c- p>)</c-></code>) ⨯ [0, <code class="highlight"><c- n>extent</c-><c- p>(</c-><c- mi>1</c-><c- p>)</c-></code>) ⨯ ... ⨯ [0, <code class="highlight"><c- n>extent</c-><c- p>(</c-><c- n>rank</c-><c- p>()</c-><c- o>-</c-><c- mi>1</c-><c- p>)</c-></code>).  Each extent may be statically or dynamically specified.
     </p>
    <li data-md>
     <p>As with <code class="highlight"><c- n>span</c-></code>, the storage of the objects in the codomain <code class="highlight"><c- n>span</c-></code> of a <code class="highlight"><c- n>basic_mdspan</c-></code> is owned by some other object.</p>
    <li data-md>
     <p><code class="highlight"><c- n>ElementType</c-></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"><c- n>Extents</c-></code> is required to be a (cv-unqualified) specialization of <code class="highlight"><c- n>extents</c-></code>.</p>
    <li data-md>
     <p><code class="highlight"><c- n>LayoutPolicy</c-></code> is required to meet the layout mapping policy requirements, otherwise the program is ill-formed.</p>
    <li data-md>
     <p><code class="highlight"><c- n>AccessorPolicy</c-></code> is required to meet the accessor policy requirements and <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>is_same_v</c-><c- o>&lt;</c-><c- k>typename</c-> <c- n>AccessorPolicy</c-><c- o>::</c-><c- n>element_type</c-><c- p>,</c-><c- n>ElementType</c-><c- o>></c-></code> must be <code class="highlight">false</code>, otherwise the program is ill-formed.</p>
   </ol>
<pre class="highlight"><c- k>namespace</c-> <c- n>std</c-> <c- p>{</c->
<c- k>namespace</c-> <c- n>experimental</c-> <c- p>{</c->
<c- k>namespace</c-> <c- n>fundamentals_v3</c-> <c- p>{</c->

<c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>ElementType</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Extents</c-><c- p>,</c-> <c- k>class</c-> <c- nc>LayoutPolicy</c-><c- p>,</c-> <c- k>class</c-> <c- nc>AccessorPolicy</c-><c- o>></c->
<c- k>class</c-> <c- nc>basic_mdspan</c-> <c- p>{</c->
<c- k>public</c-><c- o>:</c->

  <c- c1>// Domain and codomain types</c->
  <c- k>using</c-> <c- n>extents_type</c-> <c- o>=</c-> <c- n>Extents</c-><c- p>;</c->
  <c- k>using</c-> <c- n>layout_type</c-> <c- o>=</c-> <c- n>LayoutPolicy</c-><c- p>;</c->
  <c- k>using</c-> <c- n>accessor_type</c-> <c- o>=</c-> <c- n>AccessorPolicy</c-><c- p>;</c->
  <c- k>using</c-> <c- n>mapping_type</c-> <c- o>=</c-> <c- k>typename</c-> <c- n>layout_type</c-><c- o>::</c-><c- k>template</c-> <c- n>mapping_type</c-><c- o>&lt;</c-><c- n>extents_type</c-><c- o>></c-><c- p>;</c->
  <c- k>using</c-> <c- n>element_type</c-> <c- o>=</c-> <c- k>typename</c-> <c- n>accessor_type</c-><c- o>::</c-><c- n>element_type</c-><c- p>;</c->
  <c- k>using</c-> <c- n>value_type</c-> <c- o>=</c-> <c- n>remove_cv_t</c-><c- o>&lt;</c-><c- n>element_type</c-><c- o>></c-><c- p>;</c->
  <c- k>using</c-> <c- n>index_type</c-> <c- o>=</c-> <c- b>ptrdiff_t</c-> <c- p>;</c->
  <c- k>using</c-> <c- n>difference_type</c-> <c- o>=</c-> <c- b>ptrdiff_t</c-><c- p>;</c->
  <c- k>using</c-> <c- n>pointer</c-> <c- o>=</c-> <c- k>typename</c-> <c- n>accessor_type</c-><c- o>::</c-><c- n>pointer</c-><c- p>;</c->
  <c- k>using</c-> <c- n>reference</c-> <c- o>=</c-> <c- k>typename</c-> <c- n>accessor_type</c-><c- o>::</c-><c- n>reference</c-><c- p>;</c->

  <c- c1>// [mdspan.basic.cons], basic_mdspan constructors, assignment, and destructor</c->
  <c- k>constexpr</c-> <c- nf>basic_mdspan</c-><c- p>()</c-> <c- k>noexcept</c-> <c- o>=</c-> <c- k>default</c-><c- p>;</c->
  <c- k>constexpr</c-> <c- nf>basic_mdspan</c-><c- p>(</c-><c- k>const</c-> <c- n>basic_mdspan</c-><c- o>&amp;</c-><c- p>)</c-> <c- k>noexcept</c-> <c- o>=</c-> <c- k>default</c-><c- p>;</c->
  <c- k>constexpr</c-> <c- nf>basic_mdspan</c-><c- p>(</c-><c- n>basic_mdspan</c-><c- o>&amp;&amp;</c-><c- p>)</c-> <c- k>noexcept</c-><c- p>;</c->
  <c- k>template</c-><c- o>&lt;</c-><c- n>class</c-><c- p>...</c-> <c- n>IndexType</c-><c- o>></c->
    <c- k>explicit</c-> <c- k>constexpr</c-> <c- n>basic_mdspan</c-><c- p>(</c-><c- n>pointer</c-> <c- n>p</c-><c- p>,</c-> <c- n>IndexType</c-><c- p>...</c-> <c- n>dynamic_extents</c-><c- p>);</c->
  <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>IndexType</c-><c- p>,</c-> <c- b>size_t</c-> <c- n>N</c-><c- o>></c->
    <c- k>explicit</c-> <c- k>constexpr</c-> <c- n>basic_mdspan</c-><c- p>(</c-><c- n>pointer</c-> <c- n>p</c-><c- p>,</c-> <c- k>const</c-> <c- n>array</c-><c- o>&lt;</c-><c- n>IndexType</c-><c- p>,</c-> <c- n>N</c-><c- o>>&amp;</c-> <c- n>dynamic_extents</c-><c- p>);</c->
  <c- k>constexpr</c-> <c- nf>basic_mdspan</c-><c- p>(</c-><c- n>pointer</c-> <c- n>p</c-><c- p>,</c-> <c- k>const</c-> <c- n>mapping_type</c-><c- o>&amp;</c-> <c- n>m</c-><c- p>);</c->
  <c- k>constexpr</c-> <c- nf>basic_mdspan</c-><c- p>(</c-><c- n>pointer</c-> <c- n>p</c-><c- p>,</c-> <c- k>const</c-> <c- n>mapping_type</c-><c- o>&amp;</c-> <c- n>m</c-><c- p>,</c-> <c- k>const</c-> <c- n>accessor_type</c-><c- o>&amp;</c-> <c- n>a</c-><c- p>);</c->
  <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>OtherElementType</c-><c- p>,</c-> <c- k>class</c-> <c- nc>OtherExtents</c-><c- p>,</c-> <c- k>class</c-> <c- nc>OtherLayoutPolicy</c-><c- p>,</c-> <c- k>class</c-> <c- nc>OtherAccessorPolicy</c-><c- o>></c->
    <c- k>constexpr</c-> <c- n>basic_mdspan</c-><c- p>(</c-><c- k>const</c-> <c- n>basic_mdspan</c-><c- o>&lt;</c-><c- n>OtherElementType</c-><c- p>,</c-> <c- n>OtherExtents</c-><c- p>,</c-> <c- n>OtherLayoutPolicy</c-><c- p>,</c-> <c- n>OtherAccessorPolicy</c-><c- o>>&amp;</c-> <c- n>other</c-><c- p>);</c->

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

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

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

  <c- c1>// [mdspan.basic.domobs], basic_mdspan observers of the domain multidimensional index space</c->
  <c- k>static</c-> <c- k>constexpr</c-> <c- b>int</c-> <c- nf>rank</c-><c- p>()</c-> <c- k>noexcept</c-><c- p>;</c->
  <c- k>static</c-> <c- k>constexpr</c-> <c- b>int</c-> <c- nf>rank_dynamic</c-><c- p>()</c-> <c- k>noexcept</c-><c- p>;</c->
  <c- k>static</c-> <c- k>constexpr</c-> <c- n>index_type</c-> <c- nf>static_extent</c-><c- p>(</c-><c- b>size_t</c-><c- p>)</c-> <c- k>noexcept</c-><c- p>;</c->

  <c- k>constexpr</c-> <c- n>Extents</c-> <c- nf>extents</c-><c- p>()</c-> <c- k>const</c-> <c- k>noexcept</c-><c- p>;</c->
  <c- k>constexpr</c-> <c- n>index_type</c-> <c- nf>extent</c-><c- p>(</c-><c- b>size_t</c-><c- p>)</c-> <c- k>const</c-> <c- k>noexcept</c-><c- p>;</c->
  <c- k>constexpr</c-> <c- n>index_type</c-> <c- nf>size</c-><c- p>()</c-> <c- k>const</c-> <c- k>noexcept</c-><c- p>;</c->
  <c- k>constexpr</c-> <c- n>index_type</c-> <c- nf>unique_size</c-><c- p>()</c-> <c- k>const</c-> <c- k>noexcept</c-><c- p>;</c->

  <c- c1>// [mdspan.basic.codomain], basic_mdspan observers of the codomain</c->
  <c- k>constexpr</c-> <c- n>span</c-><c- o>&lt;</c-><c- n>element_type</c-><c- o>></c-> <c- n>span</c-><c- p>()</c-> <c- k>const</c-> <c- k>noexcept</c-><c- p>;</c->
  <c- k>constexpr</c-> <c- n>pointer</c-> <c- nf>data</c-><c- p>()</c-> <c- k>const</c-> <c- k>noexcept</c-><c- p>;</c->

  <c- c1>// [mdspan.basic.obs], basic_mdspan observers of the mapping</c->
  <c- k>static</c-> <c- k>constexpr</c-> <c- b>bool</c-> <c- nf>is_always_unique</c-><c- p>()</c-> <c- k>noexcept</c-><c- p>;</c->
  <c- k>static</c-> <c- k>constexpr</c-> <c- b>bool</c-> <c- nf>is_always_contiguous</c-><c- p>()</c-> <c- k>noexcept</c-><c- p>;</c->
  <c- k>static</c-> <c- k>constexpr</c-> <c- b>bool</c-> <c- nf>is_always_strided</c-><c- p>()</c-> <c- k>noexcept</c-><c- p>;</c->

  <c- k>constexpr</c-> <c- n>mapping_type</c-> <c- nf>mapping</c-><c- p>()</c-> <c- k>const</c-> <c- k>noexcept</c-><c- p>;</c->
  <c- k>constexpr</c-> <c- b>bool</c-> <c- nf>is_unique</c-><c- p>()</c-> <c- k>const</c-> <c- k>noexcept</c-><c- p>;</c->
  <c- k>constexpr</c-> <c- b>bool</c-> <c- nf>is_contiguous</c-><c- p>()</c-> <c- k>const</c-> <c- k>noexcept</c-><c- p>;</c->
  <c- k>constexpr</c-> <c- b>bool</c-> <c- nf>is_strided</c-><c- p>()</c-> <c- k>const</c-> <c- k>noexcept</c-><c- p>;</c->
  <c- k>constexpr</c-> <c- n>index_type</c-> <c- nf>stride</c-><c- p>(</c-><c- b>size_t</c-><c- p>)</c-> <c- k>const</c-><c- p>;</c->

<c- k>private</c-><c- o>:</c->
  <c- n>accessor_type</c-> <c- n>acc_</c-><c- p>;</c-> <c- c1>// </c-><i><c- c1>exposition only</c-></i>
  <c- n>mapping_type</c-> <c- n>map_</c-><c- p>;</c-> <c- c1>// </c-><i><c- c1>exposition only</c-></i>
  <c- n>pointer</c-> <c- n>ptr_</c-><c- p>;</c-> <c- c1>// </c-><i><c- c1>exposition only</c-></i>
<c- p>};</c->

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

  <c- c1>// [mdspan.subspan], subspan creation</c->
  <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>ElementType</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Extents</c-><c- p>,</c-> <c- k>class</c-> <c- nc>LayoutPolicy</c-><c- p>,</c->
           <c- k>class</c-> <c- nc>AccessorPolicy</c-><c- p>,</c-> <c- n>class</c-><c- p>...</c-> <c- n>SliceSpecifiers</c-><c- o>></c->
  <c- k>struct</c-> <c- n>mdspan_subspan</c-> <c- p>{</c-> <c- c1>// </c-><i><c- c1>exposition only</c-></i>
    <c- k>using</c-> <c- n>extents_t</c-> <c- o>=</c-> <i><c- n>see</c-> <c- n>below</c-></i><c- p>;</c->
    <c- k>using</c-> <c- n>layout_t</c-> <c- o>=</c-> <i><c- n>see</c-> <c- n>below</c-></i><c- p>;</c->
    <c- k>using</c-> <c- n>type</c-> <c- o>=</c-> <c- n>basic_mdspan</c-><c- o>&lt;</c-><c- n>ElementType</c-><c- p>,</c-> <c- n>extents_t</c-><c- p>,</c-> <c- n>layout_t</c-><c- p>,</c->
                              <c- k>typename</c-> <c- n>AccessorPolicy</c-><c- o>::</c-><c- n>offset_policy</c-><c- o>></c-><c- p>;</c->
  <c- p>};</c->

  <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>ElementType</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Extents</c-><c- p>,</c-> <c- k>class</c-> <c- nc>LayoutPolicy</c-><c- p>,</c->
           <c- k>class</c-> <c- nc>AccessorPolicy</c-><c- p>,</c-> <c- n>class</c-><c- p>...</c-> <c- n>SliceSpecifiers</c-><c- o>></c->
  <c- k>using</c-> <c- n>mdspan_subspan_t</c-> <c- o>=</c-> <c- c1>// </c-><i><c- c1>exposition only</c-></i>
    <c- k>typename</c-> <c- n>mdspan_subspan</c-><c- o>&lt;</c-><c- n>ElementType</c-><c- p>,</c-> <c- n>Extents</c-><c- p>,</c-> <c- n>LayoutPolicy</c-><c- p>,</c->
                            <c- n>AccessorPolicy</c-><c- p>,</c-> <c- n>SliceSpecifiers</c-><c- p>...</c-><c- o>>::</c-><c- n>type</c-><c- p>;</c->

  <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>ElementType</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Extents</c-><c- p>,</c-> <c- k>class</c-> <c- nc>LayoutPolicy</c-><c- p>,</c->
           <c- k>class</c-> <c- nc>AccessorPolicy</c-><c- p>,</c-> <c- n>class</c-><c- p>...</c-> <c- n>SliceSpecifiers</c-><c- o>></c->
    <c- n>mdspan_subspan_t</c-><c- o>&lt;</c-><c- n>ElementType</c-><c- p>,</c-> <c- n>Extents</c-><c- p>,</c-> <c- n>LayoutPolicy</c-><c- p>,</c->
                     <c- n>AccessorPolicy</c-><c- p>,</c-> <c- n>SliceSpecifiers</c-><c- p>...</c-><c- o>></c->
      <c- n>subspan</c-><c- p>(</c-><c- k>const</c-> <c- n>basic_mdspan</c-><c- o>&lt;</c-><c- n>ElementType</c-><c- p>,</c-> <c- n>Extents</c-><c- p>,</c-> <c- n>LayoutPolicy</c-><c- p>,</c->
                                 <c- n>AccessorPolicy</c-><c- o>>&amp;</c-> <c- n>src</c-><c- p>,</c->
         <c- n>SliceSpecifiers</c-> <c- p>...</c-> <c- n>slices</c-><c- p>)</c-> <c- k>noexcept</c-><c- p>;</c->

<c- p>}}}</c->
</pre>
   <p>The <code class="highlight"><c- n>subspan</c-></code> function creates a <code class="highlight"><c- n>basic_mdspan</c-></code> that is a view
of a (potentially trivial) subset of another <code class="highlight"><c- n>basic_mdspan</c-></code>.
The <code class="highlight"><c- n>SliceSpecifier</c-></code> template argument(s)
and the corresponding value(s) of the arguments of <code class="highlight"><c- n>subspan</c-></code> after <code class="highlight"><c- n>src</c-></code> determine the subset of <code class="highlight"><c- n>src</c-></code> that the return value views.</p>
   <p>
    Let <code class="highlight"><c- n>sub</c-></code> be the return value of <code class="highlight"><c- n>subspan</c-><c- p>(</c-><c- n>src</c-><c- p>,</c-> <c- n>slices</c-><c- p>...)</c-></code>.
Denote the value of the 
    <math>k</math>
    -th member of <code class="highlight"><c- n>slices</c-><c- p>...</c-></code> by 
    <math>s</math>
    <sub>k</sub>.
Denote the type of the 
    <math>k</math>
    -th member of <code class="highlight"><c- n>slices</c-><c- p>...</c-></code> by 
    <math>S</math>
    <sub>k</sub>.
   </p>
   <p>
    Let ρ be <code class="highlight"><c- n>sub</c-><c- p>.</c-><c- n>rank</c-><c- p>()</c-></code>.
ρ equals the number of <code class="highlight"><c- n>k</c-></code> such that <code class="highlight"><c- n>is_convertible_v</c-><c- o>&lt;</c-></code>
    <math>S</math>
    <sub>k</sub><code class="highlight"><c- p>,</c-> <c- n>pair</c-><c- o>&lt;</c-><c- b>ptrdiff_t</c-><c- p>,</c-> <c- b>ptrdiff_t</c-><c- o>>></c-> <c- o>||</c-> <c- n>is_convertible_v</c-><c- o>&lt;</c-></code>
    <math>S</math>
    <sub>k</sub><code class="highlight"><c- p>,</c-> <c- n>all_type</c-><c- o>></c-></code> is <code class="highlight">true</code>.
   </p>
   <p>
    Define <code class="highlight"><c- n>rank_map</c-></code> as the length ρ <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>integer_sequence</c-></code> of <code class="highlight"><c- b>ptrdiff_t</c-></code> consisting of the unique values of <code class="highlight"><c- n>k</c-></code>, in increasing order, such that <code class="highlight"><c- n>is_convertible_v</c-><c- o>&lt;</c-></code>
    <math>S</math>
    <sub>k</sub><code class="highlight"><c- p>,</c-> <c- n>pair</c-><c- o>&lt;</c-><c- b>ptrdiff_t</c-><c- p>,</c-> <c- b>ptrdiff_t</c-><c- o>>></c-> <c- o>||</c-> <c- n>is_convertible_v</c-><c- o>&lt;</c-></code>
    <math>S</math>
    <sub>k</sub><code class="highlight"><c- p>,</c-> <c- n>all_type</c-><c- o>></c-></code> is <code class="highlight">true</code>.
Define the exposition-only <code class="highlight"><c- k>constexpr</c-></code> function <code class="highlight"><c- n>get_seq</c-><c- o>&lt;</c-><c- n>k</c-><c- o>></c-><c- p>(</c-><c- n>seq</c-><c- p>)</c-></code>,
where <code class="highlight"><c- n>k</c-></code> is an integer,
as the function returning the <code class="highlight"><c- n>k</c-></code>-th entry of the <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>integer_sequence</c-></code> <code class="highlight"><c- n>seq</c-></code>.
We say that the integer r "is not in <code class="highlight"><c- n>rank_map</c-></code>" when,
for 0 &lt;= <code class="highlight"><c- n>k</c-></code> &lt; ρ, r does not equal <code class="highlight"><c- n>get_seq</c-><c- o>&lt;</c-><c- n>k</c-><c- o>></c-><c- p>(</c-><c- n>rank_map</c-><c- p>)</c-></code>.
   </p>
   <p>In the exposition-only <code class="highlight"><c- k>struct</c-> <c- n>mdspan_subspan</c-></code>,</p>
   <ul>
    <li data-md>
     <p>The <code class="highlight"><c- n>extents_t</c-></code> type alias is a specialization of <code class="highlight"><c- n>extents</c-></code> <strong>[mdspan.extents]</strong>, and is determined by
  the description of the semantics of <code class="highlight"><c- n>subspan</c-></code> given below;</p>
    <li data-md>
     <p>The <code class="highlight"><c- n>layout_t</c-></code> type alias meets the requirements
  of a layout mapping policy <strong>[mdspan.layout.reqs]</strong> and is implementation defined; and</p>
    <li data-md>
     <p>The <code class="highlight"><c- n>type</c-></code> type alias specifies the type returned by <code class="highlight"><c- n>subspan</c-></code>.</p>
   </ul>
   <p><em>[Note:</em> High-quality implementations will avoid <code class="highlight"><c- n>layout_stride</c-></code> whenever possible,
if the input layout is <code class="highlight"><c- n>layout_left</c-></code> or <code class="highlight"><c- n>layout_right</c-></code>. <em>— end note]</em></p>
   <p>Let <code class="highlight"><c- n>first</c-></code> and <code class="highlight"><c- n>last</c-></code> be exposition-only <code class="highlight"><c- n>array</c-><c- o>&lt;</c-><c- b>ptrdiff_t</c-><c- p>,</c-> <c- k>sizeof</c-><c- p>...(</c-><c- n>SliceSpecifier</c-><c- p>)</c-><c- o>></c-></code>,
where <code class="highlight"><c- n>SliceSpecifier</c-><c- p>...</c-></code> is the same parameter pack as <code class="highlight"><c- n>subspan</c-></code>'s.
For 0 &lt;= <code class="highlight"><c- n>r</c-></code> &lt; <code class="highlight"><c- k>sizeof</c-><c- p>...(</c-><c- n>SliceSpecifier</c-><c- p>)</c-></code>,
define the values of <code class="highlight"><c- n>first</c-><c- p>[</c-><c- n>r</c-><c- p>]</c-></code> and <code class="highlight"><c- n>last</c-><c- p>[</c-><c- n>r</c-><c- p>]</c-></code> as follows,
where <code class="highlight"><c- n>src</c-></code> and <code class="highlight"><c- n>slices</c-><c- p>...</c-></code> are the arguments of <code class="highlight"><c- n>subspan</c-></code>.</p>
   <ul>
    <li data-md>
     <p>
      If <code class="highlight"><c- n>is_convertible_v</c-><c- o>&lt;</c-></code>
      <math>S</math>
      <sub><code class="highlight"><c- n>r</c-></code></sub><code class="highlight"><c- p>,</c-> <c- b>ptrdiff_t</c-><c- o>></c-></code>,
  then <code class="highlight"><c- n>first</c-><c- p>[</c-><c- n>r</c-><c- p>]</c-></code> equals 
      <math>s</math>
      <sub><code class="highlight"><c- n>r</c-></code></sub>, and <code class="highlight"><c- n>last</c-><c- p>[</c-><c- n>r</c-><c- p>]</c-></code> equals <code class="highlight"><c- n>first</c-><c- p>[</c-><c- n>r</c-><c- p>]</c-></code> + 1;
     </p>
    <li data-md>
     <p>
      Else, if <code class="highlight"><c- n>is_convertible_v</c-><c- o>&lt;</c-></code>
      <math>S</math>
      <sub><code class="highlight"><c- n>r</c-></code></sub><code class="highlight"><c- p>,</c-> <c- n>pair</c-><c- o>&lt;</c-><c- b>ptrdiff_t</c-><c- p>,</c-> <c- b>ptrdiff_t</c-><c- o>>></c-></code>,
  then <code class="highlight"><c- n>first</c-><c- p>[</c-><c- n>r</c-><c- p>]</c-></code> equals <code class="highlight"><c- n>p</c-><c- p>.</c-><c- n>first</c-></code>, and <code class="highlight"><c- n>last</c-><c- p>[</c-><c- n>r</c-><c- p>]</c-></code> equals <code class="highlight"><c- n>p</c-><c- p>.</c-><c- n>second</c-></code>,
  where <code class="highlight"><c- n>p</c-></code> is the result of converting 
      <math>s</math>
      <sub><code class="highlight"><c- n>r</c-></code></sub> to <code class="highlight"><c- n>pair</c-><c- o>&lt;</c-><c- b>ptrdiff_t</c-><c- p>,</c-> <c- b>ptrdiff_t</c-><c- o>></c-></code>;
     </p>
    <li data-md>
     <p>
      Else, if <code class="highlight"><c- n>is_convertible_v</c-><c- o>&lt;</c-></code>
      <math>S</math>
      <sub><code class="highlight"><c- n>r</c-></code></sub><code class="highlight"><c- p>,</c-> <c- n>all_type</c-><c- o>></c-></code>,
  then <code class="highlight"><c- n>first</c-><c- p>[</c-><c- n>r</c-><c- p>]</c-> <c- o>=</c-> <c- mi>0</c-></code>, and <code class="highlight"><c- n>last</c-><c- p>[</c-><c- n>r</c-><c- p>]</c-></code> equals <code class="highlight"><c- n>src</c-><c- p>.</c-><c- n>extent</c-><c- p>(</c-><c- n>r</c-><c- p>)</c-></code>.
     </p>
   </ul>
   <ul>
    <li data-md>
     <p><em>Requires:</em></p>
     <ul>
      <li data-md>
       <p><code class="highlight"><c- k>sizeof</c-><c- p>(</c-><c- n>slices</c-><c- p>...)</c-></code> equals <code class="highlight"><c- n>src</c-><c- p>.</c-><c- n>rank</c-><c- p>()</c-></code>.</p>
      <li data-md>
       <p>For 0 &lt;= <code class="highlight"><c- n>r</c-></code> &lt; <code class="highlight"><c- k>sizeof</c-><c- p>...(</c-><c- n>slices</c-><c- p>)</c-></code>, <code class="highlight"><c- mi>0</c-> <c- o>&lt;=</c-> <c- n>first</c-><c- p>[</c-><c- n>r</c-><c- p>]</c-> <c- o>&amp;&amp;</c-> <c- n>first</c-><c- p>[</c-><c- n>r</c-><c- p>]</c-> <c- o>&lt;</c-> <c- n>last</c-><c- p>[</c-><c- n>r</c-><c- p>]</c-> <c- o>&amp;&amp;</c-> <c- n>last</c-><c- p>[</c-><c- n>r</c-><c- p>]</c-> <c- o>&lt;=</c-> <c- n>src</c-><c- p>.</c-><c- n>extent</c-><c- p>(</c-><c- n>r</c-><c- p>)</c-></code> is <code class="highlight">true</code>.</p>
     </ul>
    <li data-md>
     <p><em>Constraints:</em></p>
     <ul>
      <li data-md>
       <p><code class="highlight"><c- n>LayoutPolicy</c-></code> is <code class="highlight"><c- n>layout_left</c-></code>, <code class="highlight"><c- n>layout_right</c-></code>, <code class="highlight"><c- n>layout_stride</c-></code>,
   or any type in a possibly empty set of implementation-defined types,
   each of which meets the requirements of a layout mapping policy <strong>[mdspan.layout.reqs]</strong>. <em>[Note:</em> Valid and useful layout mapping policies exist,
   for which taking an arbitrary <code class="highlight"><c- n>subspan</c-></code> does not make sense. <em>— end note]</em></p>
      <li data-md>
       <p>
        For 0 &lt;= <code class="highlight"><c- n>k</c-></code> &lt; <code class="highlight"><c- k>sizeof</c-><c- p>...(</c-><c- n>slices</c-><c- p>)</c-></code>, <code class="highlight"><c- n>is_convertible_v</c-><c- o>&lt;</c-></code>
        <math>S</math>
        <sub>k</sub><code class="highlight"><c- p>,</c-> <c- b>ptrdiff_t</c-><c- o>></c-> <c- o>||</c-> <c- n>is_convertible_v</c-><c- o>&lt;</c-></code>
        <math>S</math>
        <sub>k</sub><code class="highlight"><c- p>,</c-> <c- n>pair</c-><c- o>&lt;</c-><c- b>ptrdiff_t</c-><c- p>,</c-> <c- b>ptrdiff_t</c-><c- o>>></c-> <c- o>||</c-> <c- n>is_convertible_v</c-><c- o>&lt;</c-></code>
        <math>S</math>
        <sub>k</sub><code class="highlight"><c- p>,</c-> <c- n>all_type</c-><c- o>></c-></code> is <code class="highlight">true</code>.
       </p>
     </ul>
    <li data-md>
     <p><em>Ensures:</em></p>
     <ul>
      <li data-md>
       <p><code class="highlight"><c- n>sub</c-><c- p>.</c-><c- n>rank</c-><c- p>()</c-></code> equals ρ.</p>
      <li data-md>
       <p><code class="highlight"><c- n>mdspan_subspan</c-><c- o>&lt;</c-><c- n>ElementType</c-><c- p>,</c-> <c- n>Extents</c-><c- p>,</c-> <c- n>LayoutPolicy</c-><c- p>,</c-> <c- n>AccessorPolicy</c-><c- p>,</c-> <c- n>SliceSpecifiers</c-><c- p>...</c-><c- o>>::</c-><c- n>extents_t</c-><c- o>::</c-><c- n>rank</c-><c- p>()</c-></code> equals ρ.</p>
      <li data-md>
       <p>
        Let the pack <code class="highlight"><c- n>i</c-><c- p>...</c-></code> denote a multi-index in the domain of <code class="highlight"><c- n>sub</c-></code> such that 
        <math>i</math>
        <sub><code class="highlight"><c- n>k</c-></code></sub> &lt; <code class="highlight"><c- n>sub</c-><c- p>.</c-><c- n>extents</c-><c- p>(</c-><c- n>k</c-><c- p>)</c-></code> for 0 &lt;= <code class="highlight"><c- n>k</c-></code> &lt; ρ,
  where 
        <math>i</math>
        <sub><code class="highlight"><c- n>k</c-></code></sub> denotes the <code class="highlight"><c- n>k</c-></code>-th member of <code class="highlight"><c- n>i</c-><c- p>...</c-></code> .
  Let the pack <code class="highlight"><c- n>j</c-><c- p>...</c-></code> denote a multi-index in the domain of <code class="highlight"><c- n>src</c-></code> where
  the <code class="highlight"><c- n>get_seq</c-><c- o>&lt;</c-><c- n>k</c-><c- o>></c-><c- p>(</c-><c- n>rank_map</c-><c- p>)</c-></code>-th member of <code class="highlight"><c- n>j</c-><c- p>...</c-></code> equals <code class="highlight"><c- n>first</c-><c- p>[</c-><c- n>get_seq</c-><c- o>&lt;</c-><c- n>k</c-><c- o>></c-><c- p>(</c-><c- n>rank_map</c-><c- p>)]</c-></code> + 
        <math>i</math>
        <sub><code class="highlight"><c- n>k</c-></code></sub> for 0 &lt;= <code class="highlight"><c- n>k</c-></code> &lt; 
        <math>ρ</math>
        , 
  and the <code class="highlight"><c- n>r</c-></code>-th member of <code class="highlight"><c- n>j</c-><c- p>...</c-></code> equals <code class="highlight"><c- n>first</c-><c- p>[</c-><c- n>r</c-><c- p>]</c-></code> for all <code class="highlight"><c- n>r</c-></code> such that 0 &lt;= <code class="highlight"><c- n>r</c-></code> &lt; <code class="highlight"><c- n>src</c-><c- p>.</c-><c- n>rank</c-><c- p>()</c-></code> and <code class="highlight"><c- n>r</c-></code> is not in <code class="highlight"><c- n>rank_map</c-></code>.
  Then, <code class="highlight"><c- n>sub</c-><c- p>(</c-><c- n>i</c-><c- p>...)</c-></code> and <code class="highlight"><c- n>src</c-><c- p>(</c-><c- n>j</c-><c- p>...)</c-></code> refer to the same element.
       </p>
      <li data-md>
       <p>For 0 &lt;= <code class="highlight"><c- n>k</c-></code> &lt; ρ, <code class="highlight"><c- n>sub</c-><c- p>.</c-><c- n>extent</c-><c- p>(</c-><c- n>k</c-><c- p>)</c-></code> equals <code class="highlight"><c- n>last</c-><c- p>[</c-><c- n>get_seq</c-><c- o>&lt;</c-><c- n>k</c-><c- o>></c-><c- p>(</c-><c- n>rank_map</c-><c- p>)]</c-> <c- o>-</c-> <c- n>first</c-><c- p>[</c-><c- n>get_seq</c-><c- o>&lt;</c-><c- n>k</c-><c- o>></c-><c- p>(</c-><c- n>rank_map</c-><c- p>)]</c-></code>.</p>
      <li data-md>
       <p>If <code class="highlight"><c- n>src</c-><c- p>.</c-><c- n>is_strided</c-><c- p>()</c-></code>, then <code class="highlight"><c- n>sub</c-><c- p>.</c-><c- n>is_strided</c-><c- p>()</c-></code> is <code class="highlight">true</code>,
  and for 0 &lt;= <code class="highlight"><c- n>k</c-></code> &lt; ρ, <code class="highlight"><c- n>sub</c-><c- p>.</c-><c- n>stride</c-><c- p>(</c-><c- n>k</c-><c- p>)</c-></code> equals <code class="highlight"><c- n>src</c-><c- p>.</c-><c- n>stride</c-><c- p>(</c-><c- n>get_seq</c-><c- o>&lt;</c-><c- n>k</c-><c- o>></c-><c- p>(</c-><c- n>rank_map</c-><c- p>))</c-></code>.</p>
      <li data-md>
       <p>
        For 0 &lt;= <code class="highlight"><c- n>k</c-></code> &lt; ρ,
  let <code class="highlight"><c- n>rmk</c-></code> equal <code class="highlight"><c- n>get_seq</c-><c- o>&lt;</c-><c- n>k</c-><c- o>></c-><c- p>(</c-><c- n>rank_map</c-><c- p>)</c-></code>; then,
  if <code class="highlight"><c- n>src</c-><c- p>.</c-><c- n>static_extent</c-><c- p>(</c-><c- n>rmk</c-><c- p>)</c-></code> does not equal <code class="highlight"><c- n>dynamic_extent</c-></code> and <code class="highlight"><c- n>is_convertible_v</c-><c- o>&lt;</c-></code>
        <math>S</math>
        <sub><code class="highlight"><c- n>rmk</c-></code></sub><code class="highlight"><c- p>,</c-> <c- n>all_type</c-><c- o>></c-></code> is <code class="highlight">true</code>,
  then <code class="highlight"><c- n>sub</c-><c- p>.</c-><c- n>static_extent</c-><c- p>(</c-><c- n>k</c-><c- p>)</c-></code> equals <code class="highlight"><c- n>src</c-><c- p>.</c-><c- n>static_extent</c-><c- p>(</c-><c- n>rmk</c-><c- p>)</c-></code>.
       </p>
     </ul>
   </ul>
   <p><br></p>
   <p><em>[Note:</em> Example of <code class="highlight"><c- n>subspan</c-></code> use:</p>
<pre class="language-c++ highlight"><c- c1>// Create a mapping</c->
<c- k>typedef</c-> <c- n>extents</c-><c- o>&lt;</c-><c- mi>3</c-><c- p>,</c-><c- n>dynamic_extent</c-><c- p>,</c-><c- mi>7</c-><c- o>></c-> <c- n>Extents3D</c-><c- p>;</c->
<c- n>layout_right</c-><c- o>::</c-><c- n>template</c-> <c- n>mapping</c-><c- o>&lt;</c-><c- n>Extents3D</c-><c- o>></c-> <c- n>map_right</c-><c- p>(</c-><c- mi>10</c-><c- p>);</c->

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

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

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

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

<c- d>/* Output</c->
<c- d>10401 10402 10403 10404 10405</c->
<c- d>10501 10502 10503 10504 10505</c->
<c- d>*/</c->
</pre>
   <em>- end note]</em> 
   <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"><c- n>reference</c-></code> type may be a proxy for accessing an <code class="highlight"><c- n>element_type</c-></code> object. For example, the <em>atomic</em> <code class="highlight"><c- n>AccessorPolicy</c-></code> in <strong>P0860</strong> defines <code class="highlight"><c- n>AccessorPolicy</c-><c- o>::</c-><c- k>template</c-> <c- n>accessor_type</c-><c- o>&lt;</c-><c- n>T</c-><c- o>>::</c-><c- n>reference</c-></code> to be <code class="highlight"><c- n>atomic_ref</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></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"><c- n>mdspan</c-></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"><c- n>AccessorPolicy</c-></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"><c- n>mdspan</c-></code> Included proposed
modification of <code class="highlight"><c- n>span</c-></code> to better align <code class="highlight"><c- n>span</c-></code> with <code class="highlight"><c- n>mdspan</c-></code>.</p>
    <li data-md>
     <p><strong>P0546</strong> : Preparing <code class="highlight"><c- n>span</c-></code> for the future Proposed modification of <code class="highlight"><c- n>span</c-></code></p>
    <li data-md>
     <p><strong>P0856</strong> : Restrict access property for <code class="highlight"><c- n>mdspan</c-></code> and <code class="highlight"><c- n>span</c-></code></p>
    <li data-md>
     <p><strong>P0860</strong> : atomic access policy for <code class="highlight"><c- n>mdspan</c-></code></p>
    <li data-md>
     <p><strong>P0900</strong> : An Ontology of Properties for <code class="highlight"><c- n>mdspan</c-></code></p>
   </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>