<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml" lang xml:lang>
<head>
  <meta charset="utf-8" />
  <meta name="generator" content="mpark/wg21" />
  <meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes" />
  <meta name="dcterms.date" content="2020-02-28" />
  <title>MDSPAN</title>
  <style>
      code{white-space: pre-wrap;}
      span.smallcaps{font-variant: small-caps;}
      span.underline{text-decoration: underline;}
      div.column{display: inline-block; vertical-align: top; width: 50%;}
  </style>
  <style>
pre > code.sourceCode { white-space: pre; position: relative; }
pre > code.sourceCode > span { display: inline-block; line-height: 1.25; }
pre > code.sourceCode > span:empty { height: 1.2em; }
code.sourceCode > span { color: inherit; text-decoration: inherit; }
div.sourceCode { margin: 1em 0; }
pre.sourceCode { margin: 0; }
@media screen {
div.sourceCode { overflow: auto; }
}
@media print {
pre > code.sourceCode { white-space: pre-wrap; }
pre > code.sourceCode > span { text-indent: -5em; padding-left: 5em; }
}
pre.numberSource code
  { counter-reset: source-line 0; }
pre.numberSource code > span
  { position: relative; left: -4em; counter-increment: source-line; }
pre.numberSource code > span > a:first-child::before
  { content: counter(source-line);
    position: relative; left: -1em; text-align: right; vertical-align: baseline;
    border: none; display: inline-block;
    -webkit-touch-callout: none; -webkit-user-select: none;
    -khtml-user-select: none; -moz-user-select: none;
    -ms-user-select: none; user-select: none;
    padding: 0 4px; width: 4em;
    color: #aaaaaa;
  }
pre.numberSource { margin-left: 3em; border-left: 1px solid #aaaaaa;  padding-left: 4px; }
div.sourceCode
  {  background-color: #f6f8fa; }
@media screen {
pre > code.sourceCode > span > a:first-child::before { text-decoration: underline; }
}
code span. { } /* Normal */
code span.al { color: #ff0000; } /* Alert */
code span.an { } /* Annotation */
code span.at { } /* Attribute */
code span.bn { color: #9f6807; } /* BaseN */
code span.bu { color: #9f6807; } /* BuiltIn */
code span.cf { color: #00607c; } /* ControlFlow */
code span.ch { color: #9f6807; } /* Char */
code span.cn { } /* Constant */
code span.co { color: #008000; font-style: italic; } /* Comment */
code span.cv { color: #008000; font-style: italic; } /* CommentVar */
code span.do { color: #008000; } /* Documentation */
code span.dt { color: #00607c; } /* DataType */
code span.dv { color: #9f6807; } /* DecVal */
code span.er { color: #ff0000; font-weight: bold; } /* Error */
code span.ex { } /* Extension */
code span.fl { color: #9f6807; } /* Float */
code span.fu { } /* Function */
code span.im { } /* Import */
code span.in { color: #008000; } /* Information */
code span.kw { color: #00607c; } /* Keyword */
code span.op { color: #af1915; } /* Operator */
code span.ot { } /* Other */
code span.pp { color: #6f4e37; } /* Preprocessor */
code span.re { } /* RegionMarker */
code span.sc { color: #9f6807; } /* SpecialChar */
code span.ss { color: #9f6807; } /* SpecialString */
code span.st { color: #9f6807; } /* String */
code span.va { } /* Variable */
code span.vs { color: #9f6807; } /* VerbatimString */
code span.wa { color: #008000; font-weight: bold; } /* Warning */
code.diff {color: #898887}
code.diff span.va {color: #006e28}
code.diff span.st {color: #bf0303}
  </style>
  <style type="text/css">
body {
margin: 5em;
font-family: serif;

hyphens: auto;
line-height: 1.35;
}
div.wrapper {
max-width: 60em;
margin: auto;
}
ul {
list-style-type: none;
padding-left: 2em;
margin-top: -0.2em;
margin-bottom: -0.2em;
}
a {
text-decoration: none;
color: #4183C4;
}
a.hidden_link {
text-decoration: none;
color: inherit;
}
li {
margin-top: 0.6em;
margin-bottom: 0.6em;
}
h1, h2, h3, h4 {
position: relative;
line-height: 1;
}
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;
font-family: sans-serif;
font-weight: normal;
font-size: 83%;
}
a.self-link:hover { opacity: 1; }
a.self-link::before { content: "§"; }
ul > li:before {
content: "\2014";
position: absolute;
margin-left: -1.5em;
}
:target { background-color: #C9FBC9; }
:target .codeblock { background-color: #C9FBC9; }
:target ul { background-color: #C9FBC9; }
.abbr_ref { float: right; }
.folded_abbr_ref { float: right; }
:target .folded_abbr_ref { display: none; }
:target .unfolded_abbr_ref { float: right; display: inherit; }
.unfolded_abbr_ref { display: none; }
.secnum { display: inline-block; min-width: 35pt; }
.header-section-number { display: inline-block; min-width: 35pt; }
.annexnum { display: block; }
div.sourceLinkParent {
float: right;
}
a.sourceLink {
position: absolute;
opacity: 0;
margin-left: 10pt;
}
a.sourceLink:hover {
opacity: 1;
}
a.itemDeclLink {
position: absolute;
font-size: 75%;
text-align: right;
width: 5em;
opacity: 0;
}
a.itemDeclLink:hover { opacity: 1; }
span.marginalizedparent {
position: relative;
left: -5em;
}
li span.marginalizedparent { left: -7em; }
li ul > li span.marginalizedparent { left: -9em; }
li ul > li ul > li span.marginalizedparent { left: -11em; }
li ul > li ul > li ul > li span.marginalizedparent { left: -13em; }
div.footnoteNumberParent {
position: relative;
left: -4.7em;
}
a.marginalized {
position: absolute;
font-size: 75%;
text-align: right;
width: 5em;
}
a.enumerated_item_num {
position: relative;
left: -3.5em;
display: inline-block;
margin-right: -3em;
text-align: right;
width: 3em;
}
div.para { margin-bottom: 0.6em; margin-top: 0.6em; text-align: justify; }
div.section { text-align: justify; }
div.sentence { display: inline; }
span.indexparent {
display: inline;
position: relative;
float: right;
right: -1em;
}
a.index {
position: absolute;
display: none;
}
a.index:before { content: "⟵"; }

a.index:target {
display: inline;
}
.indexitems {
margin-left: 2em;
text-indent: -2em;
}
div.itemdescr {
margin-left: 3em;
}
.bnf {
font-family: serif;
margin-left: 40pt;
margin-top: 0.5em;
margin-bottom: 0.5em;
}
.ncbnf {
font-family: serif;
margin-top: 0.5em;
margin-bottom: 0.5em;
margin-left: 40pt;
}
.ncsimplebnf {
font-family: serif;
font-style: italic;
margin-top: 0.5em;
margin-bottom: 0.5em;
margin-left: 40pt;
background: inherit; 
}
span.textnormal {
font-style: normal;
font-family: serif;
white-space: normal;
display: inline-block;
}
span.rlap {
display: inline-block;
width: 0px;
}
span.descr { font-style: normal; font-family: serif; }
span.grammarterm { font-style: italic; }
span.term { font-style: italic; }
span.terminal { font-family: monospace; font-style: normal; }
span.nonterminal { font-style: italic; }
span.tcode { font-family: monospace; font-style: normal; }
span.textbf { font-weight: bold; }
span.textsc { font-variant: small-caps; }
a.nontermdef { font-style: italic; font-family: serif; }
span.emph { font-style: italic; }
span.techterm { font-style: italic; }
span.mathit { font-style: italic; }
span.mathsf { font-family: sans-serif; }
span.mathrm { font-family: serif; font-style: normal; }
span.textrm { font-family: serif; }
span.textsl { font-style: italic; }
span.mathtt { font-family: monospace; font-style: normal; }
span.mbox { font-family: serif; font-style: normal; }
span.ungap { display: inline-block; width: 2pt; }
span.textit { font-style: italic; }
span.texttt { font-family: monospace; }
span.tcode_in_codeblock { font-family: monospace; font-style: normal; }
span.phantom { color: white; }

span.math { font-style: normal; }
span.mathblock {
display: block;
margin-left: auto;
margin-right: auto;
margin-top: 1.2em;
margin-bottom: 1.2em;
text-align: center;
}
span.mathalpha {
font-style: italic;
}
span.synopsis {
font-weight: bold;
margin-top: 0.5em;
display: block;
}
span.definition {
font-weight: bold;
display: block;
}
.codeblock {
margin-left: 1.2em;
line-height: 127%;
}
.outputblock {
margin-left: 1.2em;
line-height: 127%;
}
div.itemdecl {
margin-top: 2ex;
}
code.itemdeclcode {
white-space: pre;
display: block;
}
span.textsuperscript {
vertical-align: super;
font-size: smaller;
line-height: 0;
}
.footnotenum { vertical-align: super; font-size: smaller; line-height: 0; }
.footnote {
font-size: small;
margin-left: 2em;
margin-right: 2em;
margin-top: 0.6em;
margin-bottom: 0.6em;
}
div.minipage {
display: inline-block;
margin-right: 3em;
}
div.numberedTable {
text-align: center;
margin: 2em;
}
div.figure {
text-align: center;
margin: 2em;
}
table {
border: 1px solid black;
border-collapse: collapse;
margin-left: auto;
margin-right: auto;
margin-top: 0.8em;
text-align: left;
hyphens: none; 
}
td, th {
padding-left: 1em;
padding-right: 1em;
vertical-align: top;
}
td.empty {
padding: 0px;
padding-left: 1px;
}
td.left {
text-align: left;
}
td.right {
text-align: right;
}
td.center {
text-align: center;
}
td.justify {
text-align: justify;
}
td.border {
border-left: 1px solid black;
}
tr.rowsep, td.cline {
border-top: 1px solid black;
}
tr.even, tr.odd {
border-bottom: 1px solid black;
}
tr.capsep {
border-top: 3px solid black;
border-top-style: double;
}
tr.header {
border-bottom: 3px solid black;
border-bottom-style: double;
}
th {
border-bottom: 1px solid black;
}
span.centry {
font-weight: bold;
}
div.table {
display: block;
margin-left: auto;
margin-right: auto;
text-align: center;
width: 90%;
}
span.indented {
display: block;
margin-left: 2em;
margin-bottom: 1em;
margin-top: 1em;
}
ol.enumeratea { list-style-type: none; background: inherit; }
ol.enumerate { list-style-type: none; background: inherit; }

code.sourceCode > span { display: inline; }

div#refs p { padding-left: 32px; text-indent: -32px; }
</style>
  <link href="data:image/vnd.microsoft.icon;base64,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" rel="icon" />
  <!--[if lt IE 9]>
    <script src="//cdnjs.cloudflare.com/ajax/libs/html5shiv/3.7.3/html5shiv-printshiv.min.js"></script>
  <![endif]-->
  
</head>
<body>
<div class="wrapper">
<header id="title-block-header">
<h1 class="title" style="text-align:center"><code>MDSPAN</code></h1>

<table style="border:none;float:right">
  <tr>
    <td>Document #: </td>
    <td>p0009r10</td>
  </tr>
  <tr>
    <td>Date: </td>
    <td>2020-02-28</td>
  </tr>
  <tr>
    <td style="vertical-align:top">Project: </td>
    <td>Programming Language C++<br>
      LWG<br>
    </td>
  </tr>
  <tr>
    <td style="vertical-align:top">Reply-to: </td>
    <td>
      Christian Trott<br>&lt;<a href="mailto:crtrott@sandia.gov" class="email">crtrott@sandia.gov</a>&gt;<br>
      D.S. Hollman<br>&lt;<a href="mailto:dshollm@sandia.gov" class="email">dshollm@sandia.gov</a>&gt;<br>
      Damien Lebrun-Grandie<br>&lt;<a href="mailto:lebrungrandt@ornl.gov" class="email">lebrungrandt@ornl.gov</a>&gt;<br>
      Mark Hoemmen<br>&lt;<a href="mailto:mhoemme@sandia.gov" class="email">mhoemme@sandia.gov</a>&gt;<br>
      Daniel Sunderland<br>&lt;<a href="mailto:dsunder@sandia.gov" class="email">dsunder@sandia.gov</a>&gt;<br>
      H. Carter Edwards<br>&lt;<a href="mailto:hedwards@nvidia.com" class="email">hedwards@nvidia.com</a>&gt;<br>
      Bryce Adelstein Lelbach<br>&lt;<a href="mailto:blelbach@nvidia.com" class="email">blelbach@nvidia.com</a>&gt;<br>
      Mauro Bianco<br>&lt;<a href="mailto:mbianco@cscs.ch" class="email">mbianco@cscs.ch</a>&gt;<br>
      Ben Sander<br>&lt;<a href="mailto:ben.sander@amd.com" class="email">ben.sander@amd.com</a>&gt;<br>
      Athanasios Iliopoulos<br>&lt;<a href="mailto:athanasios.iliopoulos@nrl.navy.mil" class="email">athanasios.iliopoulos@nrl.navy.mil</a>&gt;<br>
      John Michopoulos<br>&lt;<a href="mailto:john.michopoulos@nrl.navy.mil" class="email">john.michopoulos@nrl.navy.mil</a>&gt;<br>
    </td>
  </tr>
</table>

</header>
<div style="clear:both">
<div id="TOC" role="doc-toc">
<h1 id="toctitle">Contents</h1>
<ul>
<li><a href="#revision-history"><span class="toc-section-number">1</span> Revision History<span></span></a>
<ul>
<li><a href="#p0009r10-pre-2020-02-prague-mailing"><span class="toc-section-number">1.1</span> P0009r10: Pre 2020-02-Prague Mailing<span></span></a></li>
<li><a href="#p0009r9-pre-2019-02-kona-mailing"><span class="toc-section-number">1.2</span> P0009r9: Pre 2019-02-Kona Mailing<span></span></a></li>
<li><a href="#p0009r8-pre-2018-11-sandiego-mailing"><span class="toc-section-number">1.3</span> P0009r8: Pre 2018-11-SanDiego Mailing<span></span></a></li>
<li><a href="#p0009r7-post-2018-06-rapperswil-mailing"><span class="toc-section-number">1.4</span> P0009r7: Post 2018-06-Rapperswil Mailing<span></span></a></li>
<li><a href="#p0009r6-pre-2018-06-rapperswil-mailing"><span class="toc-section-number">1.5</span> P0009r6 : Pre 2018-06-Rapperswil Mailing<span></span></a></li>
<li><a href="#p0009r5-pre-2018-03-jacksonville-mailing"><span class="toc-section-number">1.6</span> P0009r5 : Pre 2018-03-Jacksonville Mailing<span></span></a></li>
<li><a href="#p0009r4-pre-2017-11-albuquerque-mailing"><span class="toc-section-number">1.7</span> P0009r4 : Pre 2017-11-Albuquerque Mailing<span></span></a></li>
<li><a href="#p0009r3-post-2016-06-oulu-mailing"><span class="toc-section-number">1.8</span> P0009r3 : Post 2016-06-Oulu Mailing<span></span></a></li>
<li><a href="#p0009r2-pre-2016-06-oulu-mailing"><span class="toc-section-number">1.9</span> P0009r2 : Pre 2016-06-Oulu Mailing<span></span></a></li>
<li><a href="#p0009r1-pre-2016-02-jacksonville-mailing"><span class="toc-section-number">1.10</span> P0009r1 : Pre 2016-02-Jacksonville Mailing<span></span></a></li>
<li><a href="#p0009r0-pre-2015-10-kona-mailing"><span class="toc-section-number">1.11</span> P0009r0 : Pre 2015-10-Kona Mailing<span></span></a></li>
<li><a href="#related-activity"><span class="toc-section-number">1.12</span> Related Activity<span></span></a></li>
</ul></li>
<li><a href="#description"><span class="toc-section-number">2</span> Description<span></span></a></li>
<li><a href="#editing-notes"><span class="toc-section-number">3</span> Editing Notes<span></span></a></li>
<li><a href="#wording"><span class="toc-section-number">4</span> Wording<span></span></a></li>
<li><a href="#next-steps"><span class="toc-section-number">5</span> Next Steps<span></span></a></li>
<li><a href="#related-work"><span class="toc-section-number">6</span> Related Work<span></span></a></li>
</ul>
</div>
<h1 data-number="1" id="revision-history" data-number="1"><span class="header-section-number">1</span> Revision History<a href="#revision-history" class="self-link"></a></h1>
<h2 data-number="1.1" id="p0009r10-pre-2020-02-prague-mailing" data-number="1.1"><span class="header-section-number">1.1</span> P0009r10: Pre 2020-02-Prague Mailing<a href="#p0009r10-pre-2020-02-prague-mailing" class="self-link"></a></h2>
<ul>
<li>Switched to mpark/wg21 pandoc format</li>
<li>Add general description of span and mdspan</li>
<li>Removed <code>mdspan_subspan</code> expo only type; use <code>basic_mdspan&lt;</code><em>see below</em><code>&gt;</code> instead</li>
<li>Fixed typos in accessor table</li>
<li>Made editorial changes to wording based on San Diego feedback</li>
<li>Updated operational semantics subsection heading based on new style guidelines</li>
</ul>
<h2 data-number="1.2" id="p0009r9-pre-2019-02-kona-mailing" data-number="1.2"><span class="header-section-number">1.2</span> P0009r9: Pre 2019-02-Kona Mailing<a href="#p0009r9-pre-2019-02-kona-mailing" class="self-link"></a></h2>
<ul>
<li>Wording fixes based on guidance: <a href="http://wiki.edg.com/bin/view/Wg21sandiego2018/SanDiego2018P0009">LWG small group at 2018-11-SanDiego</a></li>
</ul>
<h2 data-number="1.3" id="p0009r8-pre-2018-11-sandiego-mailing" data-number="1.3"><span class="header-section-number">1.3</span> P0009r8: Pre 2018-11-SanDiego Mailing<a href="#p0009r8-pre-2018-11-sandiego-mailing" class="self-link"></a></h2>
<ul>
<li>Refinement based upon updated <a href="https://github.com/ORNL/cpp-proposals-pub/blob/master/P0009/prototype">prototype</a> / reference implementation</li>
</ul>
<h2 data-number="1.4" id="p0009r7-post-2018-06-rapperswil-mailing" data-number="1.4"><span class="header-section-number">1.4</span> P0009r7: Post 2018-06-Rapperswil Mailing<a href="#p0009r7-post-2018-06-rapperswil-mailing" class="self-link"></a></h2>
<ul>
<li>wording reworked based on guidance: <a href="http://wiki.edg.com/bin/view/Wg21rapperswil2018/LWGSatAM">LWG review at 2018-06-Rapperswil</a></li>
<li>usage of <code>span</code> requires reference to C++20 working draft</li>
<li>namespace for library TS <code>std::experimental::fundamentals_v3</code></li>
</ul>
<h2 data-number="1.5" id="p0009r6-pre-2018-06-rapperswil-mailing" data-number="1.5"><span class="header-section-number">1.5</span> P0009r6 : Pre 2018-06-Rapperswil Mailing<a href="#p0009r6-pre-2018-06-rapperswil-mailing" class="self-link"></a></h2>
<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><b>LEWG Poll</b> We want the ability to customize the access to elements of span (ability to restrict, etc):</p>
<div class="sourceCode" id="cb1"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb1-1"><a href="#cb1-1"></a>span<span class="op">&lt;</span>T, N, Accessor<span class="op">=...&gt;</span></span></code></pre></div>
<table>
<thead>
<tr>
<th>
SF
</th>
<th>
F
</th>
<th>
N
</th>
<th>
A
</th>
<th>
SA
</th>
</tr>
</thead>
<tbody>
<tr>
<td>
1
</td>
<td>
1
</td>
<td>
1
</td>
<td>
2
</td>
<td>
8
</td>
</tr>
</tbody>
</table>
<p><b>LEWG Poll</b> We want the customization of <code>basic_mdspan</code> to be two concepts <code>Mapper</code> and <code>Accessor</code> (akin to <code>Allocator</code> design).</p>
<div class="sourceCode" id="cb2"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb2-1"><a href="#cb2-1"></a>basic_mdspan<span class="op">&lt;</span>T, Extents, Mapper, Accessor<span class="op">&gt;</span></span>
<span id="cb2-2"><a href="#cb2-2"></a>mdspan<span class="op">&lt;</span>T, N<span class="op">...&gt;</span></span></code></pre></div>
<table>
<thead>
<tr>
<th>
SF
</th>
<th>
F
</th>
<th>
N
</th>
<th>
A
</th>
<th>
SA
</th>
</tr>
</thead>
<tbody>
<tr>
<td>
3
</td>
<td>
4
</td>
<td>
5
</td>
<td>
1
</td>
<td>
0
</td>
</tr>
</tbody>
</table>
<p><b>LEWG Poll</b>: We want the customization of <code>basic_mdspan</code> to be an arbitrary (and potentially user-extensible) list of properties.</p>
<div class="sourceCode" id="cb3"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb3-1"><a href="#cb3-1"></a>basic_mdspan<span class="op">&lt;</span>T, Extents, Properties<span class="op">...&gt;</span></span></code></pre></div>
<table>
<thead>
<tr>
<th>
SF
</th>
<th>
F
</th>
<th>
N
</th>
<th>
A
</th>
<th>
SA
</th>
</tr>
</thead>
<tbody>
<tr>
<td>
1
</td>
<td>
2
</td>
<td>
2
</td>
<td>
6
</td>
<td>
2
</td>
</tr>
</tbody>
</table>
<p><b>Changes from P0009r5 due to related LEWG reviews</b>:</p>
<ul>
<li>Replaced variadic property list with <em>extents</em>, <em>layout mapping</em>, and <em>accessor</em> properties.</li>
<li>Incorporated <a href="https://wg21.link/P0454r1">P0454r1</a>.
<ul>
<li>Added accessor policy concept.</li>
<li>Renamed <code>mdspan</code> to <code>basic_mdspan</code>.</li>
<li>Added a <code>mdspan</code> alias to <code>basic_mdspan</code>.</li>
</ul></li>
</ul>
<h2 data-number="1.6" id="p0009r5-pre-2018-03-jacksonville-mailing" data-number="1.6"><span class="header-section-number">1.6</span> P0009r5 : Pre 2018-03-Jacksonville Mailing<a href="#p0009r5-pre-2018-03-jacksonville-mailing" class="self-link"></a></h2>
<p><a href="http://wiki.edg.com/bin/view/Wg21albuquerque/P0009">LEWG review of P0009r4 at 2017-11-Albuquerque meeting</a></p>
<p><b>LEWG Poll</b>: We should be able to index with <code>span&lt;int type[N]&gt;</code> (in addition to array).</p>
<table>
<thead>
<tr>
<th>
SF
</th>
<th>
F
</th>
<th>
N
</th>
<th>
A
</th>
<th>
SA
</th>
</tr>
</thead>
<tbody>
<tr>
<td>
2
</td>
<td>
11
</td>
<td>
1
</td>
<td>
1
</td>
<td>
0
</td>
</tr>
</tbody>
</table>
<p>Against comment - there is not a proven needs for this feature.</p>
<p><b>LEWG Poll</b>: We should be able to index with 1d <code>mdspan</code>.</p>
<table>
<thead>
<tr>
<th>
SF
</th>
<th>
F
</th>
<th>
N
</th>
<th>
A
</th>
<th>
SA
</th>
</tr>
</thead>
<tbody>
<tr>
<td>
0
</td>
<td>
8
</td>
<td>
7
</td>
<td>
0
</td>
<td>
0
</td>
</tr>
</tbody>
</table>
<p><b>LEWG Poll</b>: We should put the requirement on “rank() &lt;= N” back to “rank()==N”.</p>
<p><em>Unanimous consent</em></p>
<p><b>LEWG Poll</b>: 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><b>Changes from P0009r4</b>:</p>
<ul>
<li>Removed nullptr constructor.</li>
<li>Added constexpr to indexing operator.</li>
<li>Indexing operator requires that <code>rank()==sizeof...(indices)</code>.</li>
<li>Fixed typos in examples and moved them to appendix.</li>
<li>Converted note on how extentions to access properties may cause reference to be a proxy type to an “see below” to make it normative.</li>
</ul>
<h2 data-number="1.7" id="p0009r4-pre-2017-11-albuquerque-mailing" data-number="1.7"><span class="header-section-number">1.7</span> P0009r4 : Pre 2017-11-Albuquerque Mailing<a href="#p0009r4-pre-2017-11-albuquerque-mailing" class="self-link"></a></h2>
<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><b>LEWG Poll</b>: Should we have a single template that covers both single and multi-dimensional spans?</p>
<table>
<thead>
<tr>
<th>
SF
</th>
<th>
F
</th>
<th>
N
</th>
<th>
A
</th>
<th>
SA
</th>
</tr>
</thead>
<tbody>
<tr>
<td>
1
</td>
<td>
6
</td>
<td>
2
</td>
<td>
6
</td>
<td>
3
</td>
</tr>
</tbody>
</table>
<p><b>Changes from P0009r3</b>:</p>
<ul>
<li>Align with P0122r5 span <a href="https://wg21.link/P0122r5">proposal</a>.</li>
<li>Rename to <code>mdspan</code>, multidimensional span, to align with <code>span</code>.</li>
<li>Move preferred array extents mechanism to appendix.</li>
<li>Expose codomain as a <code>span</code>.</li>
<li>Add layout mapping concept.</li>
</ul>
<h2 data-number="1.8" id="p0009r3-post-2016-06-oulu-mailing" data-number="1.8"><span class="header-section-number">1.8</span> P0009r3 : Post 2016-06-Oulu Mailing<a href="#p0009r3-post-2016-06-oulu-mailing" class="self-link"></a></h2>
<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>array_ref</code>, and suggested the following alternatives: - <code>sci_span</code> - <code>numeric_span</code> - <code>multidimensional_span</code> - <code>multidim_span</code> - <code>mdspan</code> - <code>md_span</code> - <code>vla_span</code> - <code>multispan</code> - <code>multi_span</code></p>
<p><b>LEWG Poll</b>: Are member <code>begin()</code>/<code>end()</code> still good?</p>
<table>
<thead>
<tr>
<th>
SF
</th>
<th>
F
</th>
<th>
N
</th>
<th>
A
</th>
<th>
SA
</th>
</tr>
</thead>
<tbody>
<tr>
<td>
0
</td>
<td>
2
</td>
<td>
4
</td>
<td>
3
</td>
<td>
1
</td>
</tr>
</tbody>
</table>
<p><b>LEWG Poll</b>: Want this proposal to provide range-producing functions outside <code>array_ref</code>?</p>
<table>
<thead>
<tr>
<th>
SF
</th>
<th>
F
</th>
<th>
N
</th>
<th>
A
</th>
<th>
SA
</th>
</tr>
</thead>
<tbody>
<tr>
<td>
0
</td>
<td>
1
</td>
<td>
3
</td>
<td>
2
</td>
<td>
3
</td>
</tr>
</tbody>
</table>
<p><b>LEWG Poll</b>: Want a separate proposal to explore iteration design space?</p>
<table>
<thead>
<tr>
<th>
SF
</th>
<th>
F
</th>
<th>
N
</th>
<th>
A
</th>
<th>
SA
</th>
</tr>
</thead>
<tbody>
<tr>
<td>
9
</td>
<td>
1
</td>
<td>
0
</td>
<td>
0
</td>
<td>
0
</td>
</tr>
</tbody>
</table>
<p><b>Changes from P0009r2</b>:</p>
<ul>
<li>Removed iterator support; a future paper will be written on the subject.</li>
<li>Noted difference between multidimensional array versus language’s array-of-array-of-array…</li>
<li>Clearly describe requirements for the embedded type aliases (<code>element_type</code>, <code>reference</code>, etc).</li>
<li>Expanded description of how the variadic properties list would work.</li>
<li>Stopped allowing <code>array_ref&lt;T[N]&gt;</code> in addition to <code>array_ref&lt;extents&lt;N&gt;&gt;</code>.</li>
<li>Clarified domain, codomain, and domain -&gt; codomain mapping specifications.</li>
<li>Consistently use <em>extent</em> and <em>extents</em> for the multidimensional index space.</li>
</ul>
<h2 data-number="1.9" id="p0009r2-pre-2016-06-oulu-mailing" data-number="1.9"><span class="header-section-number">1.9</span> P0009r2 : Pre 2016-06-Oulu Mailing<a href="#p0009r2-pre-2016-06-oulu-mailing" class="self-link"></a></h2>
<p><a href="http://wiki.edg.com/bin/view/Wg21jacksonville/P0009">LEWG review at 2016-02-Jacksonville</a>.</p>
<p><b>Changes from P0009r1</b>:</p>
<ul>
<li>Adding details for extensibility of layout mapping.</li>
<li>Move motivation, examples, and relaxed incomplete array type proposal to separate papers.
<ul>
<li><a href="https://wg21.link/P0331">P0331: Motivation and Examples for Polymorphic Multidimensional Array</a>.</li>
<li><a href="https://wg21.link/P0332">P0332: Relaxed Incomplete Multidimensional Array Type Declaration</a>.</li>
</ul></li>
</ul>
<h2 data-number="1.10" id="p0009r1-pre-2016-02-jacksonville-mailing" data-number="1.10"><span class="header-section-number">1.10</span> P0009r1 : Pre 2016-02-Jacksonville Mailing<a href="#p0009r1-pre-2016-02-jacksonville-mailing" class="self-link"></a></h2>
<p><a href="http://wiki.edg.com/bin/view/Wg21kona2015/P0009">LEWG review at 2015-10-Kona</a>.</p>
<p><b>LEWG Poll</b>: What should this feature be called?</p>
<table>
<thead>
<tr>
<th>
Name
</th>
<th>
#
</th>
</tr>
</thead>
<tbody>
<tr>
<td>
<code>view</code>
</td>
<td>
5
</td>
</tr>
<tr>
<td>
<code>span</code>
</td>
<td>
9
</td>
</tr>
<tr>
<td>
<code>array_ref</code>
</td>
<td>
6
</td>
</tr>
<tr>
<td>
<code>slice</code>
</td>
<td>
6
</td>
</tr>
<tr>
<td>
<code>array_view</code>
</td>
<td>
6
</td>
</tr>
<tr>
<td>
<code>ref</code>
</td>
<td>
0
</td>
</tr>
<tr>
<td>
<code>array_span</code>
</td>
<td>
7
</td>
</tr>
<tr>
<td>
<code>basic_span</code>
</td>
<td>
1
</td>
</tr>
<tr>
<td>
<code>object_span</code>
</td>
<td>
3
</td>
</tr>
<tr>
<td>
<code>field</code>
</td>
<td>
0
</td>
</tr>
</tbody>
</table>
<p><b>LEWG Poll</b>: Do we want 0-length static extents?</p>
<table>
<thead>
<tr>
<th>
SF
</th>
<th>
F
</th>
<th>
N
</th>
<th>
A
</th>
<th>
SA
</th>
</tr>
</thead>
<tbody>
<tr>
<td>
3
</td>
<td>
4
</td>
<td>
2
</td>
<td>
3
</td>
<td>
0
</td>
</tr>
</tbody>
</table>
<p><b>LEWG POLL</b>: Do we want the language to support syntaxes like <code>X[3][][][5]</code>?</p>
<table>
<thead>
<tr>
<th>
Syntax
</th>
<th>
#
</th>
</tr>
</thead>
<tbody>
<tr>
<td>
<code>view&lt;int[3][0][][5], property1&gt;</code>
</td>
<td>
12
</td>
</tr>
<tr>
<td>
<code>view&lt;int, dimension&lt;3, 0, dynamic_extent, 5&gt;, property1&gt;</code>
</td>
<td>
4
</td>
</tr>
<tr>
<td>
<code>view&lt;int[3][0][dynamic_extent][5], property1&gt;</code>
</td>
<td>
5
</td>
</tr>
<tr>
<td>
<code>view&lt;int, 3, 0, dynamic_extent, 5, property1&gt;</code>
</td>
<td>
4
</td>
</tr>
<tr>
<td>
<code>view&lt;int, 3, 0, dynamic_extent, 5, properties&lt;property1&gt;&gt;</code>
</td>
<td>
2
</td>
</tr>
<tr>
<td>
<code>view&lt;arr&lt;int, 3, 0, dynamic_extent, 5&gt;, property1&gt;</code>
</td>
<td>
4
</td>
</tr>
<tr>
<td>
<code>view&lt;int[3][0][][5], properties&lt;property1&gt;&gt;</code>
</td>
<td>
9
</td>
</tr>
</tbody>
</table>
<p><b>LEWG POLL</b>: Do we want the variadic property list in template args (either raw or in <code>properties&lt;&gt;</code>)? Note there is no precedence for this in the library.</p>
<table>
<thead>
<tr>
<th>
SF
</th>
<th>
F
</th>
<th>
N
</th>
<th>
A
</th>
<th>
SA
</th>
</tr>
</thead>
<tbody>
<tr>
<td>
3
</td>
<td>
6
</td>
<td>
3
</td>
<td>
0
</td>
<td>
0
</td>
</tr>
</tbody>
</table>
<p><b>LEWG POLL</b>: Do we want the per-view bounds-checking knob?</p>
<table>
<thead>
<tr>
<th>
SF
</th>
<th>
F
</th>
<th>
N
</th>
<th>
A
</th>
<th>
SA
</th>
</tr>
</thead>
<tbody>
<tr>
<td>
3
</td>
<td>
4
</td>
<td>
1
</td>
<td>
2
</td>
<td>
1
</td>
</tr>
</tbody>
</table>
<p><b>Changes from P0009r0</b>:</p>
<ul>
<li>Renamed <code>view</code> to <code>array_ref</code>.</li>
<li>How are users allowed to add properties? Needs elaboration in paper.</li>
<li><code>view&lt;int[][][]&gt;::layout</code> should be named.</li>
<li>Rename <code>is_regular</code> (possibly to <code>is_affine</code>) to avoid overloading the term with the <code>Regular</code> concept.</li>
<li>Make static span(), operator(), constructor, etc variadic.</li>
<li>Demonstrate the need for improper access in the paper.</li>
<li>In <code>operator()</code>, take integral types by value.</li>
</ul>
<h2 data-number="1.11" id="p0009r0-pre-2015-10-kona-mailing" data-number="1.11"><span class="header-section-number">1.11</span> P0009r0 : Pre 2015-10-Kona Mailing<a href="#p0009r0-pre-2015-10-kona-mailing" class="self-link"></a></h2>
<p>Original non-owning multidimensional array reference (<code>view</code>) paper with motivation, specification, and examples.</p>
<h2 data-number="1.12" id="related-activity" data-number="1.12"><span class="header-section-number">1.12</span> Related Activity<a href="#related-activity" class="self-link"></a></h2>
<p>Related <a href="http://wiki.edg.com/bin/view/Wg21albuquerque/P0546">LEWG review of P0546r1 at 2017-11-Albuquerque meeting</a></p>
<p><b>LEWG Poll</b>: <code>span</code> should specify the dynamic extent as the element type of the first template parameter rather than the (current) second template parameter</p>
<table>
<thead>
<tr>
<th>
SF
</th>
<th>
F
</th>
<th>
N
</th>
<th>
A
</th>
<th>
SA
</th>
</tr>
</thead>
<tbody>
<tr>
<td>
5
</td>
<td>
3
</td>
<td>
2
</td>
<td>
2
</td>
<td>
0
</td>
</tr>
</tbody>
</table>
<p><b>LEWG Poll</b>: <code>span</code> should support the addition of access properties variadic template parameters</p>
<table>
<thead>
<tr>
<th>
SF
</th>
<th>
F
</th>
<th>
N
</th>
<th>
A
</th>
<th>
SA
</th>
</tr>
</thead>
<tbody>
<tr>
<td>
0
</td>
<td>
10
</td>
<td>
1
</td>
<td>
5
</td>
<td>
0
</td>
</tr>
</tbody>
</table>
<p>Authors agreed to bring a separate paper ([[P0900r0]]) discussing how the variadic properties will work.</p>
<h1 data-number="2" id="description" data-number="2"><span class="header-section-number">2</span> Description<a href="#description" class="self-link"></a></h1>
<p>The proposed polymorphic multidimensional array reference (<code>mdspan</code>) defines types and functions for mapping multidimensional indices in its <em>domain</em>, a multidimensional index space, to the <code>mdspan</code>’s <em>codomain</em>, elements of a contiguous span of objects. A <em>multidimensional index space</em> of <em>rank</em> <math>R</math> is the Cartesian product <math>[0, N<sub>0</sub>) ⨯ [0, N<sub>1</sub>) ⨯ … ⨯ <a href="http://wg21.link/p0367">0, N<sub>R-1</sub>)</math> of half-open integer intervals. A <em>multidimensional index</em> is a element of a multidimensional index space. An <code>mdspan</code> has two policies: the <em>layout mapping</em> and the <em>accessor</em>. The layout mapping specifies the formula, and properties of the formula, for mapping a multidimensional 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, [P0367</a> proposed a rich set of potential access properties.</p>
<p><b>A multidimensional array is not an array-of-array-of-array-of…</b></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 multidimensional indices to element objects.</p>
<p><b>Optimized Implementation of Layout Mapping</b></p>
<p>We intend the layout mapping of a multidimensional index to be a constant-time <code>constexpr</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 multidimensional index layout mappings when indices are loop invariant.</p>
<h1 data-number="3" id="editing-notes" data-number="3"><span class="header-section-number">3</span> Editing Notes<a href="#editing-notes" class="self-link"></a></h1>
<p>The proposed changes are relative to the working draft of the standard as of <a href="http://wg21.link/n4842">N4842</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>&lt;mdspan&gt;</code> to the “C++ library headers” table in <b>[headers]</b> in a place that respects the table’s current alphabetic order.</p>
<p>Add the header <code>&lt;mdspan&gt;</code> to the “Containers library summary” table in <b>[containers.general]</b> below the listing for <code>&lt;span&gt;</code>.</p>
<!--

 /$$      /$$                           /$$ /$$
| $$  /$ | $$                          | $$|__/
| $$ /$$$| $$  /$$$$$$   /$$$$$$   /$$$$$$$ /$$ /$$$$$$$   /$$$$$$
| $$/$$ $$ $$ /$$__  $$ /$$__  $$ /$$__  $$| $$| $$__  $$ /$$__  $$
| $$$$_  $$$$| $$  \ $$| $$  \__/| $$  | $$| $$| $$  \ $$| $$  \ $$
| $$$/ \  $$$| $$  | $$| $$      | $$  | $$| $$| $$  | $$| $$  | $$
| $$/   \  $$|  $$$$$$/| $$      |  $$$$$$$| $$| $$  | $$|  $$$$$$$
|__/     \__/ \______/ |__/       \_______/|__/|__/  |__/ \____  $$
                                                          /$$  \ $$
                                                         |  $$$$$$/
                                                          \______/
-->
<h1 data-number="4" id="wording" data-number="4"><span class="header-section-number">4</span> Wording<a href="#wording" class="self-link"></a></h1>
<blockquote>
<p><em>The � character is used to denote a placeholder section number which the editor shall determine.</em></p>
</blockquote>
<blockquote>
<p><em>Make the following changes to 22.7.1 <b>[views.general]</b></em>,</p>
</blockquote>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> The header <code>&lt;span&gt;</code> defines the view span. <span class="add" style="color: #006e28"><ins>The header <span><code>&lt;mdspan&gt;</code></span> defines the view <span><code>basic_mdspan</code></span>, the type alias <span><code>mdspan</code></span>, and other facilities for interacting with these views.</ins></span></p>
<hr />
<blockquote>
<p><em>Add the following subclauses to the end of the <b>[views]</b> subclause (after <code>span</code>):</em></p>
</blockquote>
<!--
 .d8888b.                                               d8b
d88P  Y88b                                              Y8P
Y88b.
 "Y888b.   888  888 88888b.   .d88b.  88888b.  .d8888b  888 .d8888b
    "Y88b. 888  888 888 "88b d88""88b 888 "88b 88K      888 88K
      "888 888  888 888  888 888  888 888  888 "Y8888b. 888 "Y8888b.
Y88b  d88P Y88b 888 888  888 Y88..88P 888 d88P      X88 888      X88
 "Y8888P"   "Y88888 888  888  "Y88P"  88888P"   88888P' 888  88888P'
                888                   888
           Y8b d88P                   888
            "Y88P"                    888
-->
<p><br /> <b>22.7.� Header <code>&lt;mdspan&gt;</code> synopsis [mdspan.syn]</b></p>
<div class="sourceCode" id="cb4"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb4-1"><a href="#cb4-1"></a><span class="kw">namespace</span> std <span class="op">{</span></span>
<span id="cb4-2"><a href="#cb4-2"></a>  <span class="co">// [mdspan.extents], class template extents</span></span>
<span id="cb4-3"><a href="#cb4-3"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="dt">ptrdiff_t</span><span class="op">...</span> Extents<span class="op">&gt;</span></span>
<span id="cb4-4"><a href="#cb4-4"></a>    <span class="kw">class</span> extents;</span>
<span id="cb4-5"><a href="#cb4-5"></a></span>
<span id="cb4-6"><a href="#cb4-6"></a>  <span class="co">// [mdspan.layout], Layout mapping policies</span></span>
<span id="cb4-7"><a href="#cb4-7"></a>  <span class="kw">class</span> layout_left;</span>
<span id="cb4-8"><a href="#cb4-8"></a>  <span class="kw">class</span> layout_right;</span>
<span id="cb4-9"><a href="#cb4-9"></a>  <span class="kw">class</span> layout_stride;</span>
<span id="cb4-10"><a href="#cb4-10"></a></span>
<span id="cb4-11"><a href="#cb4-11"></a>  <span class="co">// [mdspan.accessor.basic]</span></span>
<span id="cb4-12"><a href="#cb4-12"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> ElementType<span class="op">&gt;</span></span>
<span id="cb4-13"><a href="#cb4-13"></a>    <span class="kw">class</span> accessor_basic;</span>
<span id="cb4-14"><a href="#cb4-14"></a></span>
<span id="cb4-15"><a href="#cb4-15"></a>  <span class="co">// [mdspan.basic], class template mdspan</span></span>
<span id="cb4-16"><a href="#cb4-16"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> ElementType, <span class="kw">class</span> Extents, <span class="kw">class</span> LayoutPolicy <span class="op">=</span> layout_right,</span>
<span id="cb4-17"><a href="#cb4-17"></a>           <span class="kw">class</span> AccessorPolicy <span class="op">=</span> accessor_basic<span class="op">&lt;</span>ElementType<span class="op">&gt;&gt;</span></span>
<span id="cb4-18"><a href="#cb4-18"></a>    <span class="kw">class</span> basic_mdspan;</span>
<span id="cb4-19"><a href="#cb4-19"></a></span>
<span id="cb4-20"><a href="#cb4-20"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> T, <span class="dt">ptrdiff_t</span><span class="op">...</span> Extents<span class="op">&gt;</span></span>
<span id="cb4-21"><a href="#cb4-21"></a>    <span class="kw">using</span> mdspan <span class="op">=</span> basic_mdspan<span class="op">&lt;</span>T, extents<span class="op">&lt;</span>Extents<span class="op">...&gt;&gt;</span>;</span>
<span id="cb4-22"><a href="#cb4-22"></a></span>
<span id="cb4-23"><a href="#cb4-23"></a>  <span class="co">// [mdspan.extents.compare], extents comparison operators</span></span>
<span id="cb4-24"><a href="#cb4-24"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="dt">ptrdiff_t</span><span class="op">...</span> LHS, <span class="dt">ptrdiff_t</span><span class="op">...</span> RHS<span class="op">&gt;</span></span>
<span id="cb4-25"><a href="#cb4-25"></a>    <span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> extents<span class="op">&lt;</span>LHS<span class="op">...&gt;&amp;</span>,</span>
<span id="cb4-26"><a href="#cb4-26"></a>                              <span class="kw">const</span> extents<span class="op">&lt;</span>RHS<span class="op">...&gt;&amp;)</span> <span class="kw">noexcept</span>;</span>
<span id="cb4-27"><a href="#cb4-27"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="dt">ptrdiff_t</span><span class="op">...</span> LHS, <span class="dt">ptrdiff_t</span><span class="op">...</span> RHS<span class="op">&gt;</span></span>
<span id="cb4-28"><a href="#cb4-28"></a>    <span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">!=(</span><span class="kw">const</span> extents<span class="op">&lt;</span>LHS<span class="op">...&gt;&amp;</span>, </span>
<span id="cb4-29"><a href="#cb4-29"></a>                              <span class="kw">const</span> extents<span class="op">&lt;</span>RHS<span class="op">...&gt;&amp;)</span> <span class="kw">noexcept</span></span>
<span id="cb4-30"><a href="#cb4-30"></a>    <span class="op">{</span> <span class="cf">return</span> <span class="op">!(</span>lhs <span class="op">==</span> rhs<span class="op">)</span>; <span class="op">}</span></span>
<span id="cb4-31"><a href="#cb4-31"></a></span>
<span id="cb4-32"><a href="#cb4-32"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> ElementType, <span class="kw">class</span> Extents, <span class="kw">class</span> LayoutPolicy,</span>
<span id="cb4-33"><a href="#cb4-33"></a>           <span class="kw">class</span> AccessorPolicy, <span class="kw">class</span><span class="op">...</span> SliceSpecifiers<span class="op">&gt;</span></span>
<span id="cb4-34"><a href="#cb4-34"></a>    basic_mdspan<span class="op">&lt;</span><em>see below</em><span class="op">&gt;</span> subspan<span class="op">(</span><span class="kw">const</span> basic_mdspan<span class="op">&lt;</span>ElementType,</span>
<span id="cb4-35"><a href="#cb4-35"></a>                                        Extents, LayoutPolicy, AccessorPolicy<span class="op">&gt;&amp;</span>,</span>
<span id="cb4-36"><a href="#cb4-36"></a>                                        SliceSpecifiers <span class="op">...)</span> <span class="kw">noexcept</span>;</span>
<span id="cb4-37"><a href="#cb4-37"></a></span>
<span id="cb4-38"><a href="#cb4-38"></a>  <span class="co">// tag supporting subspan</span></span>
<span id="cb4-39"><a href="#cb4-39"></a>  <span class="kw">struct</span> all_type <span class="op">{</span> <span class="kw">explicit</span> all_type<span class="op">()</span> <span class="op">=</span> <span class="cf">default</span>; <span class="op">}</span>;</span>
<span id="cb4-40"><a href="#cb4-40"></a>  <span class="kw">inline</span> <span class="kw">constexpr</span> all_type all <span class="op">=</span> all_type<span class="op">{}</span>;</span>
<span id="cb4-41"><a href="#cb4-41"></a><span class="op">}</span></span></code></pre></div>
<p><b>22.7.� Overview [mdspan.overview]</b></p>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> A <em>multidimensional index space</em> is a Cartesian product of integer intervals. Each interval can be represented by a half-open range <span class="math inline">[<em>I</em><sub><em>b</em></sub>, <em>I</em><sub><em>e</em></sub>)</span>, where <span class="math inline"><em>I</em><sub><em>b</em></sub></span> and <span class="math inline"><em>I</em><sub><em>e</em></sub></span> are the lower and upper bounds of the <span class="math inline"><em>i</em><sup><em>t</em><em>h</em></sup></span> dimension. The <em>rank</em> of a multidimensional index space is the number of intervals it represents.</p>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> A <em>multidimensional index</em> is an element within the a multidimensional index space and can be represented as a pack of integer types. The multidimensional index <code>idx...</code> refers to an element within the domain of a multidimensional index space if both the following are true:</p>
<ul>
<li><p><span class="marginalizedparent"><a class="marginalized">(2.1)</a></span> <code>sizeof...(idx)</code> is equal to rank, and</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">(2.2)</a></span> For all <span class="math inline"><em>i</em></span> in the range <span class="math inline">[0,</span>rank<span class="math inline">)</span>, the <span class="math inline"><em>i</em><sup><em>t</em><em>h</em></sup></span> value of <code>idx</code> is in the range <span class="math inline">[<em>I</em><sub><em>b</em></sub>, <em>I</em><sub><em>e</em></sub>)</span>.</p></li>
</ul>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span> For the following subsections, let <span class="math inline"><em>r</em></span> be a value in the range <span class="math inline">[0,</span>rank<span class="math inline">)</span>.</p>
<!--
                  888                     888
                  888                     888
                  888                     888
 .d88b.  888  888 888888 .d88b.  88888b.  888888 .d8888b
d8P  Y8b `Y8bd8P' 888   d8P  Y8b 888 "88b 888    88K
88888888   X88K   888   88888888 888  888 888    "Y8888b.
Y8b.     .d8""8b. Y88b. Y8b.     888  888 Y88b.       X88
 "Y8888  888  888  "Y888 "Y8888  888  888  "Y888  88888P'


-->
<p><b>22.7.� Class template <code>extents</code> [mdspan.extents]</b></p>
<p><b>22.7.�.1 Overview [mdspan.extents.syn]</b></p>
<div class="sourceCode" id="cb5"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb5-1"><a href="#cb5-1"></a><span class="kw">namespace</span> std <span class="op">{</span></span>
<span id="cb5-2"><a href="#cb5-2"></a></span>
<span id="cb5-3"><a href="#cb5-3"></a><span class="kw">template</span><span class="op">&lt;</span><span class="dt">ptrdiff_t</span><span class="op">...</span> Extents<span class="op">&gt;</span></span>
<span id="cb5-4"><a href="#cb5-4"></a><span class="kw">class</span> extents <span class="op">{</span></span>
<span id="cb5-5"><a href="#cb5-5"></a><span class="kw">public</span><span class="op">:</span></span>
<span id="cb5-6"><a href="#cb5-6"></a>  <span class="kw">using</span> index_type <span class="op">=</span> <span class="dt">ptrdiff_t</span>;</span>
<span id="cb5-7"><a href="#cb5-7"></a></span>
<span id="cb5-8"><a href="#cb5-8"></a>  <span class="co">// [mdspan.extents.cons], Constructors and assignment</span></span>
<span id="cb5-9"><a href="#cb5-9"></a>  <span class="kw">constexpr</span> extents<span class="op">()</span> <span class="kw">noexcept</span> <span class="op">=</span> <span class="cf">default</span>;</span>
<span id="cb5-10"><a href="#cb5-10"></a>  <span class="kw">constexpr</span> extents<span class="op">(</span><span class="kw">const</span> extents<span class="op">&amp;)</span> <span class="kw">noexcept</span> <span class="op">=</span> <span class="cf">default</span>;</span>
<span id="cb5-11"><a href="#cb5-11"></a>  <span class="kw">constexpr</span> extents<span class="op">&amp;</span> <span class="kw">operator</span><span class="op">=(</span><span class="kw">const</span> extents<span class="op">&amp;)</span> <span class="kw">noexcept</span> <span class="op">=</span> <span class="cf">default</span>;</span>
<span id="cb5-12"><a href="#cb5-12"></a></span>
<span id="cb5-13"><a href="#cb5-13"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="dt">ptrdiff_t</span><span class="op">...</span> OtherExtents<span class="op">&gt;</span></span>
<span id="cb5-14"><a href="#cb5-14"></a>    <span class="kw">constexpr</span> extents<span class="op">(</span><span class="kw">const</span> extents<span class="op">&lt;</span>OtherExtents<span class="op">...&gt;&amp;)</span> <span class="kw">noexcept</span>;</span>
<span id="cb5-15"><a href="#cb5-15"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span><span class="op">...</span> IndexType<span class="op">&gt;</span></span>
<span id="cb5-16"><a href="#cb5-16"></a>    <span class="kw">constexpr</span> extents<span class="op">(</span>IndexType<span class="op">...)</span> <span class="kw">noexcept</span>;</span>
<span id="cb5-17"><a href="#cb5-17"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> IndexType<span class="op">&gt;</span></span>
<span id="cb5-18"><a href="#cb5-18"></a>    <span class="kw">constexpr</span> extents<span class="op">(</span><span class="kw">const</span> array<span class="op">&lt;</span>IndexType, rank_dynamic<span class="op">()&gt;&amp;)</span> <span class="kw">noexcept</span>;</span>
<span id="cb5-19"><a href="#cb5-19"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="dt">ptrdiff_t</span><span class="op">...</span> OtherExtents<span class="op">&gt;</span></span>
<span id="cb5-20"><a href="#cb5-20"></a>    <span class="kw">constexpr</span> extents<span class="op">&amp;</span> <span class="kw">operator</span><span class="op">=(</span><span class="kw">const</span> extents<span class="op">&lt;</span>OtherExtents<span class="op">...&gt;&amp;)</span> <span class="kw">noexcept</span>;</span>
<span id="cb5-21"><a href="#cb5-21"></a></span>
<span id="cb5-22"><a href="#cb5-22"></a>  <span class="co">// [mdspan.extents.obs], Observers of the domain multidimensional index space</span></span>
<span id="cb5-23"><a href="#cb5-23"></a>  <span class="kw">static</span> <span class="kw">constexpr</span> <span class="dt">size_t</span> rank<span class="op">()</span> <span class="kw">noexcept</span> <span class="op">{</span> <span class="cf">return</span> <span class="kw">sizeof</span><span class="op">...(</span>Extents<span class="op">)</span>; <span class="op">}</span></span>
<span id="cb5-24"><a href="#cb5-24"></a>  <span class="kw">static</span> <span class="kw">constexpr</span> <span class="dt">size_t</span> rank_dynamic<span class="op">()</span> <span class="kw">noexcept</span> </span>
<span id="cb5-25"><a href="#cb5-25"></a>    <span class="op">{</span> <span class="cf">return</span> <span class="op">(</span><span class="dt">size_t</span><span class="op">(</span>Extents <span class="op">==</span> dynamic_extent<span class="op">)</span> <span class="op">+</span> <span class="op">...)</span>; <span class="op">}</span></span>
<span id="cb5-26"><a href="#cb5-26"></a>  <span class="kw">static</span> <span class="kw">constexpr</span> index_type static_extent<span class="op">(</span><span class="dt">size_t</span><span class="op">)</span> <span class="kw">noexcept</span></span>
<span id="cb5-27"><a href="#cb5-27"></a>    <span class="op">{</span> <span class="cf">return</span> rank<span class="op">()</span> <span class="op">-</span> rank_dynamic<span class="op">()</span>; <span class="op">}</span> </span>
<span id="cb5-28"><a href="#cb5-28"></a>  <span class="kw">constexpr</span> index_type extent<span class="op">(</span><span class="dt">size_t</span><span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb5-29"><a href="#cb5-29"></a></span>
<span id="cb5-30"><a href="#cb5-30"></a><span class="kw">private</span><span class="op">:</span></span>
<span id="cb5-31"><a href="#cb5-31"></a>  <span class="kw">static</span> <span class="kw">constexpr</span> <span class="dt">size_t</span> dynamic_index<span class="op">(</span><span class="dt">size_t</span><span class="op">)</span> <span class="kw">noexcept</span>; <span class="co">// <em>exposition only</em></span></span>
<span id="cb5-32"><a href="#cb5-32"></a>  array<span class="op">&lt;</span>index_type, rank_dynamic<span class="op">()&gt;</span> dynamic_extents_<span class="op">{}</span>; <span class="co">// <em>exposition only</em></span></span>
<span id="cb5-33"><a href="#cb5-33"></a><span class="op">}</span>;</span>
<span id="cb5-34"><a href="#cb5-34"></a></span>
<span id="cb5-35"><a href="#cb5-35"></a><span class="op">}</span></span></code></pre></div>
<p><b>22.7.�.2 Overview [mdspan.extents.overview]</b></p>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> The class template <code>extents</code> represents a multidimensional index space of of rank equal to <code>sizeof...(Extents)</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> For all <span class="math inline"><em>r</em></span>, let <span class="math inline"><em>E</em><sub><em>r</em></sub></span> be the value of the <span class="math inline"><em>r</em><sup><em>t</em><em>h</em></sup></span> parameter in the template parameter pack <code>Extents</code>. Each <span class="math inline"><em>E</em><sub><em>r</em></sub></span> shall either be a non-negative integer or <code>dynamic_extent</code>, otherwise, the program is ill-formed.</p>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span> <span class="math inline"><em>E</em><sub><em>r</em></sub></span> is a <em>dymnamic extent</em> if it is equal to <code>dynamic_extent</code>, otherwise <span class="math inline"><em>E</em><sub><em>r</em></sub></span> is a <em>static extent</em>. For each <span class="math inline"><em>E</em><sub><em>r</em></sub></span> equivalent to <code>dynamic_extent</code>,<br />
the upper bound of the interval is stored in the exposition only array <code>dynamic_extents_</code> at <code>dynamic_extents_[dynamic_index(</code><em>r</em><code>)]</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">4</a></span> If <span class="math inline"><em>E</em><sub><em>r</em></sub></span> is a dynamic extent, let <span class="math inline"><em>D</em><sub><em>r</em></sub></span> be the value of <code>dynamic_extents_[dynamic_index(</code><em>r</em><code>)]</code>. The <span class="math inline"><em>r</em><sup><em>t</em><em>h</em></sup></span> interval of an <code>extents</code> is as follows:</p>
<ul>
<li><p><span class="marginalizedparent"><a class="marginalized">(4.1)</a></span> <span class="math inline">[0, <em>E</em><sub><em>r</em></sub>)</span> if <span class="math inline"><em>E</em><sub><em>r</em></sub></span> is a static extent,</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">(4.2)</a></span> otherwise <span class="math inline">[0, <em>D</em><sub><em>r</em></sub>)</span>.</p></li>
</ul>
<hr />
<div class="sourceCode" id="cb6"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb6-1"><a href="#cb6-1"></a><span class="kw">constexpr</span> <span class="dt">size_t</span> dynamic_index<span class="op">(</span><span class="dt">size_t</span> i<span class="op">)</span> <span class="kw">noexcept</span>; <span class="co">// <em>exposition only</em></span></span></code></pre></div>
<ul>
<li><span class="marginalizedparent"><a class="marginalized">5</a></span> <em>Returns</em>: If <code>i &lt;= sizeof...(Extents)</code> is <code>true</code>, returns the number of arguments before the <code>i</code><em>th</em> template parameter in the template parameter pack <code>Extents</code> equivalent to <code>dynamic_extent</code>. Otherwise, returns <code>rank_dynamic()</code>.</li>
</ul>
<p><b>22.7.�.3 Constructors and assignment [mdspan.extents.cons]</b></p>
<div class="sourceCode" id="cb7"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb7-1"><a href="#cb7-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="dt">ptrdiff_t</span><span class="op">...</span> OtherExtents<span class="op">&gt;</span></span>
<span id="cb7-2"><a href="#cb7-2"></a>  <span class="kw">constexpr</span> extents<span class="op">(</span><span class="kw">const</span> extents<span class="op">&lt;</span>OtherExtents<span class="op">...&gt;&amp;</span> other<span class="op">)</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<ul>
<li><p><span class="marginalizedparent"><a class="marginalized">1</a></span> <em>Constraints:</em></p>
<ul>
<li><p><span class="marginalizedparent"><a class="marginalized">(1.1)</a></span> <code>sizeof...(OtherExtents)</code> equals <code>rank()</code>.</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">(1.2)</a></span> For all <code>r</code> where <code>static_extent(r) != dynamic_extent</code> and <code>other.static_extent(r) != dynamic_extent</code> are both <code>true</code>, <code>static_extent(r) == other.static_extent(r)</code> is <code>true</code>.</p></li>
</ul></li>
<li><p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Expects:</em> For all <code>r</code> <code>static_extent(r) == dynamic_extent || static_extent(r) == other.extent(r)</code> is <code>true</code>.</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">3</a></span> <em>Effects:</em> For each <code>r</code> where <code>static_extent(r) == dynamic_extent</code> is <code>true</code>, assigns <code>other.extent(r)</code> to <code>dynamic_extent[dynamic_index(r)]</code>.</p></li>
</ul>
<p><br /></p>
<div class="sourceCode" id="cb8"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb8-1"><a href="#cb8-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span><span class="op">...</span> IndexType<span class="op">&gt;</span></span>
<span id="cb8-2"><a href="#cb8-2"></a>  <span class="kw">constexpr</span> extents<span class="op">(</span>IndexType<span class="op">...</span> dynamic<span class="op">)</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<ul>
<li><p><span class="marginalizedparent"><a class="marginalized">4</a></span> <em>Constraints:</em></p>
<ul>
<li><p><span class="marginalizedparent"><a class="marginalized">(4.1)</a></span> <code>(is_convertible_v&lt;IndexType, index_type&gt; &amp;&amp; ...)</code> is <code>true</code>, and</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">(4.2)</a></span> <code>sizeof...(IndexType) == rank_dynamic()</code> is <code>true</code>.</p></li>
</ul></li>
<li><p><span class="marginalizedparent"><a class="marginalized">5</a></span> <em>Expects:</em> <code>((dynamic &gt;= 0) &amp;&amp; ...)</code> is <code>true</code>.</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">6</a></span> <em>Effects:</em> Initializes <code>dynamic_extents_</code> with <code>dynamic...</code>.</p></li>
</ul>
<div class="sourceCode" id="cb9"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb9-1"><a href="#cb9-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> IndexType<span class="op">&gt;</span></span>
<span id="cb9-2"><a href="#cb9-2"></a><span class="kw">constexpr</span> extents<span class="op">(</span><span class="kw">const</span> array<span class="op">&lt;</span>IndexType, rank_dynamic<span class="op">()&gt;</span> <span class="op">&amp;</span> dynamic<span class="op">)</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<ul>
<li><p><span class="marginalizedparent"><a class="marginalized">7</a></span> <em>Constraints:</em> <code>is_convertible_v&lt;IndexType, index_type&gt;</code> is <code>true</code>.</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">8</a></span> <em>Expects:</em> <code>dynamic[i] &gt;= 0</code> is <code>true</code> for all <code>i</code> in the range <code>[0, rank_dynamic())</code>.</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">9</a></span> <em>Effects:</em> Initializes <code>dynamic_extents_</code> with <code>dynamic</code>.</p></li>
</ul>
<div class="sourceCode" id="cb10"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb10-1"><a href="#cb10-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="dt">ptrdiff_t</span><span class="op">...</span> OtherExtents<span class="op">&gt;</span></span>
<span id="cb10-2"><a href="#cb10-2"></a><span class="kw">constexpr</span> extents<span class="op">&amp;</span> <span class="kw">operator</span><span class="op">=(</span><span class="kw">const</span> extents<span class="op">&lt;</span>OtherExtents<span class="op">...&gt;&amp;</span> other<span class="op">)</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<ul>
<li><p><span class="marginalizedparent"><a class="marginalized">10</a></span> <em>Constraints:</em></p>
<ul>
<li><p><span class="marginalizedparent"><a class="marginalized">(10.1)</a></span> <code>sizeof...(OtherExtents)</code> equals <code>rank()</code>.</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">(10.2)</a></span> For all <code>r</code> where <code>static_extent(r) != dynamic_extent</code> and <code>other.static_extent(r) != dynamic_extent</code> are both <code>true</code>, <code>static_extent(r) == other.static_extent(r)</code> is <code>true</code>.</p></li>
</ul></li>
<li><p><span class="marginalizedparent"><a class="marginalized">11</a></span> <em>Expects:</em> For all <code>r</code> <code>static_extent(r) == dynamic_extent || static_extent(r) == other.extent(r)</code> is <code>true</code>.</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">12</a></span> <em>Effects:</em> For each <code>r</code> where <code>static_extent(r) == dynamic_extent</code> is <code>true</code>, assigns <code>other.extent(r)</code> to <code>dynamic_extent[dynamic_index(r)]</code>.</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">13</a></span> <em>Returns:</em> <code>*this</code>.</p></li>
</ul>
<p><br /> <b>22.7.�.3 Observers of the domain multidimensional index space [mdspan.extents.obs]</b></p>
<div class="sourceCode" id="cb11"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb11-1"><a href="#cb11-1"></a><span class="kw">constexpr</span> index_type extent<span class="op">(</span><span class="dt">size_t</span> i<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<ul>
<li><p><span class="marginalizedparent"><a class="marginalized">1</a></span> <em>Expects:</em> <code>i &lt; rank()</code> is <code>true</code>.</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Returns:</em> <code>dynamic_extents_[dynamic_index(i)]</code> if <code>static_extent(i) == dynamic_extent</code> is <code>true</code>, otherwise <code>static_extent(i)</code>.</p></li>
</ul>
<p><br /> <b>22.7.�.4 <code>extents</code> comparison operators [mdspan.extents.compare]</b></p>
<div class="sourceCode" id="cb12"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb12-1"><a href="#cb12-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="dt">ptrdiff_t</span><span class="op">...</span> LHS, <span class="dt">ptrdiff_t</span><span class="op">...</span> RHS<span class="op">&gt;</span></span>
<span id="cb12-2"><a href="#cb12-2"></a>  <span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> extents<span class="op">&lt;</span>LHS<span class="op">...&gt;&amp;</span> lhs, <span class="kw">const</span> extents<span class="op">&lt;</span>RHS<span class="op">...&gt;&amp;</span> rhs<span class="op">)</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<ul>
<li><span class="marginalizedparent"><a class="marginalized">1</a></span> <em>Returns:</em> true if <code>lhs.rank()</code> equals <code>rhs.rank()</code> and <code>lhs.extents(r)</code> equals <code>rhs.extents(r)</code> for all <code>r</code>, otherwise <code>false</code>.</li>
</ul>
<!--
888                                     888                                                  d8b
888                                     888                                                  Y8P
888                                     888
888  8888b.  888  888  .d88b.  888  888 888888      88888b.d88b.   8888b.  88888b.  88888b.  888 88888b.   .d88b.
888     "88b 888  888 d88""88b 888  888 888         888 "888 "88b     "88b 888 "88b 888 "88b 888 888 "88b d88P"88b
888 .d888888 888  888 888  888 888  888 888         888  888  888 .d888888 888  888 888  888 888 888  888 888  888
888 888  888 Y88b 888 Y88..88P Y88b 888 Y88b.       888  888  888 888  888 888 d88P 888 d88P 888 888  888 Y88b 888
888 "Y888888  "Y88888  "Y88P"   "Y88888  "Y888      888  888  888 "Y888888 88888P"  88888P"  888 888  888  "Y88888
                  888                                                      888      888                        888
             Y8b d88P                                                      888      888                   Y8b d88P
              "Y88P"                                                       888      888                    "Y88P"
-->
<p><br /> <br /> <b>22.7.� Layout mapping policy [mdspan.layout]</b></p>
<p><b>22.7.�.1 Layout mapping requirements [mdspan.layout.reqs]</b></p>
<ol type="1">
<li><p>A <em>layout mapping policy</em> is a class that contains a <em>layout mapping</em>, a nested class template.</p></li>
<li><p>A layout mapping policy and its layout mapping nested class template meet the requirements in Table �.</p></li>
<li><p>A layout mapping meets the requirements of <em>Cpp17DefaultConstructible</em>, <em>Cpp17CopyAssignable</em>, and <em>Cpp17EqualityComparable</em>.</p></li>
<li><p>In Table �:</p>
<ul>
<li><code>MP</code> denotes a layout mapping policy.</li>
<li><code>M</code> denotes a specialization of the layout mapping policy’s nested layout mapping template class.</li>
<li><code>E</code> denotes a specialization of <code>extents</code>.</li>
<li><code>e</code> denotes an object of type <code>E</code>.</li>
<li><code>m</code> denotes an object of type <code>M</code>.</li>
<li><code>i...</code> and <code>j...</code> are multidimensional indices in the multidimensional index space defined by <code>e</code>.</li>
<li><code>r</code> is an integral value in the range <code>[0, e.rank())</code>.</li>
<li><code>dr...</code> is an integer pack where <code>sizeof...(dr) == e.rank()</code> is <code>true</code> and the <code>r</code>th element is equal to <code>1</code> and all other elements are <code>0</code>.</li>
</ul></li>
</ol>
Table � — Layout mapping policy and layout mapping requirements
<table border="1">
<tr>
<th>
Expression
</th>
<th>
Return Type
</th>
<th>
Returns
</th>
<th>
Expects
</th>
</tr>
<tr>
<td>
<code>MP::template mapping&lt;E&gt;</code>
</td>
<td>
<code>M</code>
</td>
<td>
</td>
<td>
</td>
</tr>
<tr>
<td>
<code>m.extents()</code>
</td>
<td>
<code>E</code>
</td>
<td>
<em>Returns:</em> <code>e</code>.
</td>
<td>
</td>
</tr>
<tr>
<td>
<code>m(i...)</code>
</td>
<td>
<code>E::index_type</code>
</td>
<td>
<em>Returns:</em> A value in the range of <span class="math inline">[0,</span> <code>requried_span_size()</code> <span class="math inline">)</span> defined by applying the layout mapping to a multidimensional index <code>i...</code>.
</td>
<td>
<em>Expects:</em><br /> <span class="math inline">0 ≤</span> <code>array{i...}[r]</code> <span class="math inline">&lt;</span> <code>extents().extent(r)</code> for all <code>r</code> in the range <span class="math inline">[0,</span> <code>Extents::rank()</code> <span class="math inline">)</span>.
</td>
</tr>
<tr>
<td>
<code>m.required_span_size()</code>
</td>
<td>
<code>E::index_type</code>
</td>
<td>
<em>Returns:</em> If the multidimensional index space that <code>e</code> defines is empty, then zero, else 1 plus the maximum value of <code>m(i...)</code> for all <code>i...</code> in <code>e</code>.
</td>
<td>
</td>
</tr>
<tr>
<td>
<code>m.is_unique()</code>
</td>
<td>
<code>bool</code>
</td>
<td>
<em>Returns:</em> <code>true</code> if for every <code>i...</code> and <code>j...</code> where <code>i != j || ...</code> is <code>true</code>, <code>m(i...) != m(j...)</code> is <code>true</code>.
</td>
<td>
</td>
</tr>
<tr>
<td>
<code>m.is_contiguous()</code>
</td>
<td>
<code>bool</code>
</td>
<td>
<em>Returns:</em> <code>true</code> if for all <span class="math inline"><em>k</em></span> in the range <span class="math inline">[0,</span> <code>m.required_span_size()</code> <span class="math inline">)</span> there exists an <code>i...</code> such that <code>m(i...)</code> equals <span class="math inline"><em>k</em></span>, otherwise <code>false</code>.
</td>
<td>
</td>
</tr>
<tr>
<td>
<code>m.is_strided()</code>
</td>
<td>
<code>bool</code>
</td>
<td>
<em>Returns:</em> <code>true</code> if for every <code>r</code> there exists an integer <code>sr</code> such that, for all <code>j...</code> and <code>i...</code> in <code>e</code>, where <code>j...</code> equals <code>(i+dr)...</code> <code>m(j...) - m(i...)</code> equals <code>sr</code>. Otherwise, <code>false</code>.
</td>
<td>
</td>
</tr>
<tr>
<td>
<code>M::is_always_unique()</code>
</td>
<td>
<code>bool</code>
</td>
<td>
<em>Returns:</em> <code>true</code> if <code>m.is_unique()</code> is <code>true</code> for any object of type <code>M</code>.
</td>
<td>
</td>
</tr>
<tr>
<td>
<code>M::is_always_contiguous()</code>
</td>
<td>
<code>bool</code>
</td>
<td>
<em>Returns:</em> <code>true</code> if <code>m.is_contiguous()</code> is <code>true</code> for any object of type <code>M</code>.
</td>
<td>
</td>
</tr>
<tr>
<td>
<code>M::is_always_strided()</code>
</td>
<td>
<code>bool</code>
</td>
<td>
<em>Returns:</em> true if <code>m.is_strided()</code> is <code>true</code> for any object of type <code>M</code>.
</td>
<td>
</td>
</tr>
<tr>
<td>
<code>m.stride(r)</code>
</td>
<td>
<code>E::index_type</code>
</td>
<td>
<em>Returns:</em> <code>sr</code> as defined in <code>m.is_strided()</code> above.
</td>
<td>
<em>Expects:</em> <code>m.is_strided()</code> is <code>true</code>.
</td>
</tr>
</table>
<!--


  #                   #       #       ##  #
  #   ## # # ### # # ###      #  ###  #  ###
  #  # # ### # # # #  #       #  ##  ###  #
  ## ###   # ### ###  ##      ## ###  #   ##
         ###             ###         ##

-->
<p><br /> <b>22.7.�.2 Class template <code>layout_left</code> [mdspan.layout.left]</b></p>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> <code>layout_left</code> meets the requirements of layout mapping policy.</p>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> <code>layout_left</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>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span> If <code>Extents</code> is not a (possibly cv-qualified) specialization of <code>extents</code>, then the program is ill-formed.</p>
<div class="sourceCode" id="cb13"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb13-1"><a href="#cb13-1"></a><span class="kw">namespace</span> std <span class="op">{</span></span>
<span id="cb13-2"><a href="#cb13-2"></a></span>
<span id="cb13-3"><a href="#cb13-3"></a><span class="kw">struct</span> layout_left <span class="op">{</span></span>
<span id="cb13-4"><a href="#cb13-4"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> Extents<span class="op">&gt;</span></span>
<span id="cb13-5"><a href="#cb13-5"></a>  <span class="kw">class</span> mapping <span class="op">{</span></span>
<span id="cb13-6"><a href="#cb13-6"></a>    <span class="kw">using</span> index_type <span class="op">=</span> <span class="kw">typename</span> Extents<span class="op">::</span>index_type; <span class="co">// <em>exposition only</em></span></span>
<span id="cb13-7"><a href="#cb13-7"></a>  <span class="kw">public</span><span class="op">:</span></span>
<span id="cb13-8"><a href="#cb13-8"></a>    <span class="kw">constexpr</span> mapping<span class="op">()</span> <span class="kw">noexcept</span> <span class="op">=</span> <span class="cf">default</span>;</span>
<span id="cb13-9"><a href="#cb13-9"></a>    <span class="kw">constexpr</span> mapping<span class="op">(</span><span class="kw">const</span> mapping<span class="op">&amp;)</span> <span class="kw">noexcept</span> <span class="op">=</span> <span class="cf">default</span>;</span>
<span id="cb13-10"><a href="#cb13-10"></a>    <span class="kw">constexpr</span> mapping<span class="op">(</span><span class="kw">const</span> Extents<span class="op">&amp;)</span> <span class="kw">noexcept</span>;</span>
<span id="cb13-11"><a href="#cb13-11"></a>    <span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> OtherExtents<span class="op">&gt;</span></span>
<span id="cb13-12"><a href="#cb13-12"></a>      <span class="kw">constexpr</span> mapping<span class="op">(</span><span class="kw">const</span> mapping<span class="op">&lt;</span>OtherExtents<span class="op">&gt;&amp;)</span> <span class="kw">noexcept</span>;</span>
<span id="cb13-13"><a href="#cb13-13"></a></span>
<span id="cb13-14"><a href="#cb13-14"></a>    <span class="kw">constexpr</span> mapping<span class="op">&amp;</span> <span class="kw">operator</span><span class="op">=(</span><span class="kw">const</span> mapping<span class="op">&amp;)</span> <span class="kw">noexcept</span> <span class="op">=</span> <span class="cf">default</span>;</span>
<span id="cb13-15"><a href="#cb13-15"></a>    <span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> OtherExtents<span class="op">&gt;</span></span>
<span id="cb13-16"><a href="#cb13-16"></a>      <span class="kw">constexpr</span> mapping<span class="op">&amp;</span> <span class="kw">operator</span><span class="op">=(</span><span class="kw">const</span> mapping<span class="op">&lt;</span>OtherExtents<span class="op">&gt;&amp;)</span> <span class="kw">noexcept</span>;</span>
<span id="cb13-17"><a href="#cb13-17"></a></span>
<span id="cb13-18"><a href="#cb13-18"></a>    <span class="kw">constexpr</span> Extents extents<span class="op">()</span> <span class="kw">const</span> <span class="kw">noexcept</span> <span class="op">{</span> <span class="cf">return</span> extents_; <span class="op">}</span></span>
<span id="cb13-19"><a href="#cb13-19"></a></span>
<span id="cb13-20"><a href="#cb13-20"></a>    <span class="kw">constexpr</span> index_type required_span_size<span class="op">()</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb13-21"><a href="#cb13-21"></a></span>
<span id="cb13-22"><a href="#cb13-22"></a>    <span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span><span class="op">...</span> Indices<span class="op">&gt;</span></span>
<span id="cb13-23"><a href="#cb13-23"></a>      index_type <span class="kw">operator</span><span class="op">()(</span>Indices<span class="op">...)</span> <span class="kw">const</span> <span class="kw">noexcept</span>; </span>
<span id="cb13-24"><a href="#cb13-24"></a></span>
<span id="cb13-25"><a href="#cb13-25"></a>    <span class="kw">static</span> <span class="kw">constexpr</span> <span class="dt">bool</span> is_always_unique<span class="op">()</span> <span class="kw">noexcept</span> <span class="op">{</span> <span class="cf">return</span> <span class="kw">true</span>; <span class="op">}</span></span>
<span id="cb13-26"><a href="#cb13-26"></a>    <span class="kw">static</span> <span class="kw">constexpr</span> <span class="dt">bool</span> is_always_contiguous<span class="op">()</span> <span class="kw">noexcept</span> <span class="op">{</span> <span class="cf">return</span> <span class="kw">true</span>; <span class="op">}</span></span>
<span id="cb13-27"><a href="#cb13-27"></a>    <span class="kw">static</span> <span class="kw">constexpr</span> <span class="dt">bool</span> is_always_strided<span class="op">()</span> <span class="kw">noexcept</span> <span class="op">{</span> <span class="cf">return</span> <span class="kw">true</span>; <span class="op">}</span></span>
<span id="cb13-28"><a href="#cb13-28"></a></span>
<span id="cb13-29"><a href="#cb13-29"></a>    <span class="kw">constexpr</span> <span class="dt">bool</span> is_unique<span class="op">()</span> <span class="kw">const</span> <span class="kw">noexcept</span> <span class="op">{</span> <span class="cf">return</span> <span class="kw">true</span>; <span class="op">}</span></span>
<span id="cb13-30"><a href="#cb13-30"></a>    <span class="kw">constexpr</span> <span class="dt">bool</span> is_contiguous<span class="op">()</span> <span class="kw">const</span> <span class="kw">noexcept</span> <span class="op">{</span> <span class="cf">return</span> <span class="kw">true</span>; <span class="op">}</span></span>
<span id="cb13-31"><a href="#cb13-31"></a>    <span class="kw">constexpr</span> <span class="dt">bool</span> is_strided<span class="op">()</span> <span class="kw">const</span> <span class="kw">noexcept</span> <span class="op">{</span> <span class="cf">return</span> <span class="kw">true</span>; <span class="op">}</span></span>
<span id="cb13-32"><a href="#cb13-32"></a></span>
<span id="cb13-33"><a href="#cb13-33"></a>    index_type stride<span class="op">(</span><span class="dt">size_t</span><span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb13-34"><a href="#cb13-34"></a></span>
<span id="cb13-35"><a href="#cb13-35"></a>    <span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> OtherExtents<span class="op">&gt;</span></span>
<span id="cb13-36"><a href="#cb13-36"></a>      <span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> mapping<span class="op">&lt;</span>OtherExtents<span class="op">&gt;&amp;)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb13-37"><a href="#cb13-37"></a>    <span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> OtherExtents<span class="op">&gt;</span></span>
<span id="cb13-38"><a href="#cb13-38"></a>      <span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">!=(</span><span class="kw">const</span> mapping<span class="op">&lt;</span>OtherExtents<span class="op">&gt;&amp;</span> rhs<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span></span>
<span id="cb13-39"><a href="#cb13-39"></a>      <span class="op">{</span> <span class="cf">return</span> <span class="op">!(*</span><span class="kw">this</span> <span class="op">==</span> rhs<span class="op">)</span>; <span class="op">}</span></span>
<span id="cb13-40"><a href="#cb13-40"></a></span>
<span id="cb13-41"><a href="#cb13-41"></a>  <span class="kw">private</span><span class="op">:</span></span>
<span id="cb13-42"><a href="#cb13-42"></a>    Extents extents_<span class="op">{}</span>; <span class="co">// <em>exposition only</em></span></span>
<span id="cb13-43"><a href="#cb13-43"></a>  <span class="op">}</span>;</span>
<span id="cb13-44"><a href="#cb13-44"></a><span class="op">}</span>;</span>
<span id="cb13-45"><a href="#cb13-45"></a><span class="op">}</span></span></code></pre></div>
<p><b>22.7.�.2.1 <code>layout_left::mapping</code> members [mdspan.layout.layout_left]</b></p>
<div class="sourceCode" id="cb14"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb14-1"><a href="#cb14-1"></a><span class="kw">constexpr</span> mapping<span class="op">(</span><span class="kw">const</span> Extents<span class="op">&amp;</span> e<span class="op">)</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<ul>
<li><span class="marginalizedparent"><a class="marginalized">1</a></span> <em>Effects:</em> Initializes <code>extents_</code> with <code>e</code>.</li>
</ul>
<div class="sourceCode" id="cb15"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb15-1"><a href="#cb15-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> OtherExtents<span class="op">&gt;</span></span>
<span id="cb15-2"><a href="#cb15-2"></a>  <span class="kw">constexpr</span> mapping<span class="op">(</span><span class="kw">const</span> mapping<span class="op">&lt;</span>OtherExtents<span class="op">&gt;&amp;</span> other<span class="op">)</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<ul>
<li><p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Constraints:</em> <code>is_convertible_v&lt;OtherExtents,Extents&gt;</code> is <code>true</code>.</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">3</a></span> <em>Effects:</em> Initializes <code>extents_</code> with <code>other.extents()</code>.</p></li>
</ul>
<div class="sourceCode" id="cb16"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb16-1"><a href="#cb16-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> OtherExtents<span class="op">&gt;</span></span>
<span id="cb16-2"><a href="#cb16-2"></a>  <span class="kw">constexpr</span> mapping<span class="op">&amp;</span> <span class="kw">operator</span><span class="op">=(</span><span class="kw">const</span> mapping<span class="op">&lt;</span>OtherExtents<span class="op">&gt;&amp;</span> other<span class="op">)</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<ul>
<li><p><span class="marginalizedparent"><a class="marginalized">4</a></span> <em>Effects:</em> Equivalent to:</p>
<div class="sourceCode" id="cb17"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb17-1"><a href="#cb17-1"></a>extents_ <span class="op">=</span> other<span class="op">.</span>extents<span class="op">()</span>;</span>
<span id="cb17-2"><a href="#cb17-2"></a><span class="cf">return</span> <span class="op">*</span><span class="kw">this</span>;</span></code></pre></div></li>
</ul>
<div class="sourceCode" id="cb18"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb18-1"><a href="#cb18-1"></a>index_type required_span_size<span class="op">()</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<ul>
<li><span class="marginalizedparent"><a class="marginalized">5</a></span> <em>Returns:</em> The product of <code>extents().extent(r)</code> for all <code>r</code> in the range <span class="math inline">[0,</span> <code>Extents::rank()</code> <span class="math inline">)</span>.</li>
</ul>
<div class="sourceCode" id="cb19"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb19-1"><a href="#cb19-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span><span class="op">...</span> Indices<span class="op">&gt;</span> </span>
<span id="cb19-2"><a href="#cb19-2"></a>  index_type <span class="kw">operator</span><span class="op">()(</span>Indices<span class="op">...</span> i<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<ul>
<li><p><span class="marginalizedparent"><a class="marginalized">6</a></span> <em>Constraints:</em></p>
<ul>
<li><p><span class="marginalizedparent"><a class="marginalized">(6.1)</a></span> <code>sizeof...(Indices) == Extents::rank()</code> is <code>true</code>, and</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">(6.1)</a></span> <code>(is_convertible_v&lt;Indices, index_type&gt; &amp;&amp; ...)</code> is <code>true</code>.</p></li>
</ul></li>
<li><p><span class="marginalizedparent"><a class="marginalized">7</a></span> <em>Expects:</em> <span class="math inline">0 ≤</span> <code>array{i...}[r]</code> <span class="math inline">&lt;</span> <code>extents().extent(r)</code> for all <code>r</code> in the range <span class="math inline">[0,</span> <code>Extents::rank()</code> <span class="math inline">)</span>.</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">8</a></span> <em>Effects:</em> Let <code>P...</code> be the parameter pack such that <code>is_same_v&lt;make_index_sequence&lt;index_type, sizeof...(Indices)&gt;, integer_sequence&lt;index_type, P...&gt;&gt;</code> is <code>true</code>. <br /> Equivalent to: <code>return Extents::rank() &gt; 0 ? (i*stride(P()) + ...) : 0;</code></p></li>
</ul>
<div class="sourceCode" id="cb20"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb20-1"><a href="#cb20-1"></a>index_type stride<span class="op">(</span><span class="dt">size_t</span> r<span class="op">)</span> <span class="kw">const</span>;</span></code></pre></div>
<ul>
<li><span class="marginalizedparent"><a class="marginalized">9</a></span> <em>Returns:</em> <code>1</code> if <code>r</code> equals zero, otherwise, the product of <code>extents().extent(k)</code> for all <code>k</code> in the range <span class="math inline">[0,</span> <code>r</code> <span class="math inline">)</span>.</li>
</ul>
<div class="sourceCode" id="cb21"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb21-1"><a href="#cb21-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> OtherExtents<span class="op">&gt;</span></span>
<span id="cb21-2"><a href="#cb21-2"></a>  <span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> mapping<span class="op">&lt;</span>OtherExtents<span class="op">&gt;&amp;</span> other<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<ul>
<li><span class="marginalizedparent"><a class="marginalized">10</a></span> <em>Effects:</em> Equivalent to: <code>return extents() == other.extents();</code>.</li>
</ul>
<!--

 #                   #           #      #    #
 #   ## # # ### # # ###     ###     ### ### ###
 #  # # ### # # # #  #      #    #  # # # #  #
 ## ###   # ### ###  ##     #    ##  ## # #  ##
        ###             ###         ###
-->
<p><br /> <b>22.7.�.3 Class template <code>layout_right</code> [mdspan.layout.right]</b></p>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> <code>layout_right</code> meets the requirements of layout mapping policy.</p>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> The layout mapping property <code>layout_right</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>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span> If <code>Extents</code> is not a (possibly cv-qualified) specialization of <code>extents</code>, then the program is ill-formed.</p>
<div class="sourceCode" id="cb22"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb22-1"><a href="#cb22-1"></a><span class="kw">namespace</span> std <span class="op">{</span></span>
<span id="cb22-2"><a href="#cb22-2"></a></span>
<span id="cb22-3"><a href="#cb22-3"></a><span class="kw">struct</span> layout_right <span class="op">{</span></span>
<span id="cb22-4"><a href="#cb22-4"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> Extents<span class="op">&gt;</span></span>
<span id="cb22-5"><a href="#cb22-5"></a>  <span class="kw">class</span> mapping <span class="op">{</span></span>
<span id="cb22-6"><a href="#cb22-6"></a>    <span class="kw">using</span> index_type <span class="op">=</span> <span class="kw">typename</span> Extents<span class="op">::</span>index_type; <span class="co">// <em>exposition only</em></span></span>
<span id="cb22-7"><a href="#cb22-7"></a>  <span class="kw">public</span><span class="op">:</span></span>
<span id="cb22-8"><a href="#cb22-8"></a>    <span class="kw">constexpr</span> mapping<span class="op">()</span> <span class="kw">noexcept</span> <span class="op">=</span> <span class="cf">default</span>;</span>
<span id="cb22-9"><a href="#cb22-9"></a>    <span class="kw">constexpr</span> mapping<span class="op">(</span><span class="kw">const</span> mapping<span class="op">&amp;)</span> <span class="kw">noexcept</span> <span class="op">=</span> <span class="cf">default</span>;</span>
<span id="cb22-10"><a href="#cb22-10"></a>    <span class="kw">constexpr</span> mapping<span class="op">(</span><span class="kw">const</span> Extents<span class="op">&amp;)</span> <span class="kw">noexcept</span>;</span>
<span id="cb22-11"><a href="#cb22-11"></a>    <span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> OtherExtents<span class="op">&gt;</span></span>
<span id="cb22-12"><a href="#cb22-12"></a>      <span class="kw">constexpr</span> mapping<span class="op">(</span><span class="kw">const</span> mapping<span class="op">&lt;</span>OtherExtents<span class="op">&gt;&amp;)</span> <span class="kw">noexcept</span>;</span>
<span id="cb22-13"><a href="#cb22-13"></a></span>
<span id="cb22-14"><a href="#cb22-14"></a>    <span class="kw">constexpr</span> mapping<span class="op">&amp;</span> <span class="kw">operator</span><span class="op">=(</span><span class="kw">const</span> mapping<span class="op">&amp;)</span> <span class="kw">noexcept</span> <span class="op">=</span> <span class="cf">default</span>;</span>
<span id="cb22-15"><a href="#cb22-15"></a>    <span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> OtherExtents<span class="op">&gt;</span></span>
<span id="cb22-16"><a href="#cb22-16"></a>      <span class="kw">constexpr</span> mapping<span class="op">&amp;</span> <span class="kw">operator</span><span class="op">=(</span><span class="kw">const</span> mapping<span class="op">&lt;</span>OtherExtents<span class="op">&gt;&amp;)</span> <span class="kw">noexcept</span>;</span>
<span id="cb22-17"><a href="#cb22-17"></a></span>
<span id="cb22-18"><a href="#cb22-18"></a>    <span class="kw">constexpr</span> Extents extents<span class="op">()</span> <span class="kw">const</span> <span class="kw">noexcept</span> <span class="op">{</span> <span class="cf">return</span> extents_; <span class="op">}</span></span>
<span id="cb22-19"><a href="#cb22-19"></a></span>
<span id="cb22-20"><a href="#cb22-20"></a>    <span class="kw">constexpr</span> index_type required_span_size<span class="op">()</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb22-21"><a href="#cb22-21"></a></span>
<span id="cb22-22"><a href="#cb22-22"></a>    <span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span><span class="op">...</span> Indices<span class="op">&gt;</span></span>
<span id="cb22-23"><a href="#cb22-23"></a>      index_type <span class="kw">operator</span><span class="op">()(</span>Indices<span class="op">...)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb22-24"><a href="#cb22-24"></a></span>
<span id="cb22-25"><a href="#cb22-25"></a>    <span class="kw">static</span> <span class="kw">constexpr</span> <span class="dt">bool</span> is_always_unique<span class="op">()</span> <span class="kw">noexcept</span> <span class="op">{</span> <span class="cf">return</span> <span class="kw">true</span>; <span class="op">}</span></span>
<span id="cb22-26"><a href="#cb22-26"></a>    <span class="kw">static</span> <span class="kw">constexpr</span> <span class="dt">bool</span> is_always_contiguous<span class="op">()</span> <span class="kw">noexcept</span> <span class="op">{</span> <span class="cf">return</span> <span class="kw">true</span>; <span class="op">}</span></span>
<span id="cb22-27"><a href="#cb22-27"></a>    <span class="kw">static</span> <span class="kw">constexpr</span> <span class="dt">bool</span> is_always_strided<span class="op">()</span> <span class="kw">noexcept</span> <span class="op">{</span> <span class="cf">return</span> <span class="kw">true</span>; <span class="op">}</span></span>
<span id="cb22-28"><a href="#cb22-28"></a></span>
<span id="cb22-29"><a href="#cb22-29"></a>    <span class="kw">constexpr</span> <span class="dt">bool</span> is_unique<span class="op">()</span> <span class="kw">const</span> <span class="kw">noexcept</span> <span class="op">{</span> <span class="cf">return</span> <span class="kw">true</span>; <span class="op">}</span></span>
<span id="cb22-30"><a href="#cb22-30"></a>    <span class="kw">constexpr</span> <span class="dt">bool</span> is_contiguous<span class="op">()</span> <span class="kw">const</span> <span class="kw">noexcept</span> <span class="op">{</span> <span class="cf">return</span> <span class="kw">true</span>; <span class="op">}</span></span>
<span id="cb22-31"><a href="#cb22-31"></a>    <span class="kw">constexpr</span> <span class="dt">bool</span> is_strided<span class="op">()</span> <span class="kw">const</span> <span class="kw">noexcept</span> <span class="op">{</span> <span class="cf">return</span> <span class="kw">true</span>; <span class="op">}</span></span>
<span id="cb22-32"><a href="#cb22-32"></a></span>
<span id="cb22-33"><a href="#cb22-33"></a>    index_type stride<span class="op">(</span><span class="dt">size_t</span><span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb22-34"><a href="#cb22-34"></a></span>
<span id="cb22-35"><a href="#cb22-35"></a>    <span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> OtherExtents<span class="op">&gt;</span></span>
<span id="cb22-36"><a href="#cb22-36"></a>      <span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> mapping<span class="op">&lt;</span>OtherExtents<span class="op">&gt;&amp;)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb22-37"><a href="#cb22-37"></a>    <span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> OtherExtents<span class="op">&gt;</span></span>
<span id="cb22-38"><a href="#cb22-38"></a>      <span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">!=(</span><span class="kw">const</span> mapping<span class="op">&lt;</span>OtherExtents<span class="op">&gt;&amp;</span> rhs<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span></span>
<span id="cb22-39"><a href="#cb22-39"></a>      <span class="op">{</span> <span class="cf">return</span> <span class="op">!(*</span><span class="kw">this</span> <span class="op">==</span> rhs<span class="op">)</span>; <span class="op">}</span></span>
<span id="cb22-40"><a href="#cb22-40"></a></span>
<span id="cb22-41"><a href="#cb22-41"></a>  <span class="kw">private</span><span class="op">:</span></span>
<span id="cb22-42"><a href="#cb22-42"></a>    Extents extents_<span class="op">{}</span>; <span class="co">// <em>exposition only</em></span></span>
<span id="cb22-43"><a href="#cb22-43"></a>  <span class="op">}</span>;</span>
<span id="cb22-44"><a href="#cb22-44"></a><span class="op">}</span>;</span>
<span id="cb22-45"><a href="#cb22-45"></a><span class="op">}</span></span></code></pre></div>
<p><b>22.7.�.3.1 <code>layout_right::mapping</code> members [mdspan.layout.layout_right]</b></p>
<div class="sourceCode" id="cb23"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb23-1"><a href="#cb23-1"></a><span class="kw">constexpr</span> mapping<span class="op">(</span><span class="kw">const</span> Extents<span class="op">&amp;</span> e<span class="op">)</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<ul>
<li><span class="marginalizedparent"><a class="marginalized">1</a></span> <em>Effects:</em> Initializes <code>extents_</code> with <code>e</code>.</li>
</ul>
<div class="sourceCode" id="cb24"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb24-1"><a href="#cb24-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> OtherExtents<span class="op">&gt;</span></span>
<span id="cb24-2"><a href="#cb24-2"></a>  <span class="kw">constexpr</span> mapping<span class="op">(</span><span class="kw">const</span> mapping<span class="op">&lt;</span>OtherExtents<span class="op">&gt;&amp;</span> other<span class="op">)</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<ul>
<li><p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Constraints:</em> <code>is_convertible_v&lt;OtherExtents,Extents&gt;</code> is <code>true</code>.</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">3</a></span> <em>Effects:</em> Initializes <code>extents_</code> with <code>other.extents()</code>.</p></li>
</ul>
<div class="sourceCode" id="cb25"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb25-1"><a href="#cb25-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> OtherExtents<span class="op">&gt;</span></span>
<span id="cb25-2"><a href="#cb25-2"></a>  <span class="kw">constexpr</span> mapping<span class="op">&amp;</span> <span class="kw">operator</span><span class="op">=(</span><span class="kw">const</span> mapping<span class="op">&lt;</span>OtherExtents<span class="op">&gt;&amp;</span> other<span class="op">)</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<ul>
<li><p><span class="marginalizedparent"><a class="marginalized">4</a></span> <em>Effects:</em> Equivalent to:</p>
<div class="sourceCode" id="cb26"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb26-1"><a href="#cb26-1"></a>extents_ <span class="op">=</span> other<span class="op">.</span>extents<span class="op">()</span>;</span>
<span id="cb26-2"><a href="#cb26-2"></a><span class="cf">return</span> <span class="op">*</span><span class="kw">this</span>;</span></code></pre></div></li>
</ul>
<div class="sourceCode" id="cb27"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb27-1"><a href="#cb27-1"></a>index_type required_span_size<span class="op">()</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<ul>
<li><span class="marginalizedparent"><a class="marginalized">5</a></span> <em>Returns:</em> The product of <code>extents().extent(r)</code> for all <code>r</code> in the range <span class="math inline">[0,</span> <code>Extents::rank()</code> <span class="math inline">)</span>.</li>
</ul>
<div class="sourceCode" id="cb28"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb28-1"><a href="#cb28-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span><span class="op">...</span> Indices<span class="op">&gt;</span> </span>
<span id="cb28-2"><a href="#cb28-2"></a>  index_type <span class="kw">operator</span><span class="op">()(</span>Indices<span class="op">...</span> i<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<ul>
<li><p><span class="marginalizedparent"><a class="marginalized">6</a></span> <em>Constraints:</em></p>
<ul>
<li><p><span class="marginalizedparent"><a class="marginalized">(6.1)</a></span> <code>sizeof...(Indices) == Extents::rank()</code> is <code>true</code>, and</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">(6.1)</a></span> <code>(is_convertible_v&lt;Indices, index_type&gt; &amp;&amp; ...)</code> is <code>true</code>.</p></li>
</ul></li>
<li><p><span class="marginalizedparent"><a class="marginalized">7</a></span> <em>Expects:</em> <span class="math inline">0 ≤</span> <code>array{i...}[r]</code> <span class="math inline">&lt;</span> <code>extents().extent(r)</code> for all <code>r</code> in the range <span class="math inline">[0,</span> <code>Extents::rank()</code> <span class="math inline">)</span>.</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">8</a></span> <em>Effects:</em> Let <code>P...</code> be the parameter pack such that <code>is_same_v&lt;make_index_sequence&lt;index_type, sizeof...(Indices)&gt;, integer_sequence&lt;index_type, P...&gt;&gt;</code> is <code>true</code>. <br /> Equivalent to: <code>return Extents::rank() &gt; 0 ? (i*stride(P()) + ...) : 0;</code></p></li>
</ul>
<div class="sourceCode" id="cb29"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb29-1"><a href="#cb29-1"></a>index_type stride<span class="op">(</span><span class="dt">size_t</span> r<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<ul>
<li><span class="marginalizedparent"><a class="marginalized">9</a></span> <em>Returns:</em> <code>1</code> if <code>r</code> equals <code>Extents::rank()-1</code>, otherwise, the product of <code>extents().extent(k)</code> for all <code>k</code> in the range <span class="math inline">[</span> <code>r+1</code> <span class="math inline">,</span> <code>Extents::rank()</code> <span class="math inline">)</span>.</li>
</ul>
<div class="sourceCode" id="cb30"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb30-1"><a href="#cb30-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> OtherExtents<span class="op">&gt;</span></span>
<span id="cb30-2"><a href="#cb30-2"></a>  <span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> mapping<span class="op">&lt;</span>OtherExtents<span class="op">&gt;&amp;</span> other<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<ul>
<li><span class="marginalizedparent"><a class="marginalized">10</a></span> <em>Effects:</em> Equivalent to: <code>return extents() == other.extents();</code>.</li>
</ul>
<!--
layout_stride

 /$$                                           /$$                      /$$               /$$       /$$
| $$                                          | $$                     | $$              |__/      | $$
| $$  /$$$$$$  /$$   /$$  /$$$$$$  /$$   /$$ /$$$$$$         /$$$$$$$ /$$$$$$    /$$$$$$  /$$  /$$$$$$$  /$$$$$$
| $$ |____  $$| $$  | $$ /$$__  $$| $$  | $$|_  $$_/        /$$_____/|_  $$_/   /$$__  $$| $$ /$$__  $$ /$$__  $$
| $$  /$$$$$$$| $$  | $$| $$  \ $$| $$  | $$  | $$         |  $$$$$$   | $$    | $$  \__/| $$| $$  | $$| $$$$$$$$
| $$ /$$__  $$| $$  | $$| $$  | $$| $$  | $$  | $$ /$$      \____  $$  | $$ /$$| $$      | $$| $$  | $$| $$_____/
| $$|  $$$$$$$|  $$$$$$$|  $$$$$$/|  $$$$$$/  |  $$$$/      /$$$$$$$/  |  $$$$/| $$      | $$|  $$$$$$$|  $$$$$$$
|__/ \_______/ \____  $$ \______/  \______/    \___//$$$$$$|_______/    \___/  |__/      |__/ \_______/ \_______/
               /$$  | $$                           |______/
              |  $$$$$$/
               \______/

-->
<p><br /> <b>22.7.�.4 Class template <code>layout_stride</code> [mdspan.layout.stride]</b></p>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> <code>layout_stride</code> meets the requirements of layout mapping policy.</p>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> The layout mapping property <code>layout_stride</code> gives a layout mapping where the strides are user defined.</p>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span> If <code>Extents</code> is not a (possibly cv-qualified) specialization of <code>extents</code>, then the program is ill-formed.</p>
<div class="sourceCode" id="cb31"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb31-1"><a href="#cb31-1"></a><span class="kw">namespace</span> std <span class="op">{</span></span>
<span id="cb31-2"><a href="#cb31-2"></a></span>
<span id="cb31-3"><a href="#cb31-3"></a><span class="kw">struct</span> layout_stride <span class="op">{</span></span>
<span id="cb31-4"><a href="#cb31-4"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> Extents<span class="op">&gt;</span></span>
<span id="cb31-5"><a href="#cb31-5"></a>  <span class="kw">class</span> mapping <span class="op">{</span></span>
<span id="cb31-6"><a href="#cb31-6"></a>    <span class="kw">using</span> index_type <span class="op">=</span> <span class="kw">typename</span> Extents<span class="op">::</span>index_type; <span class="co">// <em>exposition only</em></span></span>
<span id="cb31-7"><a href="#cb31-7"></a>  <span class="kw">public</span><span class="op">:</span></span>
<span id="cb31-8"><a href="#cb31-8"></a>    <span class="kw">constexpr</span> mapping<span class="op">()</span> <span class="kw">noexcept</span> <span class="op">=</span> <span class="cf">default</span>;</span>
<span id="cb31-9"><a href="#cb31-9"></a>    <span class="kw">constexpr</span> mapping<span class="op">(</span><span class="kw">const</span> mapping<span class="op">&amp;)</span> <span class="kw">noexcept</span> <span class="op">=</span> <span class="cf">default</span>;</span>
<span id="cb31-10"><a href="#cb31-10"></a>    <span class="kw">constexpr</span> mapping<span class="op">(</span><span class="kw">const</span> Extents<span class="op">&amp;</span>,</span>
<span id="cb31-11"><a href="#cb31-11"></a>                      <span class="kw">const</span> array<span class="op">&lt;</span>index_type, Extents<span class="op">::</span>rank<span class="op">()&gt;&amp;)</span> <span class="kw">noexcept</span>;</span>
<span id="cb31-12"><a href="#cb31-12"></a>    <span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> OtherExtents<span class="op">&gt;</span></span>
<span id="cb31-13"><a href="#cb31-13"></a>      <span class="kw">constexpr</span> mapping<span class="op">(</span><span class="kw">const</span> mapping<span class="op">&lt;</span>OtherExtents<span class="op">&gt;&amp;)</span> <span class="kw">noexcept</span>;</span>
<span id="cb31-14"><a href="#cb31-14"></a></span>
<span id="cb31-15"><a href="#cb31-15"></a>    mapping<span class="op">&amp;</span> <span class="kw">operator</span><span class="op">=(</span><span class="kw">const</span> mapping<span class="op">&amp;)</span> <span class="kw">noexcept</span> <span class="op">=</span> <span class="cf">default</span>;</span>
<span id="cb31-16"><a href="#cb31-16"></a>    <span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> OtherExtents<span class="op">&gt;</span></span>
<span id="cb31-17"><a href="#cb31-17"></a>      mapping<span class="op">&amp;</span> <span class="kw">operator</span><span class="op">=(</span><span class="kw">const</span> mapping<span class="op">&lt;</span>OtherExtents<span class="op">&gt;&amp;)</span> <span class="kw">noexcept</span>;</span>
<span id="cb31-18"><a href="#cb31-18"></a></span>
<span id="cb31-19"><a href="#cb31-19"></a>    <span class="kw">constexpr</span> Extents extents<span class="op">()</span> <span class="kw">const</span> <span class="kw">noexcept</span> <span class="op">{</span> <span class="cf">return</span> extents_; <span class="op">}</span></span>
<span id="cb31-20"><a href="#cb31-20"></a>    array<span class="op">&lt;</span><span class="kw">typename</span> index_type, Extents<span class="op">::</span>rank<span class="op">()&gt;</span> strides<span class="op">()</span> <span class="kw">const</span> <span class="kw">noexcept</span></span>
<span id="cb31-21"><a href="#cb31-21"></a>    <span class="op">{</span> <span class="cf">return</span> strides_; <span class="op">}</span></span>
<span id="cb31-22"><a href="#cb31-22"></a></span>
<span id="cb31-23"><a href="#cb31-23"></a>    <span class="kw">constexpr</span> index_type required_span_size<span class="op">()</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb31-24"><a href="#cb31-24"></a></span>
<span id="cb31-25"><a href="#cb31-25"></a>    <span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span><span class="op">...</span> Indices<span class="op">&gt;</span></span>
<span id="cb31-26"><a href="#cb31-26"></a>      index_type <span class="kw">operator</span><span class="op">()(</span>Indices<span class="op">...)</span> <span class="kw">const</span> <span class="kw">noexcept</span> ;</span>
<span id="cb31-27"><a href="#cb31-27"></a></span>
<span id="cb31-28"><a href="#cb31-28"></a>    <span class="kw">static</span> <span class="kw">constexpr</span> <span class="dt">bool</span> is_always_unique<span class="op">()</span> <span class="kw">noexcept</span> <span class="op">{</span> <span class="cf">return</span> <span class="kw">true</span>; <span class="op">}</span></span>
<span id="cb31-29"><a href="#cb31-29"></a>    <span class="kw">static</span> <span class="kw">constexpr</span> <span class="dt">bool</span> is_always_contiguous<span class="op">()</span> <span class="kw">noexcept</span> <span class="op">{</span> <span class="cf">return</span> <span class="kw">false</span>; <span class="op">}</span></span>
<span id="cb31-30"><a href="#cb31-30"></a>    <span class="kw">static</span> <span class="kw">constexpr</span> <span class="dt">bool</span> is_always_strided<span class="op">()</span> <span class="kw">noexcept</span> <span class="op">{</span> <span class="cf">return</span> <span class="kw">true</span>; <span class="op">}</span></span>
<span id="cb31-31"><a href="#cb31-31"></a></span>
<span id="cb31-32"><a href="#cb31-32"></a>    <span class="kw">constexpr</span> <span class="dt">bool</span> is_unique<span class="op">()</span> <span class="kw">const</span> <span class="kw">noexcept</span> <span class="op">{</span> <span class="cf">return</span> <span class="kw">true</span>; <span class="op">}</span></span>
<span id="cb31-33"><a href="#cb31-33"></a>    <span class="kw">constexpr</span> <span class="dt">bool</span> is_contiguous<span class="op">()</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb31-34"><a href="#cb31-34"></a>    <span class="kw">constexpr</span> <span class="dt">bool</span> is_strided<span class="op">()</span> <span class="kw">const</span> <span class="kw">noexcept</span> <span class="op">{</span> <span class="cf">return</span> <span class="kw">true</span>; <span class="op">}</span></span>
<span id="cb31-35"><a href="#cb31-35"></a></span>
<span id="cb31-36"><a href="#cb31-36"></a>    index_type stride<span class="op">(</span><span class="dt">size_t</span><span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb31-37"><a href="#cb31-37"></a></span>
<span id="cb31-38"><a href="#cb31-38"></a>    <span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> OtherExtents<span class="op">&gt;</span></span>
<span id="cb31-39"><a href="#cb31-39"></a>      <span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> mapping<span class="op">&lt;</span>OtherExtents<span class="op">&gt;&amp;)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb31-40"><a href="#cb31-40"></a>    <span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> OtherExtents<span class="op">&gt;</span></span>
<span id="cb31-41"><a href="#cb31-41"></a>      <span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">!=(</span><span class="kw">const</span> mapping<span class="op">&lt;</span>OtherExtents<span class="op">&gt;&amp;</span> rhs<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span></span>
<span id="cb31-42"><a href="#cb31-42"></a>      <span class="op">{</span> <span class="cf">return</span> <span class="op">!(*</span><span class="kw">this</span> <span class="op">==</span> rhs<span class="op">)</span>; <span class="op">}</span></span>
<span id="cb31-43"><a href="#cb31-43"></a></span>
<span id="cb31-44"><a href="#cb31-44"></a>  <span class="kw">private</span><span class="op">:</span></span>
<span id="cb31-45"><a href="#cb31-45"></a>    Extents extents_<span class="op">{}</span>; <span class="co">// <em>exposition only</em></span></span>
<span id="cb31-46"><a href="#cb31-46"></a>    array<span class="op">&lt;</span>index_type, Extents<span class="op">::</span>rank<span class="op">()&gt;</span> strides_<span class="op">{}</span>; <span class="co">// <em>exposition only</em></span></span>
<span id="cb31-47"><a href="#cb31-47"></a>  <span class="op">}</span>;</span>
<span id="cb31-48"><a href="#cb31-48"></a><span class="op">}</span>;</span>
<span id="cb31-49"><a href="#cb31-49"></a><span class="op">}</span></span></code></pre></div>
<p><b>22.7.�.4.1 <code>layout_stride::mapping</code> members [mdspan.layout.layout_stride]</b></p>
<div class="sourceCode" id="cb32"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb32-1"><a href="#cb32-1"></a><span class="kw">constexpr</span> mapping<span class="op">(</span><span class="kw">const</span> Extents<span class="op">&amp;</span> e, array<span class="op">&lt;</span>index_type, Extents<span class="op">::</span>rank<span class="op">()&gt;</span> s<span class="op">)</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> Let <span class="math inline"><em>P</em></span> be a permutation of the integers <span class="math inline">0, ...,</span> <code>Extents::rank()-1</code> and let <span class="math inline"><em>p</em><sub><em>i</em></sub></span> be the <span class="math inline"><em>i</em><sup><em>t</em><em>h</em></sup></span> element of <span class="math inline"><em>P</em></span>.</p>
<ul>
<li><p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Expects:</em></p>
<ul>
<li><p><span class="marginalizedparent"><a class="marginalized">(2.1)</a></span><code>s[i] &gt; 0</code> is <code>true</code> for all <code>i</code> in the range <span class="math inline">[0,</span> <code>Extents::rank()</code> <span class="math inline">)</span>.</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">(2.2)</a></span> If <code>Extents::rank()</code> is greater than zero, then there exists a permutation <span class="math inline"><em>P</em></span> such that <code>s[</code> <span class="math inline"><em>p</em><sub><em>i</em></sub></span> <code>] &gt;= s(</code> <span class="math inline"><em>p</em><sub><em>i</em> − 1</sub></span> <code>]) * e.extent(</code> <span class="math inline"><em>p</em><sub><em>i</em> − 1</sub></span> <code>)</code> is <code>true</code> for all <span class="math inline"><em>i</em></span> in the range <span class="math inline">[1,</span> <code>Extents::rank()</code> <span class="math inline">)</span>.</p></li>
</ul></li>
<li><p><span class="marginalizedparent"><a class="marginalized">3</a></span> <em>Effects:</em> Initializes <code>extents_</code> with <code>e</code>, and initializes <code>strides_</code> with <code>s</code>.</p></li>
</ul>
<div class="sourceCode" id="cb33"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb33-1"><a href="#cb33-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> OtherExtents<span class="op">&gt;</span></span>
<span id="cb33-2"><a href="#cb33-2"></a>  <span class="kw">constexpr</span> mapping<span class="op">(</span><span class="kw">const</span> mapping<span class="op">&lt;</span>OtherExtents<span class="op">&gt;&amp;</span> other<span class="op">)</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<ul>
<li><p><span class="marginalizedparent"><a class="marginalized">4</a></span> <em>Constraints:</em> <code>is_convertible_v&lt;OtherExtents,Extents&gt;</code> is <code>true</code>.</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">5</a></span> <em>Effects:</em> Initializes <code>extents_</code> with <code>other.extents()</code>, and initializes <code>strides_</code> with <code>other.strides()</code>.</p></li>
</ul>
<div class="sourceCode" id="cb34"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb34-1"><a href="#cb34-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> OtherExtents<span class="op">&gt;</span></span>
<span id="cb34-2"><a href="#cb34-2"></a>  mapping<span class="op">&amp;</span> <span class="kw">operator</span><span class="op">=(</span><span class="kw">const</span> mapping<span class="op">&lt;</span>OtherExtents<span class="op">&gt;&amp;</span> other<span class="op">)</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<ul>
<li><p><span class="marginalizedparent"><a class="marginalized">6</a></span> <em>Effects:</em> Equivalent to:</p>
<div class="sourceCode" id="cb35"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb35-1"><a href="#cb35-1"></a>extents_ <span class="op">=</span> other<span class="op">.</span>extents<span class="op">()</span>;</span>
<span id="cb35-2"><a href="#cb35-2"></a><span class="cf">return</span> <span class="op">*</span><span class="kw">this</span>;</span></code></pre></div></li>
</ul>
<div class="sourceCode" id="cb36"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb36-1"><a href="#cb36-1"></a>index_type required_span_size<span class="op">()</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<ul>
<li><span class="marginalizedparent"><a class="marginalized">7</a></span> <em>Returns:</em> The maximum of <code>extents().extent(r) * stride(r)</code> for all <code>r</code> in the range <span class="math inline">[0,</span> <code>Extents::rank()</code> <span class="math inline">)</span>.</li>
</ul>
<div class="sourceCode" id="cb37"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb37-1"><a href="#cb37-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span><span class="op">...</span> Indices<span class="op">&gt;</span> </span>
<span id="cb37-2"><a href="#cb37-2"></a>  index_type <span class="kw">operator</span><span class="op">()(</span>Indices<span class="op">...</span> i<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<ul>
<li><p><span class="marginalizedparent"><a class="marginalized">8</a></span> <em>Constraints:</em></p>
<ul>
<li><p><span class="marginalizedparent"><a class="marginalized">(8.1)</a></span> <code>sizeof...(Indices) == Extents::rank()</code> is <code>true</code>, and</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">(8.1)</a></span> <code>(is_convertible_v&lt;Indices, index_type&gt; &amp;&amp; ...)</code> is <code>true</code>.</p></li>
</ul></li>
<li><p><span class="marginalizedparent"><a class="marginalized">9</a></span> <em>Expects:</em> <span class="math inline">0 ≤</span> <code>array{i...}[r]</code> <span class="math inline">&lt;</span> <code>extents().extent(r)</code> for all <code>r</code> in the range <span class="math inline">[0,</span> <code>Extents::rank()</code> <span class="math inline">)</span>.</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">10</a></span> <em>Effects:</em> Let <code>P...</code> be the parameter pack such that <code>is_same_v&lt;make_index_sequence&lt;index_type, sizeof...(Indices)&gt;, integer_sequence&lt;index_type, P...&gt;&gt;</code> is <code>true</code>. <br /> Equivalent to: <code>return Extents::rank() &gt; 0 ? (i*stride(P()) + ...) : 0;</code></p></li>
</ul>
<div class="sourceCode" id="cb38"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb38-1"><a href="#cb38-1"></a><span class="kw">constexpr</span> <span class="dt">bool</span> is_contiguous<span class="op">()</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">11</a></span> Let <span class="math inline"><em>P</em></span> be a permutation of the integers <span class="math inline">0, ...,</span> <code>Extents::rank()-1</code> and let <span class="math inline"><em>p</em><sub><em>i</em></sub></span> be the <span class="math inline"><em>i</em><sup><em>t</em><em>h</em></sup></span> element of <span class="math inline"><em>P</em></span>.</p>
<ul>
<li><p><span class="marginalizedparent"><a class="marginalized">12</a></span><em>Returns:</em></p>
<ul>
<li><p><span class="marginalizedparent"><a class="marginalized">(12.1)</a></span> <code>true</code> if <code>Extents::ranks()</code> is zero.</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">(12.2)</a></span> Otherwise, <code>true</code> if there is a permutation <span class="math inline"><em>P</em></span> such that <code>min(stride(</code> <span class="math inline"><em>p</em><sub><em>i</em></sub></span> <code>)</code> equals one for <span class="math inline"><em>i</em></span> in the range <span class="math inline">[0,</span> <code>Extents::rank()</code> <span class="math inline">)</span>, and <code>stride(</code> <span class="math inline"><em>p</em><sub><em>i</em></sub></span> <code>)</code> equals <code>stride(</code> <span class="math inline"><em>p</em><sub><em>i</em> − 1</sub></span> <code>) * extents().extent(</code> <span class="math inline"><em>p</em><sub><em>i</em> − 1</sub></span> <code>)</code> for <span class="math inline"><em>i</em></span> in the range <span class="math inline">[1,</span> <code>Extents::rank()</code> <span class="math inline">)</span>.</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">(12.3)</a></span> Otherwise, <code>false</code>.</p></li>
</ul></li>
</ul>
<div class="sourceCode" id="cb39"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb39-1"><a href="#cb39-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> OtherExtents<span class="op">&gt;</span></span>
<span id="cb39-2"><a href="#cb39-2"></a>  <span class="kw">constexpr</span> <span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span><span class="kw">const</span> mapping<span class="op">&lt;</span>OtherExtents<span class="op">&gt;&amp;</span> other<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<ul>
<li><span class="marginalizedparent"><a class="marginalized">13</a></span> <em>Effects:</em> Equivalent to: <code>return extents() == other.extents();</code>.</li>
</ul>
<!--


 8888b.   .d8888b .d8888b .d88b.  .d8888b  .d8888b   .d88b.  888d888
    "88b d88P"   d88P"   d8P  Y8b 88K      88K      d88""88b 888P"
.d888888 888     888     88888888 "Y8888b. "Y8888b. 888  888 888
888  888 Y88b.   Y88b.   Y8b.          X88      X88 Y88..88P 888
"Y888888  "Y8888P "Y8888P "Y8888   88888P'  88888P'  "Y88P"  888



-->
<p><b>22.7.� Accessor Policy [mdspan.accessor]</b></p>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> An <em>accessor policy</em> defines types and operations by which a contiguous set of objects are accessed.</p>
<p><b>22.7.�.1 Accessor policy requirements [mdspan.accessor.reqs]</b></p>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> An accessor policy defines:</p>
<ul>
<li><p><span class="marginalizedparent"><a class="marginalized">(2.1)</a></span> a handle to a single element of type <code>element_type</code>;</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">(2.2)</a></span> a handle to a contiguous set of elements of type <code>element_type</code>, accessible through the policy’s <code>access</code> method;</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">(2.3)</a></span> conversion of a handle to a contiguous set of elements, to a pointer <em>[conv.array]</em>; and</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">(2.4)</a></span> getting a handle to the contiguous subset of elements beginning at an integer offset value.</p></li>
</ul>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span> <i>[Note:</i> The type of <code>reference</code> need not be <code>element_type&amp;</code>. The type of <code>pointer</code> need not be <code>element_type*</code>. <i>— end note]</i></p>
<p><span class="marginalizedparent"><a class="marginalized">4</a></span> An accessor policy meets the requirements of <em>Cpp17DefaultConstructible</em>, <em>Cpp17CopyAssignable</em>, and <em>Cpp17EqualityComparable</em>.</p>
<p><span class="marginalizedparent"><a class="marginalized">5</a></span> In Table �:</p>
<ul>
<li><p><span class="marginalizedparent"><a class="marginalized">(5.1)</a></span> <code>A</code> denotes an accessor policy.</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">(5.2)</a></span> <code>a</code> denotes an object of type <code>A</code>.</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">(5.3)</a></span> <code>p</code> denotes an object of type <code>A::pointer</code>.</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">(5.4)</a></span> <code>i</code> and <code>j</code> each denote a <code>ptrdiff_t</code> value.</p></li>
</ul>
Table �: Accessor policy requirements
<table border="1">
<tr>
<th>
Expression
</th>
<th>
Return Type
</th>
<th>
Requirements
</th>
</tr>
<tr>
<td>
<code>A</code>
</td>
<td>
</td>
<td>
<code>A</code> meets the requirements of <em>Cpp17DefaultConstructible</em>, <em>Cpp17CopyConstructible</em>, and <em>Cpp17CopyAssignable</em>.
</td>
</tr>
<tr>
<td>
<code>A::element_type</code>
</td>
<td>
</td>
<td>
<code>A::element_type</code> is required to be a complete object type that is not an abstract class type.
</td>
</tr>
<tr>
<td>
<code>A::pointer</code>
</td>
<td>
</td>
<td>
<code>A::pointer</code> meets the requirements of <em>Cpp17DefaultConstructible</em>, <em>Cpp17CopyConstructible</em>, and <em>Cpp17CopyAssignable</em>.
</td>
</tr>
<tr>
<td>
<code>A::reference</code>
</td>
<td>
</td>
<td>
<em>Constraints:</em> <code>is_convertible_v&lt;A::reference,A::element_type&gt;</code> is <code>true</code>, and if <code>is_const_v&lt;A::element_type&gt;</code> is <code>false</code> then <code>is_assignable_v&lt;A::element_type,A::reference&gt;</code> is <code>true</code>.
</td>
</tr>
<tr>
<td>
<code>A::offset_policy</code>
</td>
<td>
</td>
<td>
Accessor policy for accessing a pointer returned by <code>a.offset(p,i)</code>. <br /> <br /> <em>Constraints:</em> <br /> — <code>A::offset_policy</code> meets the requirements of an accessor policy in Table �, <br /> — <code>is_convertible_v&lt;A, A::offset_policy&gt;</code> is <code>true</code>, and <br /> — <code>A::offset_policy</code> can be constructed from <code>a</code>.
</td>
</tr>
<tr>
<td>
<code>a.decay(p)</code>
</td>
<td>
<code>A::element_type*</code>
</td>
<!-- lifted from [pointer.traits.optmem] -->
<td>
<em>Returns:</em> A pointer that references the same location as <code>p</code>.
</td>
</tr>
<tr>
<td>
<code>a.access(p, i)</code>
</td>
<td>
<code>A::reference</code>
</td>
<td>
<em>Returns:</em> An object which provides access to the <code>i</code>-th element in the range of elements that starts at <code>p</code>.
</td>
</tr>
<tr>
<td>
<code>a.offset(p, i)</code>
</td>
<td>
<code>A::offset_policy::pointer</code>
</td>
<td>
<em>Expects:</em> <br /> — <code>a.decay(p)+i</code> equals <code>A::offset_policy(a).decay(a.offset(p, i))</code>, and <br /> — <code>A::offset_policy(a).access(a.offset(p, i), j)</code> is valid if <code>a.access(p, i+j)</code> is valid. <br /> <br /> <em>Returns:</em> A pointer that references the same location as <code>a.decay(p)+i</code>.
</td>
</tr>
</table>
<!--

                                    #            #
 ## ### ### ###  ##  ## ### ###     ###  ##  ##     ###
# # #   #   ##   #   #  # # #       # # # #  #   #  #
### ### ### ### ##  ##  ### #       ### ### ##   ## ###
                                ###
-->
<p><b>22.7.�.2 Class template <code>accessor_basic</code> [mdspan.accessor.basic]</b></p>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> <code>accessor_basic</code> meets the requirements of accessor policy.</p>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> <code>ElementType</code> is required to be a complete object type that is neither an abstract class type nor an array type. <!-- mfh 20 Jan 2019: This imitates [span.overview] para 4 wording, with an additional restriction --></p>
<div class="sourceCode" id="cb40"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb40-1"><a href="#cb40-1"></a><span class="kw">namespace</span> std <span class="op">{</span></span>
<span id="cb40-2"><a href="#cb40-2"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> ElementType<span class="op">&gt;</span></span>
<span id="cb40-3"><a href="#cb40-3"></a>  <span class="kw">struct</span> accessor_basic <span class="op">{</span></span>
<span id="cb40-4"><a href="#cb40-4"></a>    <span class="kw">using</span> offset_policy <span class="op">=</span> accessor_basic;</span>
<span id="cb40-5"><a href="#cb40-5"></a>    <span class="kw">using</span> element_type <span class="op">=</span> ElementType;</span>
<span id="cb40-6"><a href="#cb40-6"></a>    <span class="kw">using</span> reference <span class="op">=</span> ElementType<span class="op">&amp;</span>;</span>
<span id="cb40-7"><a href="#cb40-7"></a>    <span class="kw">using</span> pointer <span class="op">=</span> ElementType<span class="op">*</span>;</span>
<span id="cb40-8"><a href="#cb40-8"></a></span>
<span id="cb40-9"><a href="#cb40-9"></a>    <span class="kw">constexpr</span> <span class="kw">typename</span> offset_policy<span class="op">::</span>pointer</span>
<span id="cb40-10"><a href="#cb40-10"></a>      offset<span class="op">(</span>pointer p, <span class="dt">ptrdiff_t</span> i<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb40-11"><a href="#cb40-11"></a></span>
<span id="cb40-12"><a href="#cb40-12"></a>    <span class="kw">constexpr</span> reference access<span class="op">(</span>pointer p, <span class="dt">ptrdiff_t</span> i<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb40-13"><a href="#cb40-13"></a></span>
<span id="cb40-14"><a href="#cb40-14"></a>    <span class="kw">constexpr</span> pointer decay<span class="op">(</span>pointer p<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb40-15"><a href="#cb40-15"></a>  <span class="op">}</span>;</span>
<span id="cb40-16"><a href="#cb40-16"></a><span class="op">}</span></span></code></pre></div>
<p><b>22.7.�.2 Class template <code>accessor_basic</code> members [mdspan.accessor.members]</b></p>
<div class="sourceCode" id="cb41"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb41-1"><a href="#cb41-1"></a><span class="kw">constexpr</span> <span class="kw">typename</span> offset_policy<span class="op">::</span>pointer</span>
<span id="cb41-2"><a href="#cb41-2"></a>  offset<span class="op">(</span>pointer p, <span class="dt">ptrdiff_t</span> i<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<ul>
<li><p><span class="marginalizedparent"><a class="marginalized">1</a></span> <em>Expects:</em> <code>p + i</code> is dereferenceable.</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Returns:</em> <code>p + i</code>.</p></li>
</ul>
<div class="sourceCode" id="cb42"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb42-1"><a href="#cb42-1"></a><span class="kw">constexpr</span> reference access<span class="op">(</span>pointer p, <span class="dt">ptrdiff_t</span> i<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<ul>
<li><p><span class="marginalizedparent"><a class="marginalized">3</a></span> <em>Expects:</em> <code>p + i</code> is dereferenceable.</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">4</a></span> <em>Returns:</em> <code>p[i]</code>.</p></li>
</ul>
<div class="sourceCode" id="cb43"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb43-1"><a href="#cb43-1"></a><span class="kw">constexpr</span> pointer decay<span class="op">(</span>pointer p<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<ul>
<li><span class="marginalizedparent"><a class="marginalized">5</a></span> <em>Returns:</em> <code>p</code>.</li>
</ul>
<!--
888                        d8b                                      888
888                        Y8P                                      888
888                                                                 888
88888b.   8888b.  .d8888b  888  .d8888b          88888b.d88b.   .d88888 .d8888b  88888b.   8888b.  88888b.
888 "88b     "88b 88K      888 d88P"             888 "888 "88b d88" 888 88K      888 "88b     "88b 888 "88b
888  888 .d888888 "Y8888b. 888 888               888  888  888 888  888 "Y8888b. 888  888 .d888888 888  888
888 d88P 888  888      X88 888 Y88b.             888  888  888 Y88b 888      X88 888 d88P 888  888 888  888
88888P"  "Y888888  88888P' 888  "Y8888P 88888888 888  888  888  "Y88888  88888P' 88888P"  "Y888888 888  888
                                                                                 888
                                                                                 888
                                                                                 888
-->
<p><b>22.7.� Class template <code>basic_mdspan</code> [mdspan.basic]</b></p>
<p><br /> <b>22.7.�.1 <code>basic_mdspan</code> overview [mdspan.basic.overview]</b></p>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> <code>basic_mdspan</code> maps a multidimensional index in its domain to a reference to an element in its codomain <code>span</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> The <em>domain</em> of a <code>basic_mdspan</code> object is a multidimensional index space defined by an <code>extents</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span> The <em>codomain</em> of a <code>basic_mdspan</code> object is a <code>span</code> of elements.</p>
<p><span class="marginalizedparent"><a class="marginalized">4</a></span> As with <code>span</code>, the storage of the objects in the codomain <code>span</code> of a <code>basic_mdspan</code> is owned by some other object.</p>
<div class="sourceCode" id="cb44"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb44-1"><a href="#cb44-1"></a><span class="kw">namespace</span> std <span class="op">{</span></span>
<span id="cb44-2"><a href="#cb44-2"></a></span>
<span id="cb44-3"><a href="#cb44-3"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> ElementType, <span class="kw">class</span> Extents, <span class="kw">class</span> LayoutPolicy, <span class="kw">class</span> AccessorPolicy<span class="op">&gt;</span></span>
<span id="cb44-4"><a href="#cb44-4"></a><span class="kw">class</span> basic_mdspan <span class="op">{</span></span>
<span id="cb44-5"><a href="#cb44-5"></a><span class="kw">public</span><span class="op">:</span></span>
<span id="cb44-6"><a href="#cb44-6"></a></span>
<span id="cb44-7"><a href="#cb44-7"></a>  <span class="co">// Domain and codomain types</span></span>
<span id="cb44-8"><a href="#cb44-8"></a>  <span class="kw">using</span> extents_type <span class="op">=</span> Extents;</span>
<span id="cb44-9"><a href="#cb44-9"></a>  <span class="kw">using</span> layout_type <span class="op">=</span> LayoutPolicy;</span>
<span id="cb44-10"><a href="#cb44-10"></a>  <span class="kw">using</span> accessor_type <span class="op">=</span> AccessorPolicy;</span>
<span id="cb44-11"><a href="#cb44-11"></a>  <span class="kw">using</span> mapping_type <span class="op">=</span> <span class="kw">typename</span> layout_type<span class="op">::</span><span class="kw">template</span> mapping_type<span class="op">&lt;</span>extents_type<span class="op">&gt;</span>;</span>
<span id="cb44-12"><a href="#cb44-12"></a>  <span class="kw">using</span> element_type <span class="op">=</span> <span class="kw">typename</span> accessor_type<span class="op">::</span>element_type;</span>
<span id="cb44-13"><a href="#cb44-13"></a>  <span class="kw">using</span> value_type <span class="op">=</span> remove_cv_t<span class="op">&lt;</span>element_type<span class="op">&gt;</span>;</span>
<span id="cb44-14"><a href="#cb44-14"></a>  <span class="kw">using</span> index_type <span class="op">=</span> <span class="dt">ptrdiff_t</span> ;</span>
<span id="cb44-15"><a href="#cb44-15"></a>  <span class="kw">using</span> difference_type <span class="op">=</span> <span class="dt">ptrdiff_t</span>;</span>
<span id="cb44-16"><a href="#cb44-16"></a>  <span class="kw">using</span> pointer <span class="op">=</span> <span class="kw">typename</span> accessor_type<span class="op">::</span>pointer;</span>
<span id="cb44-17"><a href="#cb44-17"></a>  <span class="kw">using</span> reference <span class="op">=</span> <span class="kw">typename</span> accessor_type<span class="op">::</span>reference;</span>
<span id="cb44-18"><a href="#cb44-18"></a></span>
<span id="cb44-19"><a href="#cb44-19"></a>  <span class="co">// [mdspan.basic.cons], basic_mdspan constructors, assignment, and destructor</span></span>
<span id="cb44-20"><a href="#cb44-20"></a>  <span class="kw">constexpr</span> basic_mdspan<span class="op">()</span> <span class="kw">noexcept</span> <span class="op">=</span> <span class="cf">default</span>;</span>
<span id="cb44-21"><a href="#cb44-21"></a>  <span class="kw">constexpr</span> basic_mdspan<span class="op">(</span><span class="kw">const</span> basic_mdspan<span class="op">&amp;)</span> <span class="kw">noexcept</span> <span class="op">=</span> <span class="cf">default</span>;</span>
<span id="cb44-22"><a href="#cb44-22"></a>  <span class="kw">constexpr</span> basic_mdspan<span class="op">(</span>basic_mdspan<span class="op">&amp;&amp;)</span> <span class="kw">noexcept</span> <span class="op">=</span> <span class="cf">default</span>;</span>
<span id="cb44-23"><a href="#cb44-23"></a></span>
<span id="cb44-24"><a href="#cb44-24"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span><span class="op">...</span> IndexType<span class="op">&gt;</span></span>
<span id="cb44-25"><a href="#cb44-25"></a>    <span class="kw">explicit</span> <span class="kw">constexpr</span> basic_mdspan<span class="op">(</span>pointer p, IndexType<span class="op">...</span> dynamic_extents<span class="op">)</span>;</span>
<span id="cb44-26"><a href="#cb44-26"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> IndexType, <span class="dt">size_t</span> N<span class="op">&gt;</span></span>
<span id="cb44-27"><a href="#cb44-27"></a>    <span class="kw">explicit</span> <span class="kw">constexpr</span> basic_mdspan<span class="op">(</span>pointer p, <span class="kw">const</span> array<span class="op">&lt;</span>IndexType, N<span class="op">&gt;&amp;</span> dynamic_extents<span class="op">)</span>;</span>
<span id="cb44-28"><a href="#cb44-28"></a>  <span class="kw">constexpr</span> basic_mdspan<span class="op">(</span>pointer p, <span class="kw">const</span> mapping_type<span class="op">&amp;</span> m<span class="op">)</span>;</span>
<span id="cb44-29"><a href="#cb44-29"></a>  <span class="kw">constexpr</span> basic_mdspan<span class="op">(</span>pointer p, <span class="kw">const</span> mapping_type<span class="op">&amp;</span> m, <span class="kw">const</span> accessor_type<span class="op">&amp;</span> a<span class="op">)</span>;</span>
<span id="cb44-30"><a href="#cb44-30"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> OtherElementType, <span class="kw">class</span> OtherExtents, <span class="kw">class</span> OtherLayoutPolicy, <span class="kw">class</span> OtherAccessorPolicy<span class="op">&gt;</span></span>
<span id="cb44-31"><a href="#cb44-31"></a>    <span class="kw">constexpr</span> basic_mdspan<span class="op">(</span><span class="kw">const</span> basic_mdspan<span class="op">&lt;</span>OtherElementType, OtherExtents, OtherLayoutPolicy, OtherAccessorPolicy<span class="op">&gt;&amp;</span> other<span class="op">)</span>;</span>
<span id="cb44-32"><a href="#cb44-32"></a></span>
<span id="cb44-33"><a href="#cb44-33"></a>  <span class="kw">constexpr</span> basic_mdspan<span class="op">&amp;</span> <span class="kw">operator</span><span class="op">=(</span><span class="kw">const</span> basic_mdspan<span class="op">&amp;)</span> <span class="kw">noexcept</span> <span class="op">=</span> <span class="cf">default</span>;</span>
<span id="cb44-34"><a href="#cb44-34"></a>  <span class="kw">constexpr</span> basic_mdspan<span class="op">&amp;</span> <span class="kw">operator</span><span class="op">=(</span>basic_mdspan<span class="op">&amp;&amp;)</span> <span class="kw">noexcept</span> <span class="op">=</span> <span class="cf">default</span>;</span>
<span id="cb44-35"><a href="#cb44-35"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> OtherElementType, <span class="kw">class</span> OtherExtents, <span class="kw">class</span> OtherLayoutPolicy, <span class="kw">class</span> OtherAccessorPolicy<span class="op">&gt;</span></span>
<span id="cb44-36"><a href="#cb44-36"></a>    <span class="kw">constexpr</span> basic_mdspan<span class="op">&amp;</span> <span class="kw">operator</span><span class="op">=(</span><span class="kw">const</span> basic_mdspan<span class="op">&lt;</span>OtherElementType, OtherExtents, OtherLayoutPolicy, OtherAccessorPolicy<span class="op">&gt;&amp;</span> other<span class="op">)</span> <span class="kw">noexcept</span>;</span>
<span id="cb44-37"><a href="#cb44-37"></a></span>
<span id="cb44-38"><a href="#cb44-38"></a>  <span class="co">// [mdspan.basic.mapping], basic_mdspan mapping domain multidimensional index to access codomain element</span></span>
<span id="cb44-39"><a href="#cb44-39"></a>  <span class="kw">constexpr</span> reference <span class="kw">operator</span><span class="op">[](</span>index_type<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb44-40"><a href="#cb44-40"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span><span class="op">...</span> IndexType<span class="op">&gt;</span></span>
<span id="cb44-41"><a href="#cb44-41"></a>    <span class="kw">constexpr</span> reference <span class="kw">operator</span><span class="op">()(</span>IndexType<span class="op">...</span> indices<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb44-42"><a href="#cb44-42"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> IndexType, <span class="dt">size_t</span> N<span class="op">&gt;</span></span>
<span id="cb44-43"><a href="#cb44-43"></a>    <span class="kw">constexpr</span> reference <span class="kw">operator</span><span class="op">()(</span><span class="kw">const</span> array<span class="op">&lt;</span>IndexType, N<span class="op">&gt;&amp;</span> indices<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb44-44"><a href="#cb44-44"></a></span>
<span id="cb44-45"><a href="#cb44-45"></a>  accessor_type accessor<span class="op">()</span> <span class="kw">const</span> <span class="op">{</span> <span class="cf">return</span> acc_; <span class="op">}</span></span>
<span id="cb44-46"><a href="#cb44-46"></a></span>
<span id="cb44-47"><a href="#cb44-47"></a>  <span class="kw">static</span> <span class="kw">constexpr</span> <span class="dt">int</span> rank<span class="op">()</span> <span class="kw">noexcept</span> <span class="op">{</span> <span class="cf">return</span> Extents<span class="op">::</span>rank<span class="op">()</span>; <span class="op">}</span></span>
<span id="cb44-48"><a href="#cb44-48"></a>  <span class="kw">static</span> <span class="kw">constexpr</span> <span class="dt">int</span> rank_dynamic<span class="op">()</span> <span class="kw">noexcept</span> <span class="op">{</span> <span class="cf">return</span> Extents<span class="op">::</span>rank_dynamic<span class="op">()</span>; <span class="op">}</span></span>
<span id="cb44-49"><a href="#cb44-49"></a>  <span class="kw">static</span> <span class="kw">constexpr</span> index_type static_extent<span class="op">(</span><span class="dt">size_t</span> r<span class="op">)</span> <span class="kw">noexcept</span> <span class="op">{</span> <span class="cf">return</span> Extents<span class="op">::</span>static_extent<span class="op">(</span>r<span class="op">)</span>; <span class="op">}</span></span>
<span id="cb44-50"><a href="#cb44-50"></a></span>
<span id="cb44-51"><a href="#cb44-51"></a>  <span class="kw">constexpr</span> Extents extents<span class="op">()</span> <span class="kw">const</span> <span class="kw">noexcept</span> <span class="op">{</span> <span class="cf">return</span> map_<span class="op">.</span>extents<span class="op">()</span>; <span class="op">}</span></span>
<span id="cb44-52"><a href="#cb44-52"></a>  <span class="kw">constexpr</span> index_type extent<span class="op">(</span><span class="dt">size_t</span> r<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span> <span class="op">{</span> <span class="cf">return</span> extents<span class="op">().</span>extent<span class="op">(</span>r<span class="op">)</span>; <span class="op">}</span></span>
<span id="cb44-53"><a href="#cb44-53"></a>  <span class="kw">constexpr</span> index_type size<span class="op">()</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb44-54"><a href="#cb44-54"></a>  <span class="kw">constexpr</span> index_type unique_size<span class="op">()</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb44-55"><a href="#cb44-55"></a></span>
<span id="cb44-56"><a href="#cb44-56"></a>  <span class="co">// [mdspan.basic.codomain], basic_mdspan observers of the codomain</span></span>
<span id="cb44-57"><a href="#cb44-57"></a>  <span class="kw">constexpr</span> span<span class="op">&lt;</span>element_type<span class="op">&gt;</span> span<span class="op">()</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb44-58"><a href="#cb44-58"></a>  <span class="kw">constexpr</span> pointer data<span class="op">()</span> <span class="kw">const</span> <span class="kw">noexcept</span> <span class="op">{</span> <span class="cf">return</span> ptr_; <span class="op">}</span></span>
<span id="cb44-59"><a href="#cb44-59"></a></span>
<span id="cb44-60"><a href="#cb44-60"></a>  <span class="kw">static</span> <span class="kw">constexpr</span> <span class="dt">bool</span> is_always_unique<span class="op">()</span> <span class="kw">noexcept</span> <span class="op">{</span> <span class="cf">return</span> mapping_type<span class="op">::</span>is_always_unique<span class="op">()</span>; <span class="op">}</span></span>
<span id="cb44-61"><a href="#cb44-61"></a>  <span class="kw">static</span> <span class="kw">constexpr</span> <span class="dt">bool</span> is_always_contiguous<span class="op">()</span> <span class="kw">noexcept</span> <span class="op">{</span> <span class="cf">return</span> mapping_type<span class="op">::</span>is_always_contiguous<span class="op">()</span>; <span class="op">}</span></span>
<span id="cb44-62"><a href="#cb44-62"></a>  <span class="kw">static</span> <span class="kw">constexpr</span> <span class="dt">bool</span> is_always_strided<span class="op">()</span> <span class="kw">noexcept</span> <span class="op">{</span> <span class="cf">return</span> mapping_type<span class="op">::</span>is_always_strided<span class="op">()</span>; <span class="op">}</span></span>
<span id="cb44-63"><a href="#cb44-63"></a></span>
<span id="cb44-64"><a href="#cb44-64"></a>  <span class="kw">constexpr</span> mapping_type mapping<span class="op">()</span> <span class="kw">const</span> <span class="kw">noexcept</span> <span class="op">{</span> <span class="cf">return</span> map_; <span class="op">}</span></span>
<span id="cb44-65"><a href="#cb44-65"></a>  <span class="kw">constexpr</span> <span class="dt">bool</span> is_unique<span class="op">()</span> <span class="kw">const</span> <span class="kw">noexcept</span> <span class="op">{</span> <span class="cf">return</span> map_<span class="op">.</span>is_unique<span class="op">()</span>; <span class="op">}</span></span>
<span id="cb44-66"><a href="#cb44-66"></a>  <span class="kw">constexpr</span> <span class="dt">bool</span> is_contiguous<span class="op">()</span> <span class="kw">const</span> <span class="kw">noexcept</span> <span class="op">{</span> <span class="cf">return</span> map_<span class="op">.</span>is_contiguous<span class="op">()</span>; <span class="op">}</span> </span>
<span id="cb44-67"><a href="#cb44-67"></a>  <span class="kw">constexpr</span> <span class="dt">bool</span> is_strided<span class="op">()</span> <span class="kw">const</span> <span class="kw">noexcept</span> <span class="op">{</span> <span class="cf">return</span> map_<span class="op">.</span>is_strided<span class="op">()</span>; <span class="op">}</span></span>
<span id="cb44-68"><a href="#cb44-68"></a>  <span class="kw">constexpr</span> index_type stride<span class="op">(</span><span class="dt">size_t</span> r<span class="op">)</span> <span class="kw">const</span> <span class="op">{</span> <span class="cf">return</span> map_<span class="op">.</span>stride<span class="op">(</span>r<span class="op">)</span>; <span class="op">}</span></span>
<span id="cb44-69"><a href="#cb44-69"></a></span>
<span id="cb44-70"><a href="#cb44-70"></a><span class="kw">private</span><span class="op">:</span></span>
<span id="cb44-71"><a href="#cb44-71"></a>  accessor_type acc_<span class="op">{}</span>; <span class="co">// <em>exposition only</em></span></span>
<span id="cb44-72"><a href="#cb44-72"></a>  mapping_type map_<span class="op">{}</span>; <span class="co">// <em>exposition only</em></span></span>
<span id="cb44-73"><a href="#cb44-73"></a>  pointer ptr_<span class="op">{}</span>; <span class="co">// <em>exposition only</em></span></span>
<span id="cb44-74"><a href="#cb44-74"></a><span class="op">}</span>;</span>
<span id="cb44-75"><a href="#cb44-75"></a></span>
<span id="cb44-76"><a href="#cb44-76"></a><span class="op">}</span></span></code></pre></div>
<!-- mfh 20 Jan 2019: Putting the template parameters after the class declaration imitates [span.overview]. -->
<p><span class="marginalizedparent"><a class="marginalized">5</a></span> <code>ElementType</code> is required to be a complete object type that is neither an abstract class type nor an array type. <!-- mfh 20 Jan 2019: This imitates [span.overview] para 4 wording, with an additional restriction --></p>
<p><span class="marginalizedparent"><a class="marginalized">6</a></span> If <code>Extents</code> is not a (cv-unqualified) specialization of <code>extents</code>, then the program is ill-formed.</p>
<p><span class="marginalizedparent"><a class="marginalized">7</a></span> If <code>LayoutPolicy</code> does not meet the layout mapping policy requirements, then the program is ill-formed.</p>
<p><span class="marginalizedparent"><a class="marginalized">8</a></span> If <code>AccessorPolicy</code> does not meet the accessor policy requirements or if <code>std::is_same_v&lt;typename AccessorPolicy::element_type,ElementType&gt;</code> is <code>false</code>, then the program is ill-formed.</p>
<!--

 ##              #               #
#   ### ##   ## ### ### # # ### ### ### ###  ##
#   # # # #  #   #  #   # # #    #  # # #    #
#   ### # # ##   ## #   ### ###  ## ### #   ##
 ##

-->
<p><b>22.7.�.1 <code>basic_mdspan</code> constructors and assignment operators [mdspan.basic.cons]</b></p>
<div class="sourceCode" id="cb45"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb45-1"><a href="#cb45-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span><span class="op">...</span> IndexType<span class="op">&gt;</span></span>
<span id="cb45-2"><a href="#cb45-2"></a>  <span class="kw">explicit</span> <span class="kw">constexpr</span> basic_mdspan<span class="op">(</span>pointer ptr, IndexType<span class="op">...</span> dynamic_extents<span class="op">)</span>;</span></code></pre></div>
<ul>
<li><p><span class="marginalizedparent"><a class="marginalized">1</a></span> <em>Constraints:</em></p>
<ul>
<li><p><span class="marginalizedparent"><a class="marginalized">(1.1)</a></span> <code>(is_convertible_v&lt;IndexType, index_type&gt; &amp;&amp; ...)</code> is <code>true</code>,</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">(1.2)</a></span> <code>sizeof...(dynamic_extents) == rank_dynamic()</code> is <code>true</code>,</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">(1.3)</a></span> <code>is_constructible_v&lt;mapping_type, Extents&gt;</code> is <code>true</code>, and</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">(1.4)</a></span> <code>is_default_constructible_v&lt;accessor_type&gt;</code> is <code>true</code>.</p></li>
</ul></li>
<li><p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Effects:</em></p>
<ul>
<li><p><span class="marginalizedparent"><a class="marginalized">(2.1)</a></span> Initializes <code>ptr_</code> with <code>ptr</code>,</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">(2.2)</a></span> Initializes <code>map_</code> with <code>Extents(dynamic_extents...)</code>, and</p></li>
</ul></li>
<li><p><span class="marginalizedparent"><a class="marginalized">3</a></span> <em>Throws:</em> Nothing.</p></li>
</ul>
<div class="sourceCode" id="cb46"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb46-1"><a href="#cb46-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> IndexType, <span class="dt">size_t</span> N<span class="op">&gt;</span></span>
<span id="cb46-2"><a href="#cb46-2"></a>  <span class="kw">explicit</span> <span class="kw">constexpr</span> basic_mdspan<span class="op">(</span>pointer p, <span class="kw">const</span> array<span class="op">&lt;</span>IndexType, N<span class="op">&gt;&amp;</span> dynamic_extents<span class="op">)</span>;</span></code></pre></div>
<ul>
<li><p><span class="marginalizedparent"><a class="marginalized">4</a></span> <em>Constraints:</em></p>
<ul>
<li><p><span class="marginalizedparent"><a class="marginalized">(4.1)</a></span> <code>is_convertible_v&lt;IndexType, index_type&gt;</code> is <code>true</code>,</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">(4.2)</a></span> <code>N == rank_dynamic()</code> is <code>true</code>,</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">(4.3)</a></span> <code>is_constructible_v&lt;mapping_type, Extents&gt;</code> is <code>true</code>, and</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">(4.4)</a></span> <code>is_default_constructible_v&lt;accessor_type&gt;</code> is <code>true</code>.</p></li>
</ul></li>
<li><p><span class="marginalizedparent"><a class="marginalized">5</a></span> <em>Effects:</em> Equivalent to: <code>basic_mdspan(p, dynamic_extents[Rs]...)</code>, with <code>Rs...</code> from <code>index_sequence&lt;Rs...&gt;</code> matching <code>make_index_sequence&lt;N&gt;</code>.</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">6</a></span> <em>Throws:</em> Nothing.</p></li>
</ul>
<div class="sourceCode" id="cb47"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb47-1"><a href="#cb47-1"></a><span class="kw">constexpr</span> basic_mdspan<span class="op">(</span>pointer p, <span class="kw">const</span> mapping_type<span class="op">&amp;</span> m<span class="op">)</span>;</span></code></pre></div>
<ul>
<li><p><span class="marginalizedparent"><a class="marginalized">7</a></span> <em>Constraints:</em> <code>is_default_constructible_v&lt;accessor_type&gt;</code> is <code>true</code>.</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">8</a></span> <em>Effects:</em></p>
<ul>
<li><p><span class="marginalizedparent"><a class="marginalized">(8.1)</a></span> Initializes <code>ptr_</code> with <code>p</code>,</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">(8.2)</a></span> Initializes <code>map_</code> with <code>m</code>, and</p></li>
</ul></li>
<li><p><span class="marginalizedparent"><a class="marginalized">9</a></span> <em>Throws:</em> Nothing.</p></li>
</ul>
<div class="sourceCode" id="cb48"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb48-1"><a href="#cb48-1"></a><span class="kw">constexpr</span> basic_mdspan<span class="op">(</span>pointer p, <span class="kw">const</span> mapping_type<span class="op">&amp;</span> m, <span class="kw">const</span> accessor_type<span class="op">&amp;</span> a<span class="op">)</span>;</span></code></pre></div>
<ul>
<li><p><span class="marginalizedparent"><a class="marginalized">10</a></span><em>Effects:</em></p>
<ul>
<li><p><span class="marginalizedparent"><a class="marginalized">(10.1)</a></span> Initializes <code>ptr_</code> with <code>p</code>,</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">(10.2)</a></span> Initializes <code>map_</code> with <code>m</code>, and</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">(10.3)</a></span> Initializes <code>acc_</code> with <code>a</code>.</p></li>
</ul></li>
<li><p><span class="marginalizedparent"><a class="marginalized">11</a></span> <em>Throws:</em> Nothing.</p></li>
</ul>
<div class="sourceCode" id="cb49"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb49-1"><a href="#cb49-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> OtherElementType, <span class="kw">class</span> OtherExtents, <span class="kw">class</span> OtherLayoutPolicy, <span class="kw">class</span> OtherAccessor<span class="op">&gt;</span></span>
<span id="cb49-2"><a href="#cb49-2"></a>  <span class="kw">constexpr</span> basic_mdspan<span class="op">(</span><span class="kw">const</span> basic_mdspan<span class="op">&lt;</span>OtherElementType, OtherExtents, OtherLayoutPolicy, OtherAccessor<span class="op">&gt;&amp;</span> other<span class="op">)</span>;</span></code></pre></div>
<ul>
<li><p><span class="marginalizedparent"><a class="marginalized">12</a></span> <em>Constraints:</em></p>
<ul>
<li><p><span class="marginalizedparent"><a class="marginalized">(12.1)</a></span> <code>is_convertible_v&lt;OtherLayoutPolicy::template mapping&lt;OtherExtents&gt;, mapping_type</code> is <code>true</code>;</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">(12.2)</a></span> <code>is_convertible_v&lt;OtherAccessor, Accessor&gt;</code> is <code>true</code>;</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">(12.3)</a></span> <code>is_convertible_v&lt;OtherAccessor::pointer, pointer&gt;</code> is <code>true</code>;</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">(12.4)</a></span> <code>is_convertible_v&lt;OtherExtents, extents_type&gt;</code> is <code>true</code>; and</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">(12.5)</a></span> For all <code>r</code> in the range <code>[0, rank())</code>, if <code>other.static_extent(r) != dynamic_extent &amp;&amp; static_extent(r) != dynamic_extent</code> is <code>true</code>, then <code>other.static_extent(r) == static_extent(r)</code> is <code>true</code>.</p></li>
</ul></li>
<li><p><span class="marginalizedparent"><a class="marginalized">13</a></span> <em>Expects:</em> For all <code>r</code> in the range <code>[0, rank())</code>, if <code>other.static_extent(r) == dynamic_extent || static_extent(r) == dynamic_extent</code> is <code>true</code>, then <code>other.extent(r) == extent(r)</code> is <code>true</code>.</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">14</a></span> <em>Effects:</em></p>
<ul>
<li><p><span class="marginalizedparent"><a class="marginalized">(14.1)</a></span> Initializes <code>ptr_</code> with <code>other.ptr_</code>,</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">(14.2)</a></span> initializes <code>map_</code> with <code>other.map_</code>, and</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">(14.3)</a></span> initializes <code>acc_</code> with <code>other.acc_</code>.</p></li>
</ul></li>
<li><p><span class="marginalizedparent"><a class="marginalized">15</a></span> <em>Throws:</em> Nothing.</p></li>
</ul>
<div class="sourceCode" id="cb50"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb50-1"><a href="#cb50-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> OtherElementType, <span class="kw">class</span> OtherExtents, <span class="kw">class</span> OtherLayoutPolicy, <span class="kw">class</span> OtherAccessor<span class="op">&gt;</span></span>
<span id="cb50-2"><a href="#cb50-2"></a>  <span class="kw">constexpr</span> basic_mdspan<span class="op">&amp;</span> <span class="kw">operator</span><span class="op">=(</span><span class="kw">const</span> basic_mdspan<span class="op">&lt;</span>OtherElementType, OtherExtents, OtherLayoutPolicy, OtherAccessor<span class="op">&gt;&amp;</span> other<span class="op">)</span>;</span></code></pre></div>
<!-- NOTE is_assignable_v<T, U> means T is assignable from U -->
<ul>
<li><p><span class="marginalizedparent"><a class="marginalized">16</a></span> <em>Constraints:</em></p>
<ul>
<li><p><span class="marginalizedparent"><a class="marginalized">(16.1)</a></span> <code>is_assignable_v&lt;mapping_type, OtherLayoutPolicy::template mapping&lt;OtherExtents&gt;&gt;</code> is <code>true</code>;</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">(16.2)</a></span> <code>is_assignable_v&lt;Accessor, OtherAccessor&gt;</code> is <code>true</code>;</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">(16.3)</a></span> <code>is_assignable_v&lt;pointer, OtherAccessor::pointer&gt;</code> is <code>true</code>;</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">(16.4)</a></span> <code>OtherExtents::rank() == rank()</code> is <code>true</code>; and</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">(16.5)</a></span> For all <code>r</code> in the range <code>[0, rank())</code>, if <code>other.static_extent(r) != dynamic_extent &amp;&amp; static_extent(r) != dynamic_extent</code> is <code>true</code>, then <code>other.static_extent(r) == static_extent(r)</code> is <code>true</code>.</p></li>
</ul></li>
<li><p><span class="marginalizedparent"><a class="marginalized">17</a></span> <em>Expects:</em> For all <code>r</code> in the range <code>[0, rank())</code>, if <code>other.static_extent(r) == dynamic_extent || static_extent(r) == dynamic_extent</code> is <code>true</code>, then <code>other.extent(r) == extent(r)</code> is <code>true</code>.</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">18</a></span> <em>Effects:</em></p>
<ul>
<li><p><span class="marginalizedparent"><a class="marginalized">(18.1)</a></span> Assigns <code>other.ptr_</code> to <code>ptr_</code>,</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">(18.2)</a></span> Assigns <code>other.map_</code> to <code>map_</code>, and</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">(18.3)</a></span> Assigns <code>other.acc_</code> to <code>acc_</code>.</p></li>
</ul></li>
<li><p><span class="marginalizedparent"><a class="marginalized">17</a></span> <em>Throws:</em> Nothing.</p></li>
</ul>
<!--

  #              #                           #
### ### ###  ##     ##      ###  ## ### ###     ##  ###
# # # # ### # #  #  # #     ### # # # # # #  #  # # # #
### ### # # ###  ## # #     # # ### ### ###  ## # #  ##
                                    #   #           ###
-->
<p><br /> <b>22.7.�.2 <code>basic_mdspan</code> members [mdspan.basic.members]</b></p>
<div class="sourceCode" id="cb51"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb51-1"><a href="#cb51-1"></a><span class="kw">constexpr</span> reference <span class="kw">operator</span><span class="op">[](</span>index_type i<span class="op">)</span> <span class="kw">const</span>;</span></code></pre></div>
<ul>
<li><p><span class="marginalizedparent"><a class="marginalized">1</a></span> <em>Constraints:</em> <code>rank() == 1</code> is <code>true</code>.</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">2</a></span> <em>Expects:</em> <code>acc_.access(ptr_, map_(i))</code> shall be valid.</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">3</a></span> <em>Effects:</em> Equivalent to: <code>return (*this)(i);</code>.</p></li>
</ul>
<p><br /></p>
<div class="sourceCode" id="cb52"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb52-1"><a href="#cb52-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span><span class="op">...</span> IndexType<span class="op">&gt;</span></span>
<span id="cb52-2"><a href="#cb52-2"></a>  <span class="kw">constexpr</span> reference <span class="kw">operator</span><span class="op">()(</span>IndexType<span class="op">...</span> indices<span class="op">)</span> <span class="kw">const</span>;</span></code></pre></div>
<ul>
<li><p><span class="marginalizedparent"><a class="marginalized">4</a></span> <em>Constraints:</em></p>
<ul>
<li><p><span class="marginalizedparent"><a class="marginalized">(4.1)</a></span> <code>(is_convertible_v&lt;IndexType, index_type&gt; &amp;&amp; ...)</code> is <code>true</code>, and</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">(4.2)</a></span> <code>sizeof...(IndexType) == rank()</code> is <code>true</code>.</p></li>
</ul></li>
<li><p><span class="marginalizedparent"><a class="marginalized">5</a></span> <em>Expects:</em> <code>acc_.access(ptr_, map_(indices...))</code> shall be valid.</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">6</a></span> <em>Effects:</em> Equivalent to: <code>return acc_.access(ptr_, map_(indices...));</code>.</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">7</a></span> <em>Throws:</em> Nothing.</p></li>
</ul>
<div class="sourceCode" id="cb53"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb53-1"><a href="#cb53-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> IndexType, <span class="dt">size_t</span> N<span class="op">&gt;</span></span>
<span id="cb53-2"><a href="#cb53-2"></a>  <span class="kw">constexpr</span> reference <span class="kw">operator</span><span class="op">()(</span><span class="kw">const</span> array<span class="op">&lt;</span>IndexType, N<span class="op">&gt;&amp;</span> indices<span class="op">)</span> <span class="kw">const</span>;</span></code></pre></div>
<ul>
<li><p><span class="marginalizedparent"><a class="marginalized">8</a></span> <em>Constraints:</em></p>
<ul>
<li><p><span class="marginalizedparent"><a class="marginalized">(8.1)</a></span> <code>is_convertible_v&lt;IndexType, index_type&gt;</code> is <code>true</code>, and</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">(8.2)</a></span> <code>rank() == N</code> is <code>true</code>.</p></li>
</ul></li>
<li><p><span class="marginalizedparent"><a class="marginalized">9</a></span> <em>Effects:</em> Equivalent to: <code>return std::apply(*this, indices);</code>.</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">10</a></span> <em>Throws:</em> nothing.</p></li>
</ul>
<div class="sourceCode" id="cb54"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb54-1"><a href="#cb54-1"></a><span class="kw">constexpr</span> index_type size<span class="op">()</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<ul>
<li><span class="marginalizedparent"><a class="marginalized">11</a></span> <em>Returns:</em> Product of <code>extent(r)</code> for all <code>r</code> in the range <code>[0, Extents::rank())</code>.</li>
</ul>
<div class="sourceCode" id="cb55"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb55-1"><a href="#cb55-1"></a><span class="kw">constexpr</span> index_type unique_size<span class="op">()</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<ul>
<li><span class="marginalizedparent"><a class="marginalized">12</a></span> <em>Returns:</em> The number of unique elements in the codomain. <em>[Note:_ If <code>mapping().is_unique()</code> is <code>true</code>, this is identical to <code>size()</code>. _—end note]</em></li>
</ul>
<div class="sourceCode" id="cb56"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb56-1"><a href="#cb56-1"></a><span class="kw">constexpr</span> span<span class="op">&lt;</span>element_type<span class="op">&gt;</span> span<span class="op">()</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<ul>
<li><span class="marginalizedparent"><a class="marginalized">13</a></span> <em>Effects:</em> Equivalent to: <code>return span&lt;element_type&gt;(acc_.decay(ptr_), required_span_size());</code>.</li>
</ul>
<!--
subspan

                     /$$
                    | $$
  /$$$$$$$ /$$   /$$| $$$$$$$   /$$$$$$$  /$$$$$$   /$$$$$$  /$$$$$$$
 /$$_____/| $$  | $$| $$__  $$ /$$_____/ /$$__  $$ |____  $$| $$__  $$
|  $$$$$$ | $$  | $$| $$  \ $$|  $$$$$$ | $$  \ $$  /$$$$$$$| $$  \ $$
 \____  $$| $$  | $$| $$  | $$ \____  $$| $$  | $$ /$$__  $$| $$  | $$
 /$$$$$$$/|  $$$$$$/| $$$$$$$/ /$$$$$$$/| $$$$$$$/|  $$$$$$$| $$  | $$
|_______/  \______/ |_______/ |_______/ | $$____/  \_______/|__/  |__/
                                        | $$
                                        | $$
                                        |__/
-->
<p><b>22.7.� subspan [mdspan.subspan]</b></p>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span> <code>subspan</code> creates a <code>basic_mdspan</code> with a domain that is a subset of the input <code>basic_mdspan</code>’s domain, and a codomain that is a subset of the input <code>basic_mdspan</code>’s codomain.</p>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span> The <code>SliceSpecifier</code> template argument(s) and the corresponding value(s) of the arguments of <code>subspan</code> after <code>src</code> determine the subset of <code>src</code> that the <code>basic_mdspan</code> returned by <code>subspan</code> views.</p>
<div class="sourceCode" id="cb57"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb57-1"><a href="#cb57-1"></a><span class="kw">namespace</span> std <span class="op">{</span></span>
<span id="cb57-2"><a href="#cb57-2"></a></span>
<span id="cb57-3"><a href="#cb57-3"></a>  <span class="co">// [mdspan.subspan], subspan creation</span></span>
<span id="cb57-4"><a href="#cb57-4"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> ElementType, <span class="kw">class</span> Extents, <span class="kw">class</span> LayoutPolicy,</span>
<span id="cb57-5"><a href="#cb57-5"></a>           <span class="kw">class</span> AccessorPolicy, <span class="kw">class</span><span class="op">...</span> SliceSpecifiers<span class="op">&gt;</span></span>
<span id="cb57-6"><a href="#cb57-6"></a>      basic_mdspan<span class="op">&lt;</span><em>see below</em><span class="op">&gt;</span></span>
<span id="cb57-7"><a href="#cb57-7"></a>      subspan<span class="op">(</span><span class="kw">const</span> basic_mdspan<span class="op">&lt;</span>ElementType, Extents, LayoutPolicy,</span>
<span id="cb57-8"><a href="#cb57-8"></a>                                 AccessorPolicy<span class="op">&gt;&amp;</span> src, SliceSpecifiers<span class="op">...</span> slices<span class="op">)</span> <span class="kw">noexcept</span>;</span>
<span id="cb57-9"><a href="#cb57-9"></a><span class="op">}</span></span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span> Let <code>sub</code> be the return value of <code>subspan(src, slices...)</code>, let <span class="math inline"><em>s</em><sub><em>k</em></sub></span> be the <span class="math inline"><em>k</em></span>-th element of <code>slices...</code>, and let <span class="math inline"><em>S</em><sub><em>k</em></sub></span> be the type of the <span class="math inline"><em>k</em></span>-th element of <code>slices...</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">4</a></span> Define <code>map_rank</code> as an <code>array&lt;ptrdiff_t,src.rank()&gt;</code> such that <code>map_rank[j]</code> equals <code>-1</code> if <code>is_convertible_v&lt;</code><span class="math inline"><em>S</em><sub><em>j</em></sub></span><code>,ptrdiff_t&gt;</code> is <code>true</code>, or else <code>map_rank[j]</code> equals the number of <span class="math inline"><em>S</em><sub><em>k</em></sub></span> with <span class="math inline"><em>k</em> &lt; <em>j</em></span> such that <code>is_convertible_v&lt;</code><span class="math inline"><em>S</em><sub><em>k</em></sub></span><code>,pair&lt;ptrdiff_t,ptrdiff_t&gt;&gt; || is_convertible_v&lt;</code><span class="math inline"><em>S</em><sub><em>k</em></sub></span><code>,all_type&gt;</code> is <code>true</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">5</a></span> Let <code>first</code> and <code>last</code> be exposition-only variables of type <code>array&lt;ptrdiff_t,src.rank()&gt;</code>. For <span class="math inline"><em>r</em></span> in the range <span class="math inline">[0,</span> <code>src.rank()</code><span class="math inline">)</span>, define the values of <code>first[r]</code> and <code>last[r]</code> as follows:</p>
<ul>
<li>if <code>is_convertible_v&lt;</code><span class="math inline"><em>S</em><sub><em>r</em></sub></span><code>,ptrdiff_t&gt;</code>, then <code>first[r]</code> equals <span class="math inline"><em>s</em><sub><em>r</em></sub></span>, and <code>last[r]</code> equals <code>first[r]</code> + 1;</li>
<li>otherwise, if <code>is_convertible_v&lt;</code><span class="math inline"><em>S</em><sub><em>r</em></sub></span><code>,pair&lt;ptrdiff_t,ptrdiff_t&gt;&gt;</code>, then <code>first[r]</code> equals <code>p.first</code>, and <code>last[r]</code> equals <code>p.second</code>, where <code>p</code> is the result of converting <span class="math inline"><em>s</em><sub><em>r</em></sub></span> to <code>pair&lt;ptrdiff_t,ptrdiff_t&gt;</code>;</li>
<li>otherwise, if <code>is_convertible_v&lt;</code><span class="math inline"><em>S</em><sub><em>r</em></sub></span><code>,all_type&gt;</code>, then <code>first[r]</code> equals <code>0</code>, and <code>last[r]</code> equals <code>src.extent(r)</code>.</li>
</ul>
<p><span class="marginalizedparent"><a class="marginalized">6</a></span> <em>Constraints:</em></p>
<ul>
<li><code>sizeof(slices...)</code> equals <code>src.rank()</code>,</li>
<li><code>LayoutPolicy</code> is <code>layout_left</code>, <code>layout_right</code>, <code>layout_stride</code>, or any type in a possibly empty set of implementation-defined types, each of which meets the requirements of a layout mapping policy <b>[mdspan.layout.reqs]</b> <em>[Note:* Implementation and user defined layout mapping policies could exist, for which taking an arbitrary <code>subspan</code> does not make sense. *— end note]</em>; and</li>
<li>For all <code>k</code> in the range <code>[0, src.rank())</code>, <code>is_convertible_v&lt;</code><span class="math inline"><em>S</em><sub><em>k</em></sub></span><code>,ptrdiff_t&gt; || is_convertible_v&lt;</code><span class="math inline"><em>S</em><sub><em>k</em></sub></span><code>,pair&lt;ptrdiff_t,ptrdiff_t&gt;&gt; || is_convertible_v&lt;</code><span class="math inline"><em>S</em><sub><em>k</em></sub></span><code>,all_type&gt;</code> is <code>true</code>.</li>
</ul>
<p><span class="marginalizedparent"><a class="marginalized">7</a></span> <em>Expects:</em></p>
<ul>
<li>For <span class="math inline">0 ≤</span> <code>r</code> &lt; <code>src.rank()</code>, <code>0 &lt;= first[r] &amp;&amp; first[r] &lt;= last[r] &amp;&amp; last[r] &lt;= src.extent(r)</code> is <code>true</code>.</li>
</ul>
<p><span class="marginalizedparent"><a class="marginalized">8</a></span> <em>Ensures:</em> All of the following:</p>
<ul>
<li><code>sub.rank()</code> equals the number of <span class="math inline"><em>k</em></span> such that <code>is_convertible_v&lt;</code><span class="math inline"><em>S</em><sub><em>k</em></sub></span><code>,pair&lt;ptrdiff_t,ptrdiff_t&gt;&gt; || is_convertible_v&lt;</code><span class="math inline"><em>S</em><sub><em>k</em></sub></span><code>,all_type&gt;</code> is <code>true</code>.</li>
<li>Let the pack <code>i...</code> denote a multidimensional index in the domain of <code>src</code> with <span class="math inline"><em>i</em><sub><em>k</em></sub></span> denoting the <span class="math inline"><em>k</em></span>-th element of <code>i...</code>, such that <span class="math inline"><em>i</em><sub><em>k</em></sub></span> is greater than or equal to <code>first[k]</code> and <span class="math inline"><em>i</em><sub><em>k</em></sub></span> is less than <code>last[k]</code> for all <code>k</code> in the range <span class="math inline">[0,</span><code>src.rank()</code><span class="math inline">)</span>. Let the pack <code>j...</code> denote a multidimensional index in the domain of <code>sub</code> with <span class="math inline"><em>j</em><sub><em>s</em></sub></span> denoting the <span class="math inline"><em>s</em></span>-th element of <code>j...</code>, such that <span class="math inline"><em>j</em><sub><em>s</em></sub></span> is equal to <span class="math inline"><em>i</em><sub><em>k</em></sub></span> minus <code>first[k]</code> where <code>map_rank[k]</code> equals <code>s</code> for all <code>s</code> in the range <span class="math inline">[0,</span><code>sub.rank()</code><span class="math inline">)</span>. Then <code>sub(j...)</code> and <code>src(i...)</code> refer to the same element in the codomain of <code>src</code>.</li>
<li>For <span class="math inline">0 ≤</span> <code>k</code> &lt; <code>src.rank()</code>, if <code>map_rank[k] != -1</code> is <code>true</code>, then <code>sub.extent(map_rank[k])</code> equals <code>last[k] - first[k]</code>.</li>
<li>If <code>src.is_strided()</code> is <code>true</code>, then <code>sub.is_strided()</code> is <code>true</code>, and for all <code>k</code> in the range <code>[0, src.rank())</code>, if <code>map_rank[k] != -1</code> is <code>true</code>, then <code>sub.stride(map_rank[k])</code> equals <code>src.stride(k)</code>.</li>
<li>For all <code>k</code> in the range <code>[0, src.rank())</code>, if <code>map_rank[k] != -1</code> is <code>true</code> and <code>src.static_extent(k)</code> does not equal <code>dynamic_extent</code> and <code>is_convertible_v&lt;</code><span class="math inline"><em>S</em><sub><em>k</em></sub></span><code>,all_type&gt;</code> is <code>true</code>, then <code>sub.static_extent(map_rank[k])</code> equals <code>src.static_extent(k)</code>.</li>
</ul>
<p><br /></p>
<p><em>[Note:</em> Example of <code>subspan</code> use:</p>
<div class="sourceCode" id="cb58"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb58-1"><a href="#cb58-1"></a><span class="co">// Create a mapping</span></span>
<span id="cb58-2"><a href="#cb58-2"></a><span class="kw">typedef</span> extents<span class="op">&lt;</span><span class="dv">3</span>,dynamic_extent,<span class="dv">7</span><span class="op">&gt;</span> Extents3D;</span>
<span id="cb58-3"><a href="#cb58-3"></a>layout_right<span class="op">::</span><span class="kw">template</span> mapping<span class="op">&lt;</span>Extents3D<span class="op">&gt;</span> map_right<span class="op">(</span><span class="dv">10</span><span class="op">)</span>;</span>
<span id="cb58-4"><a href="#cb58-4"></a></span>
<span id="cb58-5"><a href="#cb58-5"></a><span class="co">// Allocate a basic_mdspan</span></span>
<span id="cb58-6"><a href="#cb58-6"></a><span class="dt">int</span><span class="op">*</span> ptr <span class="op">=</span> <span class="kw">new</span> <span class="dt">int</span><span class="op">[</span><span class="dv">3</span><span class="op">*</span><span class="dv">8</span><span class="op">*</span><span class="dv">10</span><span class="op">]</span>;</span>
<span id="cb58-7"><a href="#cb58-7"></a>basic_mdspan<span class="op">&lt;</span><span class="dt">int</span>,Extents3D,layout_right<span class="op">&gt;</span> a<span class="op">(</span>ptr,map_right<span class="op">)</span>;</span>
<span id="cb58-8"><a href="#cb58-8"></a></span>
<span id="cb58-9"><a href="#cb58-9"></a><span class="co">// Initialize the span</span></span>
<span id="cb58-10"><a href="#cb58-10"></a><span class="cf">for</span><span class="op">(</span><span class="dt">int</span> i0<span class="op">=</span><span class="dv">0</span>; i0<span class="op">&lt;</span>a<span class="op">.</span>extent<span class="op">(</span><span class="dv">0</span><span class="op">)</span>; i0<span class="op">++)</span></span>
<span id="cb58-11"><a href="#cb58-11"></a>  <span class="cf">for</span><span class="op">(</span><span class="dt">int</span> i1<span class="op">=</span><span class="dv">0</span>; i1<span class="op">&lt;</span>a<span class="op">.</span>extent<span class="op">(</span><span class="dv">1</span><span class="op">)</span>; i1<span class="op">++)</span></span>
<span id="cb58-12"><a href="#cb58-12"></a>    <span class="cf">for</span><span class="op">(</span><span class="dt">int</span> i2<span class="op">=</span><span class="dv">0</span>; i2<span class="op">&lt;</span>a<span class="op">.</span>extent<span class="op">(</span><span class="dv">2</span><span class="op">)</span>; i2<span class="op">++)</span></span>
<span id="cb58-13"><a href="#cb58-13"></a>      a<span class="op">(</span>i0,i1,i2<span class="op">)</span> <span class="op">=</span> <span class="dv">10000</span><span class="op">*</span>i0<span class="op">+</span><span class="dv">100</span><span class="op">*</span>i1<span class="op">+</span>i2;</span>
<span id="cb58-14"><a href="#cb58-14"></a></span>
<span id="cb58-15"><a href="#cb58-15"></a><span class="co">// Create Subspan</span></span>
<span id="cb58-16"><a href="#cb58-16"></a><span class="kw">auto</span> a_sub <span class="op">=</span> subspan<span class="op">(</span>a,<span class="dv">1</span>,std<span class="op">::</span>pair<span class="op">&lt;</span><span class="dt">int</span>,<span class="dt">int</span><span class="op">&gt;(</span><span class="dv">4</span>,<span class="dv">6</span><span class="op">)</span>,std<span class="op">::</span>pair<span class="op">&lt;</span><span class="dt">int</span>,<span class="dt">int</span><span class="op">&gt;(</span><span class="dv">1</span>,<span class="dv">6</span><span class="op">))</span>;</span>
<span id="cb58-17"><a href="#cb58-17"></a></span>
<span id="cb58-18"><a href="#cb58-18"></a><span class="co">// Print values of subspan</span></span>
<span id="cb58-19"><a href="#cb58-19"></a><span class="cf">for</span><span class="op">(</span><span class="dt">int</span> i0<span class="op">=</span><span class="dv">0</span>; i0<span class="op">&lt;</span>a_sub<span class="op">.</span>extent<span class="op">(</span><span class="dv">0</span><span class="op">)</span>; i0<span class="op">++)</span> <span class="op">{</span></span>
<span id="cb58-20"><a href="#cb58-20"></a>  <span class="cf">for</span><span class="op">(</span><span class="dt">int</span> i1<span class="op">=</span><span class="dv">0</span>; i1<span class="op">&lt;</span>a_sub<span class="op">.</span>extent<span class="op">(</span><span class="dv">1</span><span class="op">)</span>; i1<span class="op">++)</span> <span class="op">{</span></span>
<span id="cb58-21"><a href="#cb58-21"></a>    std<span class="op">::</span>cout <span class="op">&lt;&lt;</span> a_sub<span class="op">(</span>i0,i1<span class="op">)</span> <span class="op">&lt;&lt;</span> <span class="st">&quot; &quot;</span>;</span>
<span id="cb58-22"><a href="#cb58-22"></a>  <span class="op">}</span></span>
<span id="cb58-23"><a href="#cb58-23"></a>  std<span class="op">::</span>cout <span class="op">&lt;&lt;</span> std<span class="op">::</span>endl;</span>
<span id="cb58-24"><a href="#cb58-24"></a><span class="op">}</span></span>
<span id="cb58-25"><a href="#cb58-25"></a></span>
<span id="cb58-26"><a href="#cb58-26"></a><span class="co">/* Output</span></span>
<span id="cb58-27"><a href="#cb58-27"></a><span class="co">10401 10402 10403 10404 10405</span></span>
<span id="cb58-28"><a href="#cb58-28"></a><span class="co">10501 10502 10503 10504 10505</span></span>
<span id="cb58-29"><a href="#cb58-29"></a><span class="co">*/</span></span></code></pre></div>
<p><em>- end note]</em></p>
<h1 data-number="5" id="next-steps" data-number="5"><span class="header-section-number">5</span> Next Steps<a href="#next-steps" class="self-link"></a></h1>
<ul>
<li>Wording editing as per guidance from LWG.</li>
</ul>
<h1 data-number="6" id="related-work" data-number="6"><span class="header-section-number">6</span> Related Work<a href="#related-work" class="self-link"></a></h1>
<p><a href="https://issues.isocpp.org/show_bug.cgi?id=80">LEWG issue</a></p>
<p><b>Previous paper:</b></p>
<ul>
<li>[[N4355]]</li>
</ul>
<p><b>P0860 : Access Policy Generating Proxy Reference</b></p>
<p>The <code>reference</code> type may be a proxy for accessing an <code>element_type</code> object. For example, the <em>atomic</em> <code>AccessorPolicy</code> in <b>P0860</b> defines <code>AccessorPolicy::template accessor_type&lt;T&gt;::reference</code> to be <code>atomic_ref&lt;T&gt;</code> from <b>P0019</b>.</p>
<p><b>Related papers:</b></p>
<ul>
<li><b>P0122</b> : span: bounds-safe views for sequences of objects The <code>mdspan</code> codomain concept of <em>span</em> is well-aligned with this paper.</li>
<li><b>P0367</b> : Accessors: The P0367 Accessors proposal includes polymorphic mechanisms for accessing the memory an object or span of objects. The <code>AccessorPolicy</code> extension point in this proposal is intended to include such memory access properties.</li>
<li><b>P0331</b> : Motivation and Examples for Multidimensional Array</li>
<li><b>P0332</b> : Relaxed Incomplete Multidimensional Array Type Declaration</li>
<li><b>P0454</b> : Wording for a Minimal <code>mdspan</code> Included proposed modification of <code>span</code> to better align <code>span</code> with <code>mdspan</code>.</li>
<li><b>P0546</b> : Preparing <code>span</code> for the future Proposed modification of <code>span</code></li>
<li><b>P0856</b> : Restrict access property for <code>mdspan</code> and <code>span</code></li>
<li><b>P0860</b> : atomic access policy for <code>mdspan</code></li>
<li><b>P0900</b> : An Ontology of Properties for <code>mdspan</code></li>
</ul>
</div>
</div>
</body>
</html>
