P0009.bs

<pre class='metadata'>
Title:  <code>mdspan</code>: A Non-Owning Multidimensional Array Reference
Shortname: D0009
URL: wg21.link/P0009r6
Revision: 7
Audience: LWG
Status: D
Group: WG21
Issue Tracking: GitHub https://github.com/ORNL/cpp-proposals-pub
!Source: <a href="https://github.com/ORNL/cpp-proposals-pub/blob/master/P0009/P0009.bs">github.com/ORNL/cpp-proposals-pub/blob/master/P0009/P0009.bs</a>
No Abstract: yes
Markup Shorthands: markdown yes
Markup Shorthands: biblio yes
Editor: H. Carter Edwards, hedwards@nvidia.com
Editor: Bryce Adelstein Lelbach, blelbach@nvidia.com
Editor: Daniel Sunderland, dsunder@sandia.gov
Editor: David Hollman, dshollm@sandia.gov
Editor: Christian Trott, crtrott@sandia.gov
Editor: Mauro Bianco, mbianco@cscs.ch
Editor: Ben Sander, ben.sander@amd.com
Editor: Athanasios Iliopoulos, athanasios.iliopoulos@nrl.navy.mil
Editor: John Michopoulos, john.michopoulos@nrl.navy.mil
</pre>

Revision History
================

## P0009r7: Post 2018-06-Rapperswil Mailing

- [LWG review at 2018-06-Rapperswil](wiki.edge.com/bin/view/Wg21rapperswil2018/LWGSatAM)
- usage of `span` requires reference to C++20 working draft
- namespace for library TS `std::experimental::fundamentals_v3`
- exposition only members are in italics and each is marked with *exposition only*

## P0009r6 : Pre 2018-06-Rapperswil Mailing

P0009r5 was not taken up at 2018-03-Jacksonville meeting. Related [LEWG
review of P0900 at 2018-03-Jacksonville
meeting](http://wiki.edg.com/bin/view/Wg21jacksonville2018/P0900)

**LEWG Poll**: We want the ability to customize the access to elements
of span (ability to restrict, etc):

```c++
span<T, N, Accessor=...>
```

<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>

**LEWG Poll**: We want the customization of `basic_mdspan` to be two
concepts `Mapper` and `Accessor` (akin to `Allocator` design).

```c++
basic_mdspan<T, Extents, Mapper, Accessor>
mdspan<T, N...>
```

<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>

**LEWG Poll**: We want the customization of `basic_mdspan` to be an
arbitrary (and potentially user-extensible) list of properties.

```c++
basic_mdspan<T, Extents, Properties...>
```

<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>

**Changes from P0009r5 due to related LEWG reviews**:

-   Replaced variadic property list with *extents*, *layout mapping*,
    and *accessor* properties.
-   Incorporated [P0454r1](https://wg21.link/P0454r1).
    -   Added accessor policy concept.
    -   Renamed `mdspan` to `basic_mdspan`.
    -   Added a `mdspan` alias to `basic_mdspan`.

## P0009r5 : Pre 2018-03-Jacksonville Mailing

[LEWG review of P0009r4 at 2017-11-Albuquerque
meeting](http://wiki.edg.com/bin/view/Wg21albuquerque/P0009)

**LEWG Poll**: We should be able to index with `span<int type[N]>` (in
addition to array).

<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>

Against comment - there is not a proven needs for this feature.

**LEWG Poll**: We should be able to index with 1d `mdspan`.

<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>

**LEWG Poll**: We should put the requirement on "rank() <= N" back to
"rank() == N".

*Unanimous consent*

**LEWG Poll**: With the editorial changes from small group, plus the
above polls, forward this to LWG for Fundamentals v3.

*Unanimous consent*

**Changes from P0009r4**:

-   Removed nullptr constructor.
-   Added constexpr to indexing operator.
-   Indexing operator requires that `rank() == sizeof...(indices)`.
-   Fixed typos in examples and moved them to appendix.
-   Converted note on how extentions to access properties may cause
    reference to be a proxy type to an "see below" to make it
    normative.

## P0009r4 : Pre 2017-11-Albuquerque Mailing

[LEWG review at 2017-03-Kona meeting](http://wiki.edg.com/bin/view/Wg21kona2017/P0009)

[LEWG review of P0546r1 at 2017-03-Kona meeting](http://wiki.edg.com/bin/view/Wg21kona2017/P0546)

**LEWG Poll**: Should we have a single template that covers both single
and multi-dimensional spans?

<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>

**Changes from P0009r3**:

-   Align with P0122r5 span[proposal](https://wg21.link/P0122r5).
-   Rename to `mdspan`, multidimensional span, to align with `span`.
-   Move preferred array extents mechanism to appendix.
-   Expose codomain as a `span`.
-   Add layout mapping concept.

## P0009r3 : Post 2016-06-Oulu Mailing

[LEWG review at 2016-06-Oulu](http://wiki.edg.com/bin/view/Wg21oulu/P0009)

LEWG did not like the name `array_ref`, and suggested the following
alternatives: - `sci_span` - `numeric_span` - `multidimensional_span` -
`multidim_span` - `mdspan` - `md_span` - `vla_span` - `multispan` -
`multi_span`

**LEWG Poll**: Are member `begin()`/`end()` still good?

<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>
**LEWG Poll**: Want this proposal to provide range-producing functions
outside `array_ref`?

<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>

**LEWG Poll**: Want a separate proposal to explore iteration design
space?

<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>

**Changes from P0009r2**:

-   Removed iterator support; a future paper will be written on the
    subject.
-   Noted difference between multidimensional array versus language's
    array-of-array-of-array...
-   Clearly describe requirements for the embedded type aliases
    (`element_type`, `reference`, etc).
-   Expanded description of how the variadic properties list would
    work.
-   Stopped allowing `array_ref<T[N]>` in addition to
    `array_ref<extents<N>>`.
-   Clarified domain, codomain, and domain -> codomain mapping
    specifications.
-   Consistently use *extent* and *extents* for the multidimensional
    index space.

## P0009r2 : Pre 2016-06-Oulu Mailing

[LEWG review at 2016-02-Jacksonville](http://wiki.edg.com/bin/view/Wg21jacksonville/P0009).

**Changes from P0009r1**:

-   Adding details for extensibility of layout mapping.
-   Move motivation, examples, and relaxed incomplete array type
    proposal to separate papers.
    -   [P0331: Motivation and Examples for Polymorphic
        Multidimensional Array](https://wg21.link/P0331).
    -   [P0332: Relaxed Incomplete Multidimensional Array Type
        Declaration](https://wg21.link/P0332).

## P0009r1 : Pre 2016-02-Jacksonville Mailing

[LEWG review at 2015-10-Kona](http://wiki.edg.com/bin/view/Wg21kona2015/P0009).

**LEWG Poll**: What should this feature be called?

<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>

**LEWG Poll**: Do we want 0-length static extents?

<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>

**LEWG POLL**: Do we want the language to support syntaxes like
`X[3][][][5]`?

<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>

**LEWG POLL**: Do we want the variadic property list in template args
(either raw or in `properties<>`)? Note there is no precedence for this
in the library.

<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>

**LEWG POLL**: Do we want the per-view bounds-checking knob?

<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>

**Changes from P0009r0**:

-   Renamed `view` to `array_ref`.
-   How are users allowed to add properties? Needs elaboration in
    paper.
-   `view<int[][][]>::layout` should be named.
-   Rename `is_regular` (possibly to `is_affine`) to avoid overloading
    the term with the `Regular` concept.
-   Make static span(), operator(), constructor, etc variadic.
-   Demonstrate the need for improper access in the paper.
-   In `operator()`, take integral types by value.

## P0009r0 : Pre 2015-10-Kona Mailing

Original non-owning multidimensional array reference (`view`) paper with
motivation, specification, and examples.

## Related Activity

Related [LEWG review of P0546r1 at 2017-11-Albuquerque meeting](http://wiki.edg.com/bin/view/Wg21albuquerque/P0546)

**LEWG Poll**: `span` should specify the dynamic extent as the element
type of the first template parameter rather than the (current) second
template parameter

<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>

**LEWG Poll**: `span` should support the addition of access properties
variadic template parameters

<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>

Authors agreed to bring a separate paper
([[P0900r0]]) discussing how the variadic
properties will work.

Description
===========

The proposed polymorphic multidimensional array reference (`mdspan`)
defines types and functions for mapping indices from the **domain**, a
**multidimensional index space**, to the **codomain**, elements of a
contiguous span of objects. A multidimensional index space is defined as
the Cartesian product of integer extents, *[0..N0) X [0..N1) X [0..N2) ...*.
An `mdspan` has two policies: the **layout mapping**
and the **accessor**. The layout mapping specifies the formula, and
properties of the formula, for mapping a multi-index from the domain to
an element in the codomain. The accessor is an extension point that
allows modification of how elements are accessed. For example, the
Accessors paper (P0367) proposed a rich set of potential access
properties.

**A multidimensional array is not an array-of-array-of-array-of-array...**

The multidimensional array abstraction has been fundamental to numerical
computations for over five decades. However, the C/C++ language provides
only a one dimensional array abstraction which can be composed into
array-of-array-of-array... types. While such types have some similarity
to multidimensional arrays they do not provide adequate multidimensional
array functionality of this proposal. Two critical functionality
differences are (1) multiple dynamic extents and (2) polymorphic mapping
of multi-indices to element objects.

**Optimized Implementation of Layout Mapping**

The layout mapping of a multi-index intended to be an O(1) constexpr
operation that is trivially inlined and optimized. Note that FORTRAN
compilers' optimizations include loop invariant code motion, including
partial evaluation of multi-index layout mappings when indices are
loop-invariant.

Editing Notes
=============

The proposed changes are relative to the working draft of the standard
as of \[N4750](http://wg21.link/n4750).

The � character is used to denote a placeholder section number, table number,
or paragraph number which the editor shall determine.

Add the header `<mdspan>` to table 16 in **[headers]**.  

Add the header `<mdspan>` to Table 76 in 26.1 **[containers.general]** below
the listing for `<span>`.

Wording
=======


---

<br/>
*Add the following paragraphs to* **[views.general]*:

�. The header `<mdspan>` defines the view `basic_mdspan`, the type alias `mdspan`, 
and other facilities for interacting with these views.  
The `basic_mdspan` class template maps a multi-index within a multi-index *domain*
to a reference an element in the *codomain* `span`.

�. The `subspan` function generates a `basic_mdspan` with a domain
contained within the input `basic_mdspan` domain and codomain contained
within the input `basic_mdspan` codomain.

---

<br/>
*Add the following subclauses to the end of the* **[views]** *subclause (currently 26.7)*:

<!--
 .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
-->

<!-- TODO references to subclauses in synopsis comments -->

<br/>
<b>26.7.� Header `<mdspan>` synopsis [mdspan.syn]</b>


```c++
namespace std {
namespace experimental {
namespace fundamentals_v3 {
  // [mdspan.extents], class template extents
  template<ptrdiff_t... StaticExtents>
    class extents;

  // [mdspan.layout], Layout mapping policies
  class layout_left;
  class layout_right;
  class layout_stride;

  // [mdspan.accessor.basic], class template accessor_basic
  template<class ElementType>
  class accessor_basic;

  // [mdspan.basic], class template mdspan
  template<class ElementType,
           class Extents,
           class LayoutPolicy = layout_right,
           class Accessor = accessor_basic<ElementType>>
    class basic_mdspan;

  template<class T, ptrdiff_t... Extents>
    using mdspan = basic_mdspan<T, extents<Extents...>>;

  // [mdspan.extents.compare], extents comparison operators
  template<ptrdiff_t... LHS, ptrdiff_t... RHS>
    constexpr bool operator==(const extents<LHS...>& lhs, const extents<RHS...>& rhs) noexcept;
  template<ptrdiff_t... LHS, ptrdiff_t... RHS>
    constexpr bool operator!=(const extents<LHS...>& lhs, const extents<RHS...>& rhs) noexcept;

  // [mdspan.subspan], subspan creation
  template<class ElementType, class Extents, class LayoutPolicy,
           class Accessor, class... SliceSpecifiers>
    basic_mdspan<ElementType, /* see-below */>
      subspan(const basic_mdspan<ElementType, Extents, LayoutPolicy, Accessor>&, SliceSpecifiers...) noexcept;

  // tag supporting subspan
  struct all_type {};
  inline constexpr all_type all = all_type{};
}}}
```

<!--
                  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'


-->

<b>26.7.� Class template `extents` [mdspan.extents]</b>

<b>26.7.�.1 Overview [mdspan.extents.overview]</b>

1. An `extents` object defines a *multidimensional index space* which is the Cartesian product of integers extents *[0..N0) X [0..N1) X ...*.
2. The *dynamic extents* of an `extents` object correspond to the `StaticExtents` template parameters that are equal to `dynamic_extent`.  Let *DynamicRank[i]* denote the index of the *i*th such extent in the `StaticExtents` template parameter pack, and let *DynamicIndex[r]* indicate the number of such extents in the first *r* entries of the `StaticExtents` parameter pack
3. An `extents` object is expected to store dynamic extents.  *[Note:* An implementation should not consume storage for static extents. *— end note]* 
4. If any of `StaticExtents` are negative and not equal to `dynamic_extent`, the program is ill-formed.

<!-- TODO review change to make rank() and rank_dynamic() size_t -->
<!-- TODO review addition of array constructor -->
<!-- TODO review addition of compatible extents constructor -->
<!-- TODO comparison operators -->
<!-- TODO initializer list constructor? -->

```c++
namespace std {
namespace experimental {
namespace fundamentals_v3 {

template<ptrdiff_t... StaticExtents>
class extents {
public:
  // types
  using index_type = ptrdiff_t;

  // 26.7.�.2 Constructors and assignment
  constexpr extents() noexcept;
  constexpr extents(const extents&) noexcept;
  constexpr extents(extents&&) noexcept;
  template<class... IndexType>
  constexpr extents(IndexType... dynamic_extents) noexcept;
  template<class IndexType, size_t N>
  constexpr extents(const array<IndexType, N>&) noexcept;
  template<ptrdiff_t... OtherStaticExtents>
  constexpr extents(const extents<OtherStaticExtents...>& other) noexcept;
  ~extents() = default;

  constexpr extents& operator=(const extents&) noexcept = default;
  constexpr extents& operator=(extents&&) noexcept = default;
  template<ptrdiff_t... OtherStaticExtents>
  constexpr extents& operator=(const extents<OtherStaticExtents...>& other) noexcept;

  // 26.7.�.3 Observers of the index space domain:
  static constexpr size_t rank() noexcept;
  static constexpr size_t rank_dynamic() noexcept;
  static constexpr index_type static_extent(int) noexcept;
  constexpr index_type extent(int) const noexcept;

private:
  array<index_type, rank_dynamic()> dynamic_extents_; // exposition only
};

}}}

```

<b>26.7.�.2 Constructors and assignment [mdspan.extents.cons]</b>

```c++
constexpr extents() noexcept;
```

* *Effects:* Aggregate-initializes `dynamic_extents_` to `{ }`
* *Postconditions:* `extent(r)` if `static_extent(r) == dynamic_extent` for all `r` in the range `[0, rank())`

<br/>

```c++
constexpr extents(const extents& other);
constexpr extents(extents&& other);
```

<!-- TODO Review this. Should this be two different sections, or does it not matter for move initialization of array? -->

* *Effects:* Initializes `dynamic_extents_` with `other.dynamic_extents_`
* *Postconditions:* `extent(r) == other.extent(r)` for all `r` in the range `[0, rank())`

<br/>

```c++
template<ptrdiff_t... OtherStaticExtents>
constexpr extents(const extents<OtherStaticExtents...>& other) noexcept;
```

* *Requires:* For each `r` in the range `[0, rank())`, if `static_extent(r) != dynamic_extent` and `other.static_extent(r) == dynamic_extent`, then `static_extent(r) == other.extent(r)`.
* *Effects:* For each `r` in the range `[0, rank())`, if `static_extent(r) == dynamic_extent`, initializes `dynamic_extents_[`*DynamicRank[*`r`*]*`]` with `other.extent(r)`.
* *Postconditions:* `*this == other`
* *Remarks:* This constructor shall not participate in overload resolution unless `sizeof...(StaticExtents) == sizeof...(OtherStaticExtents)`.

<br/>

```c++
template<class... IndexType>
constexpr extents(IndexType... dynamic_extents) noexcept;
```

<!-- TODO look at how parameter pack expansions are specified in, e.g., integer_sequence -->
<!-- TODO @CRT: Please review to make sure this is the desired behavior -->

* *Requires:* `((dynamic_extents >= 0) && ...)`
* *Effects:* Aggregate-initializes `dynamic_extents_` to `{dynamic_extents...}`
* *Postconditions:* `extent(`*DynamicRank[i]*`)` is equal to the *i*th entry in the parameter pack `dynamic_extents`
* *Remarks:* This constructor shall not participate in overload resolution unless:
    + `(is_convertible_v<IndexType, index_type> && ...)`
    + and `sizeof...(dynamic_extents) == rank_dynamic()`

```c++
template<class IndexType, size_t N>
constexpr extents(const array<IndexType, N> & dynamic_extents) noexcept;
```

* *Requires:* `dynamic_extents[i] >= 0` for all `i` where `0 <= i <= rank_dynamic()`
* *Effects:* Initializes `dynamic_extents_` with `dynamic_extents`
* *Postconditions:* `extent(`*DynamicRank[i]*`)` is equal to `dynamic_extents[i]`
* *Remarks:* This constructor shall not participate in overload resolution unless:
    + `is_convertible_v<IndexType, index_type>`
    + `N == rank_dynamic()`

```c++
template<ptrdiff_t... OtherStaticExtents>
constexpr extents& operator=(const extents<OtherStaticExtents...>& other) noexcept;
```

* *Requires:* For each `r` in the range `[0, rank())`, if `static_extent(r) != dynamic_extent` and `other.static_extent(r) == dynamic_extent`, then `static_extent(r) == other.extent(r)`.
* *Effects:* For each `r` in the range `[0, rank())`, if `static_extent(r) == dynamic_extent`, assigns `dynamic_extents_[`*DynamicRank[*`r`*]*`]` to `other.extent(r)`.
* *Postconditions:* `*this == other`
* *Returns:* `*this`.
* *Remarks:* This constructor shall not participate in overload resolution unless `sizeof...(StaticExtents) == sizeof...(OtherStaticExtents)`.

<br/>

<br/>
<b>26.7.�.3 Observers of the domain multi-index space [mdspan.extents.obs]</b>

<br/>
```c++
static constexpr size_t rank() const noexcept;
```

* *Returns:* `sizeof...(StaticExtents)`

<br/>
```c++
static constexpr size_t rank_dynamic() const noexcept;
```

<!-- DSH: Added note because I was afraid I was being too clever -->
* *Returns:* `((StaticExtents == dynamic_extent) + ...)` *[Note:* This is the number of dynamic extents *—end note]*

<br/>
```c++
static constexpr index_type static_extent(int r) const noexcept;
```

* *Returns:* The `r`th entry in the `StaticExtents` parameter pack if 0 <= `r` < `rank()`, or 1 otherwise.

<br/>
```c++
constexpr index_type extent(int r) const noexcept;
```

<!-- TODO Does this need an example? -->
* *Returns:* 
    * If `static_extent(r) == dynamic_extent`, then `dynamic_extents_[`*DynamicRank[*`r`*]*`]`.
    * Otherwise, `static_extent(r)`.

<br/>
<b>26.7.�.4 `extents` comparison operators [mdspan.extents.compare]</b>


```c++
template<ptrdiff_t... LHS, ptrdiff_t... RHS>
  constexpr bool operator==(const extents<LHS...>& lhs, const extents<RHS...>& rhs) noexcept;
```

* *Returns:* `true` if `lhs.rank() == rhs.rank()` and `lhs.extents(r) == rhs.extents(r)` for all `r` in the range `[0, lhs.rank())`, or `false` otherwise.

<br/>
```c++
template<ptrdiff_t... LHS, ptrdiff_t... RHS>
  constexpr bool operator!=(const extents<LHS...>& lhs, const extents<RHS...>& rhs) noexcept;
```

* *Returns:* `!(lhs == rhs)`

<!--
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"
-->

<br/>
<br/>
<b>26.7.� Layout mapping policy [mdspan.layout]</b>

<b>26.7.�.1 Layout mapping requirements [mdspan.layout.reqs]</b>

1. A *layout mapping policy* is a class that contains a *layout mapping*, a nested class template.

2. A *layout mapping policy* shall meet the requirements in table �.

3. A *layout mapping* shall meet the requirements of `DefaultConstructible`, `CopyAssignable`, `EqualityComparable`, and the requirements in table �.

4. In Table �:
    * `MP` denotes a layout mapping policy.
    * `E` denotes a specialization of `extents`.
    * `e` denotes an object of type `E` defining a domain multi-index space.
    * `r` is a value of an integral type such that `0 <= r < e.rank()`.
    * `i...` and `j...` are packs of an integer type denoting values in the multi-index space `e`, the `r`*th member of packs `i...` and `j...` are denoted by `i[r]` and `j[r]`, and `sizeof...(i) == E::rank()` and `0 <= i[r] < e.extent(r)` for `i...` and `j...`.
    * `M` denotes a layout mapping class.
    * `m` denotes an object of type `M` that maps a multi-index `i...` to an integral value.

<!-- TODO @CRT and @HCE: Review minor design change consolidating extents-like member functions into get_extents() -->

Table � — Layout mapping policy and layout mapping requirements
<table border=1>
<tr>
  <th>Expression</th>
  <th>Return Type</th>
  <th>Operational Semantics</th>
  <th>Requires/Remarks</th>
</tr>
<tr>
  <td>`MP::mapping<E>`</td>
  <td>`M`</td>
  <td></td>
  <td></td>
</tr>
<tr>
  <td>`m.get_extents()`</td>
  <td>`E`</td>
  <td>
  
  *Returns:* `e`.
  
  </td>
  <td></td>
</tr>
<tr>
  <td>`m(i...)`</td>
  <td>`E::index_type`</td>
  <td>*Returns:* Mapping of a multi-index `i...` </td>
  <td>*Requires:* `0 <= m(i...)` </td>
</tr>
<tr>
  <td>`m.required_span_size()`</td>
  <td>`E::index_type`</td>
  <td>*Returns:* one plus the maximum value of `m(i...)`.</td>
  <td></td>
</tr>
<tr>
  <td>`m.is_unique()`</td>
  <td>`bool`</td>
  <td>*Returns:* `true` if `m(i...) != m(j...)` for every `i... != j...` </td>
  <td></td>
</tr>
<tr>
  <td>`m.is_contiguous()`</td>
  <td>`bool`</td>
  <td>*Returns:* `true` if the set values defined by `m(i)...` is equal to `[0..m.required_span_size())` </td>
  <td></td>
</tr>
<tr>
  <td>`m.is_strided()`</td>
  <td>`bool`</td>
  <td>*Returns:* `true` if `m(j...) - m(i...) = s[r]` when all members of `j...` and `i...` are equal except for exactly one `r`*th* member such that `j[r] == i[r]+1`. `s[r]` is the *stride* of ordinate `r`.</td>
  <td></td>
</tr>
<tr>
  <td>`M::is_always_unique()`</td>
  <td>`bool`</td>
  <td>*Returns:* `true` if `m.is_unique() == true` for any object of type `M`.</td>
  <td></td>
</tr>
<tr>
  <td>`M::is_always_contiguous()`</td>
  <td>`bool`</td>
  <td>*Returns:* `true` if `m.is_contiguous() == true` for any object of type `M`.</td>
  <td></td>
</tr>
<tr>
  <td>`M::is_always_strided()`</td>
  <td>`bool`</td>
  <td>*Returns:* true if `m.is_strided() == true` for any object of type `M`.</td>
  <td></td>
</tr>
<tr>
  <td>`m.stride(r)`</td>
  <td>`E::index_type`</td>
  <td>*Returns:* `m(j...) - m(i...)` when all members of `j...` and `i...` are equal except for the `r`*th* member such that `j[r] == i[r]+1`.</td>
  <td>*Requires:* `m.is_strided() == true`</td>
</tr>
</table>


<!--
 
                                             
  #                   #       #       ##  #  
  #   ## # # ### # # ###      #  ###  #  ### 
  #  # # ### # # # #  #       #  ##  ###  #  
  ## ###   # ### ###  ##      ## ###  #   ## 
         ###             ###         ##      
 
-->

<!-- TODO Do something similar to vector here? ("Descriptions are provided here only for operations on vector that are not described in one of these tables or for operations where there is additional semantic information.")>
<!-- TODO conversion from other layouts? -->

<br/>
<br/>
<b>26.7.�.2 Class layout_left [mdspan.layout.left]</b>

1. `layout_left` meets the requirements of layout mapping policy.  *[Note:* Thus, any well-formed specialization of `layout_left::mapping` meets the requirements of layout mapping *—end note]*
2. `layout_left` gives a layout mapping where the left-most extent is stride one and strides increase left-to-right as the product of extents.
3. If `Extents` is not a (possibly cv-qualified) specialization of `extents`, the program is ill-formed.

```c++
struct layout_left {
  template<class Extents>
  class mapping {
  public:
    constexpr mapping() noexcept;
    constexpr mapping(const mapping& other) noexcept;
    constexpr mapping(mapping&& other) noexcept;
    constexpr mapping(const Extents& e) noexcept;
    template<class OtherExtents>
      constexpr mapping(const mapping<OtherExtents>& other);

    mapping& operator=() noexcept = default;
    mapping& operator=(const mapping& other) noexcept = default;
    template<class OtherExtents>
      constexpr mapping& operator=(const mapping<OtherExtents>& other);

    Extents get_extents() const noexcept;

    constexpr typename Extents::index_type required_span_size() const noexcept;

    template<class... Indices>
      typename Extents::index_type operator()(Indices... is) const;

    static constexpr bool is_always_unique();
    static constexpr bool is_always_contiguous();
    static constexpr bool is_always_strided();

    constexpr bool is_unique() const;
    constexpr bool is_contiguous() const;
    constexpr bool is_strided() const;

    constexpr bool operator==(const mapping& other) const;
    constexpr bool operator!=(const mapping& other) const;

  private:
    Extents extents_; // exposition only
  };
};
```


<br/>

<b>26.7.�.2.1 `layout_left::mapping` constructors [mdspan.layout.left.cons]</b>

<!-- --- -->
<!-- Mimicking exposition-only specification style in [istreambuf.iterator.cons] and using [objects.with.classes]/2 for guidance -->

<br/>

```c++
constexpr mapping() noexcept;
```

* *Effects:* Default-initializes `extents_`.
* *Postconditions:* `get_extents() == Extents()`

<!-- --- -->

<br/>

```c++
constexpr mapping(const mapping& other) noexcept;
```

* *Effects:* Initializes `extents_` with `other.extents_`.
* *Postconditions:* `get_extents() == other.get_extents()`.

<!-- --- -->

<br/>

```c++
constexpr mapping(mapping&& other) noexcept;
```

* *Effects:* Initializes `extents_` with `move(other.extents_)`.
* *Postconditions:* `get_extents()` returns a copy of an `Extents` that is equal to the copy returned by `other.get_extents()` before the invocation of the move.

<!-- --- -->

<br/>

```c++
constexpr mapping(const Extents & e) noexcept;
```

* *Effects:* Initializes `extents_` with `e`.
* *Postconditions:* `get_extents() == e`.


<br/>

```c++
template<class OtherExtents>
constexpr mapping(const mapping<OtherExtents>& other);
```

<!-- TODO review this wording -->
<!-- TODO review this addition -->
* *Requires:* `other.get_extents()` meets the requirements for use in the initialization of `extents_`.
* *Effects:* Initializes `extents_` with `other.get_extents()`.
* *Postconditions:* `get_extents() == other.extents_`.
* *Remarks:* This constructor does not participate in overload resolution unless `OtherExtents` is convertible to `Extents`.
* *Throws:* nothing.

<br/>

```c++
template<class OtherExtents>
  constexpr mapping(const mapping<OtherExtents>& other);
```

<!-- TODO review this wording -->
<!-- TODO review this addition -->
* *Requires:* `other.get_extents()` meets the requirements for assignment to `extents_`.
* *Effects:* Assigns `other.get_extents()` to `extents_`.
* *Postconditions:* `get_extents() == other.get_extents()`.
* *Remarks:* This constructor does not participate in overload resolution unless `OtherExtents` is assignable to `Extents`.
* *Throws:* nothing.
<!-- --- -->

<!-- --- -->

<br/>

<b>26.7.�.2.2 `layout_left::mapping` operations [mdspan.layout.left.ops]</b>

<br/>

```c++
Extents get_extents() const noexcept;
```

* *Returns:* `extents_`.

<!-- --- -->

<br/>

```c++
typename Extents::index_type required_span_size() const noexcept;
```

* *Returns:* The product of `get_extents().extent(r)` for all `r` where `0 <= r < get_extents().rank()`

<!-- --- -->

<br/>
```
template<class... Indices>
  typename Extents::index_type operator()(Indices... i) const;
```

<!-- TODO Check this -->
<!-- TODO Math-style formatting? e.g., MathJax? -->

Let `i[k]` denote the `k`*th* member of `i...`.

* *Returns:* Equivalent to `offset` in

```
index_type offset = 0 ;
for(int k = 0; k < get_extents.rank(); ++k) 
  offset += i[k] * stride(k);
```

* *Remarks:* This operator shall not participate in overload resolution unless
    * `sizeof...(Indices) == get_extents().rank()`,
    * and `is_convertible_v<Indices, typename Extents::index_type> && ...`


```
```

<br/>
```c++
static constexpr bool is_always_unique();
static constexpr bool is_always_contiguous();
static constexpr bool is_always_strided();
constexpr bool is_unique() const;
constexpr bool is_contiguous() const;
constexpr bool is_strided() const;
```

* *Returns:* `true`

<br/>

```c++
index_type stride(int r) const
```

* *Returns:* Equivalent to `s` in

```
index_type s = 1;
for(int k = 0; k < r; ++k)
  s *= get_extents().extent(k);
```

<br/>
```c++
constexpr bool operator==(const mapping& other) const noexcept;
```

* *Returns:* `get_extents() == other.get_extents()`.

<br/>
```c++
constexpr bool operator!=(const mapping& other) const noexcept;
```

* *Returns:* `get_extents() != other.get_extents()`.


<!--

 #                   #           #      #    #
 #   ## # # ### # # ###     ###     ### ### ###
 #  # # ### # # # #  #      #    #  # # # #  #
 ## ###   # ### ###  ##     #    ##  ## # #  ##
        ###             ###         ###
-->

<br/>
<br/>
<b>26.7.�.3 Class layout_right [mdspan.layout.right]</b>

1. `layout_right` meets the requirements of layout mapping policy.  *[Note:* Thus, any well-formed specialization of `layout_right::mapping` meets the requirements of layout mapping *—end note]*
2. The layout mapping property `layout_right` gives a layout mapping where the right-most extent is stride one and strides increase right-to-left as the product of extents.
3. If `Extents` is not a (possibly cv-qualified) specialization of `extents`, the program is ill-formed.

```c++
struct layout_right {
  template<class Extents>
  class mapping {
  public:
    constexpr mapping() noexcept;
    constexpr mapping(const mapping& other) noexcept;
    constexpr mapping(mapping&& other) noexcept;
    constexpr mapping(Extents e) noexcept;
    template<class OtherExtents>
      constexpr mapping(const mapping<OtherExtents>& other);

    mapping& operator=() noexcept = default;
    mapping& operator=(const mapping& other) noexcept = default;
    template<class OtherExtents>
      constexpr mapping& operator=(const mapping<OtherExtents>& other);

    Extents get_extents() const noexcept;

    constexpr typename Extents::index_type required_span_size() const noexcept;

    template<class... Indices>
      typename Extents::index_type operator()(Indices... is) const;

    static constexpr bool is_always_unique() noexcept;
    static constexpr bool is_always_contiguous() noexcept;
    static constexpr bool is_always_strided() noexcept;

    constexpr bool is_unique() const noexcept;
    constexpr bool is_contiguous() const noexcept;
    constexpr bool is_strided() const noexcept;

    ptrdiff_t stride(size_t rank) const noexcept;

  private:
    Extents extents_; // exposition only
  };
};
```


<br/>

<b>26.7.�.3.1 `layout_right::mapping` constructors [mdspan.layout.right.cons]</b>

<!-- --- -->
<!-- Mimicking exposition-only specification style in [istreambuf.iterator.cons] and using [objects.with.classes]/2 for guidance -->

<br/>

```c++
constexpr mapping() noexcept;
```

* *Effects:* Default-initializes `extents_`.
* *Postconditions:* `get_extents() == Extents()`

<!-- --- -->

<br/>

```c++
constexpr mapping(const mapping& other) noexcept;
```

* *Effects:* Initializes `extents_` with `other.extents_`.
* *Postconditions:* `get_extents() == other.get_extents()`.

<!-- --- -->

<br/>

```c++
constexpr mapping(mapping&& other) noexcept;
```

* *Effects:* Initializes `extents_` with `move(other.extents_)`.
* *Postconditions:* `get_extents()` returns a copy of an `Extents` that is equal to the copy returned by `other.get_extents()` before the invocation of the move.

<!-- --- -->

<br/>

```c++
constexpr mapping(Extents e) noexcept;
```

* *Effects:* Initializes `extents_` with `e`.
* *Postconditions:* `get_extents() == e`.

<br/>

```c++
template<class OtherExtents>
  constexpr mapping(const mapping<OtherExtents>& other);
```

<!-- TODO review this wording -->
<!-- TODO review this addition -->
* *Requires:* `other.get_extents()` meets the requirements for use in the initialization of `extents_`.
* *Effects:* Initializes `extents_` with `other.get_extents()`.
* *Postconditions:* `get_extents() == other.extents_`.
* *Remarks:* This constructor does not participate in overload resolution unless `OtherExtents` is convertible to `Extents`.
* *Throws:* nothing.
<!-- --- -->

<br/>

```c++
template<class OtherExtents>
  constexpr mapping(const mapping<OtherExtents>& other);
```

<!-- TODO review this wording -->
<!-- TODO review this addition -->
* *Requires:* `other.get_extents()` meets the requirements for assignment to `extents_`.
* *Effects:* Assigns `other.get_extents()` to `extents_`.
* *Postconditions:* `get_extents() == other.get_extents()`.
* *Remarks:* This constructor does not participate in overload resolution unless `OtherExtents` is assignable to `Extents`.
* *Throws:* nothing.
<!-- --- -->


<br/>

<b>26.7.�.3.2 `layout_right::mapping` operations [mdspan.layout.right.ops]</b>

<br/>

```c++
Extents get_extents() const noexcept;
```

* *Returns:* `extents_`.

<!-- --- -->

<br/>

```c++
typename Extents::index_type required_span_size() const noexcept;
```

* *Returns:* The product of `get_extents().extent(r)` for all `r` where `0 <= r < get_extents().rank()`

<!-- --- -->

<br/>

```c++
template<class... Indices>
  typename Extents::index_type operator()(Indices... i) const noexcept;
```

Let `i[k]` denote the `k`*th* member of `i...`.

* *Returns:* Equivalent to `offset` in

```
index_type offset = 0;
for(int k = 0; k < Extents::rank(); ++k) 
  offset += i[k] * stride(k);
```

* *Remarks:* This operator shall not participate in overload resolution unless
    * `sizeof...(Indices) == get_extents().rank()`,
    * and `is_convertible_v<Indices, typename Extents::index_type> && ...`


<br/>

```c++
static constexpr bool is_always_unique() noexcept;
static constexpr bool is_always_contiguous() noexcept;
static constexpr bool is_always_strided() noexcept;
constexpr bool is_unique() const noexcept;
constexpr bool is_contiguous() const noexcept;
constexpr bool is_strided() const noexcept;
```

* *Returns:* `true`

<br/>

```c++
index_type stride(int r) const noexcept;
```

* *Returns:* Equivalent to `s` in

```
index_type s = 1;
for(int k = r+1; k < get_extents.rank(); ++k)
  s *= get_extents(k);
```

<br/>
```c++
constexpr bool operator==(const mapping& other) const noexcept;
```

* *Returns:* `get_extents() == other.get_extents()`

<br/>
```c++
constexpr bool operator!=(const mapping& other) const noexcept;
```

* *Returns:* `get_extents() != other.get_extents()`

<!-- 
layout_stride

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

-->

<br/>
<br/>
<b>26.7.�.4 Class `layout_stride` [mdspan.layout.stride]</b>

1. `layout_stride` meets the requirements of layout mapping policy.  
2. The layout mapping property `layout_stride` gives a layout mapping where the ...
3. If `Extents` is not a (possibly cv-qualified) specialization of `extents`, the program is ill-formed.

<br/>

```c++
struct layout_stride {
  template <typename Extents>
  class mapping {
  public:
    constexpr mapping() noexcept;
    constexpr mapping(mapping const& other) noexcept;
    constexpr mapping(mapping&& other) noexcept;
    constexpr mapping(Extents e, array<ptrdiff_t, Extents::rank()> s) noexcept;
    template<class OtherExtents>
      constexpr mapping(const mapping<OtherExtents>& other);

    mapping& operator=() noexcept = default;
    mapping& operator=(mapping const& other) noexcept = default;
    template<class OtherExtents>
      constexpr mapping& operator=(const mapping<OtherExtents>& other);

    Extents get_extents() const noexcept;
    array<ptrdiff_t, Extents::rank()> get_strides() const noexcept;

    constexpr typename Extents::index_type required_span_size() const noexcept;

    template <class... Indices>
      typename Extents::index_type operator()(Indices... is) const;

    static constexpr bool is_always_unique() noexcept;
    static constexpr bool is_always_contiguous() noexcept;
    static constexpr bool is_always_strided() noexcept;

    constexpr bool is_unique() const noexcept;
    constexpr bool is_contiguous() const noexcept;
    constexpr bool is_strided() const noexcept;

    ptrdiff_t stride(size_t rank) const noexcept;

  private:
    Extents extents_; // exposition only
    //TODO: should this be extents<dynamic_extent,...,dynamic_extent> ?
    array<ptrdiff_t, Extents::rank()> strides_; // exposition only
  };
};
```

<br/>

<b>26.7.�.4.1 layout_stride::mapping constructors [mdspan.layout.stride.cons]</b>
```c++
constexpr mapping() noexcept;
```
* Effects: Default-initializes extents_.
* Postconditions: `get_extents() == Extents()` and `get_strides() == array<ptrdiff_t, Extents::rank()>()`

```c++
constexpr mapping(mapping const& other) noexcept;
```
* Effects: Initializes extents_ with other.extents_.
* Postconditions: `get_extents() == other.get_extents()` and `get_strides() == other.get_strides()`

```c++
constexpr mapping(mapping&& other) noexcept;
```
* Effects: Initializes extents_ with `move(other.extents_)`.
* Postconditions: `get_extents()` returns a copy of an Extents that is equal to the copy returned by `other.get_extents()` before the invocation of the move and `get_strides()` returns a copy of an `array<ptrdiff_t,Extents::rank()>` that is equal to the copy returned by `other.get_strides()` before the invocation of the move


```c++
constexpr mapping(Extents e, array<ptrdiff_t, Extents::rank()> s) noexcept;
```
* Requires: there is a permutation of the numbers `0,...,Extents::rank()-1` `o(i)` with `0 <= i < Extents::rank()` such that `stride(o(i)) >= stride(o(i-1))*get_extent(o(i-1))` for `1 <= i < Extents::rank()`
* Effects: Initializes extents_ with e and strides_ with s
* Postconditions: `get_extents() == e` and `get_strides() == s`.
* Throws: nothing

```c++
template<class OtherExtents>
  constexpr mapping(const mapping<OtherExtents>& other);
```
* Requires: other.get_extents() meets the requirements for use in the initialization of extents_.
* Effects: Initializes extents_ with other.get_extents() and initializes strides_ with other.get_strides().
* Postconditions: `get_extents() == other.get_extents()` and `get_strides() == other.get_strides()`.
* Remarks: This constructor does not participate in overload resolution unless OtherExtents is convertible to Extents.
* Throws: nothing.


<b>26.7.�.4.2 layout_stride::mapping operations [mdspan.layout.stride.ops]</b>

```c++
Extents get_extents() const noexcept;
```
* Returns: extents_.

```c++
Extents get_strides() const noexcept;
```
* Returns: strides_.

```c++
typename Extents::index_type required_span_size() const noexcept;
```
* Returns: The maximum of of `get_extents().extent(r) * stride(r)` for all `r` where `0 <= r < get_extents().rank()`


```c++
template <class... Indices>
  typename Extents::index_type operator()(Indices... i) const noexcept;
```
* Returns: If `i...` is `i0, i1, i2,..., ik` (where `k == Extents::rank() - 1`) and `s = get_strides()`, returns `i0*s[1] + i1*s[2] +...+ ik*s[k]`
* Remarks: This operator shall not participate in overload resolution unless
  * `sizeof...(Indices) == Extents::rank()`,
  * and `is_convertible_v<Indices, typename Extents::index_type> && ...`


```c++
static constexpr bool is_always_unique() noexcept;
static constexpr bool is_always_strided() noexcept;
constexpr bool is_unique() const noexcept;
constexpr bool is_strided() const noexcept;
```
TODO: should this be always unique?
* Returns: true


```c++
static constexpr bool is_always_contiguous() noexcept;
```
* Returns: false

```c++
constexpr bool is_contiguous() const noexcept;
```
* Returns: true if there is a permutation of the numbers `0,...,Extents::rank()-1` `o(i)` with `0 <= i < Extents::rank()` such that `min(stride(o(i)) == 1` and `stride(o(i)) == stride(o(i-1))*get_extent(o(i-1))` with `1 <= i < Extents::rank()` otherwise returns false

```c++
index_type stride(int r) const noexcept;
```
* Returns: `strides_(r)`



```c++
constexpr bool operator==(const mapping& other) const noexcept;
```
* Returns: `(get_extents() == other.get_extents()) && (get_strides() == other.get_strides())`


```c++
constexpr bool operator!=(const mapping& other) const noexcept;
```
* Returns: `(get_extents() != other.get_extents()) || (get_strides() != other.get_strides())`

<!--
subspan

                     /$$                                              
                    | $$                                              
  /$$$$$$$ /$$   /$$| $$$$$$$   /$$$$$$$  /$$$$$$   /$$$$$$  /$$$$$$$ 
 /$$_____/| $$  | $$| $$__  $$ /$$_____/ /$$__  $$ |____  $$| $$__  $$
|  $$$$$$ | $$  | $$| $$  \ $$|  $$$$$$ | $$  \ $$  /$$$$$$$| $$  \ $$
 \____  $$| $$  | $$| $$  | $$ \____  $$| $$  | $$ /$$__  $$| $$  | $$
 /$$$$$$$/|  $$$$$$/| $$$$$$$/ /$$$$$$$/| $$$$$$$/|  $$$$$$$| $$  | $$
|_______/  \______/ |_______/ |_______/ | $$____/  \_______/|__/  |__/
                                        | $$                          
                                        | $$                          
                                        |__/                          
-->

<br/>
<br/>
<b>26.7.�.5 subspan [mdspan.subspan]</b>

```c++
  // [mdspan.subspan], subspan creation
  template<class ElementType, class Extents, class LayoutPolicy,
           class Accessor, class... SliceSpecifiers>
    basic_mdspan<ElementType, E /* see-below */, layout_stride, Accessor>
      subspan(const basic_mdspan<ElementType, Extents, LayoutPolicy, Accessor>& src, SliceSpecifiers ... slices) noexcept;
```

`subspan` creates a `basic_mdspan` that is a view on a (potentially trivial) subset of another `basic_mdspan`.
The SliceSpecifier parameters indicate the subset that the return value references.
Let slices[r] denote the rth value in the parameter pack slices.
The second template parameter of the return type is E, a specialization of `extents`.
<br/>

Let <em>C</em> be the number of parameters in `SliceSpecifiers` which are convertible to `ptrdiff_t` <br/>
Let <em>ranges[r]</em> denote the rth value in the parameter pack slices, which is not convertible to `ptrdiff_t` <br/>
Let <em>sub</em> be the return value of `subspan` <br/>
Let <em>first[r]</em> denote the rth lower bound of `slices[r]`. <br/>
    * If `slices[r]` is convertible to `ptrdiff_t` `first[r]==slices[r]` <br/>
    * If `slices[r]` is convertible to `pair<ptrdiff_t,ptrdiff_t>` `first[r]==pair<ptrdiff_t,ptrdiff_t>(slices[r]).first()` <br/>
    * If `slices[r]` is convertible to `alltype_t` `first[r]==0` <br/>
Let `last[r]` denote the rth upper bound of `slices[r]`. <br/>
    * If `slices[r]` is convertible to `ptrdiff_t` `last[r]==slices[r]+1` <br/>
    * If `slices[r]` is convertible to `pair<ptrdiff_t,ptrdiff_t>` `last[r]==pair<ptrdiff_t,ptrdiff_t>(slices[r]).second()` <br/>
    * If `slices[r]` is convertible to `alltype_t` `last[r]==src.extent(r)` <br/>

Requires: <br/>
    * `sizeof(slices...)==Extents::rank()` <br/>
    * `slices[r]` is convertible to `ptrdiff_t`, `pair<ptrdiff_t,ptrdiff_t>` or `alltype_t` <br/>
    * `0<=first[r]<src.extent(r)` <br/>
    * `0<last[r]<=src.extent(r)` <br/>
    * `LayoutPolicy` is `layout_right`, `layout_left`, or `layout_stride` <br/>

Postcondition: <br/>
    * `E::rank() == Extents::rank()-C` <br/>
    * If <em>ranges[r]</em> is the nth value of `ranges` convertible to `alltype_t` or `pair<ptrdiff_t,ptrdiff_t>` and `slices[k]` is the `n`th value of `slices` convertible to `all type_t` or  `pair<ptrdiff_t,ptrdiff_t>` then `sub.extent(r)==last[k]-first[k]` and `sub.stride(r)==src.stride(k)` <br/> 
    * `sub.ptr_==src.ptr_ + first[0]*src.stride(0) + ... + first[Extents::rank()-1]*src.stride(Extents::rank()-1)` <br/>
    * Note: it is quality of implementation whether static extents are preserved if possible.  <br/>

* Examples:
```c++
typedef extents<100,dynamic_extent,3> Extents3D;
layout_right::mapping<Extents3D> map_right(
basic_mdspan<int,Extents3D,layout_right> a()
```

<!--



 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



-->

<!-- TODO: @CRT review whether these requirements are flexible enough -->
<!-- TODO: Review changes here. This was too hard to specify as a nested class, and I'm not sure it buys us anything. 
(specifically, it was getting really messy trying to allow accessor implementations to constrain what types they are valid for.) -->

<br/>
<br/>

<b>26.7.� Accessor [mdspan.accessor]</b>

<br/>
<b>26.7.�.1 Accessor requirements [mdspan.accessor.reqs]</b>

1. An *accessor* is a class that converts a pointer and an offset into a reference. *[Note:* The intended semantic is that the reference refers to a value at the given offset from the given pointer. *—end note]*

5. An *accessor* shall meet the requirements of `DefaultConstructible`, `CopyAssignable`, and the requirements in table �.

In Table �:
  * `A` denotes an accessor.
  * `a` denotes a value of type `A`.
  * `p` denotes a value of type `A::pointer`.
  * `i` denotes an integer.

Table �: Accessor requirements
<table border=1>
<tr>
  <th>Expression</th>
  <th>Return Type</th>
  <th>Requirements/Notes</th>
</tr>
<tr>
  <td>`A::value_type`</td>
  <td></td>
  <td></td>
</tr>
<tr>
  <td>`A::pointer`</td>
  <td></td>
  <td>*Requires:* `A::pointer` shall meet the requirements of random access iterator (**[random.access.iterators]**), and `iterator_traits<A::pointer>::value_type` shall be exactly `A::value_type`.</td>
</tr>
<tr>
  <td>`A::reference`</td>
  <td></td>
  <td>*Requires:* `iterator_traits<A::pointer>::reference` shall be convertible to `A::reference` </td>
</tr>
<tr>
  <td>`a(p, i)`</td>
  <td>`A::reference`</td>
<!-- TODO review this wording. I tried to used `swap` in container requirements as an example of something that is an intended semantic rather than a requirement, but I'm still not sure if it should be a note or normative text. -->
  <td>*[Note:* A `basic_mdspan` implementation shall use the return of this expression as though it is constructed from `p[i]`. *— end note]*</td>
</tr>
</table>

<!--

                                    #            #
 ## ### ### ###  ##  ## ### ###     ###  ##  ##     ###
# # #   #   ##   #   #  # # #       # # # #  #   #  #
### ### ### ### ##  ##  ### #       ### ### ##   ## ###
                                ###
-->

<br/>
<b>26.7.�.2 Class `accessor_basic` [mdspan.accessor.basic]</b>

1. `accessor_basic` meets the requirements of accessor.
<!-- TODO review this summary description -->
2. `accessor_basic` gives an accessor that has semantics equivalent to dereferencing a pointer to an array of values.
3. If `T` is not an object type or is an array type, the program is ill-formed.

```c++
template<class T>
struct accessor_basic {
  using value_type = T;
  using pointer = T*;
  using reference = T&;
  constexpr reference operator()(pointer p, ptrdiff_t i) const noexcept;
};
```

<br/>
<b>26.7.�.2.1 `accessor_basic` operations [mdspan.accessor.basic.ops]</b>

```c++
constexpr reference operator()(pointer p, ptrdiff_t i) const noexcept;
```

* *Returns:* `p[i]`

<!--
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
-->

<!-- TODO: Consider moving Accessor to replace ElementType, since it's never used -->
<!-- TODO: section references in synopsis -->
<!-- TODO: Shouldn't we also have converting move constructors? -->
<!-- TODO: review addition of get_mapping() and get_extents() -->
<!-- TODO: need ways to construct stateful layout policies and stateful accessors -->

<br/>
<br/>
<b>26.7.� Class template `basic_mdspan` [mdspan.basic]</b>

1. The `basic_mdspan` class template maps a multi-index within a multi-index *domain* to a reference to an element in the *codomain* `span`.
2. The multi-index domain space is the Cartesian product of the extents: `[0, extent(0)) X [0, extent(1)) X`* ... *` X [0, extent(rank() - 1))`. Each extent may be statically or dynamically specified.
2. As with `span`, the storage of the objects in the codomain `span` of a `basic_mdspan` is owned by some other object.
3. `ElementType` is required to be a complete object type that is not an abstract class type or an array type.
4. `Extents` is required to be a (cv-unqualified) specialization of `extents`
5. `LayoutPolicy` is required to be a cv-unqualified object type.
6. If `LayoutPolicy` does not meet the layout policy requirements, the program is ill-formed.
7. `Accessor` is required to be a cv-unqualified object type.
8. If `Accessor` does not meet the accessor requirements, or if `Accessor::value_type` is not exactly `ElementType`, the program is ill-formed.


```c++
namespace std {
namespace experimental {
namespace fundamentals_v3 {

template<class ElementType, class Extents, class LayoutPolicy, class Accessor>
class basic_mdspan {
public:

  // Domain and codomain types
  using layout = LayoutPolicy;
  using mapping = typename layout::mapping<Extents>;
  using accessor = Accessor;
  using element_type = typename accessor::value_type;
  using value_type = remove_cv_t<element_type>;
  using index_type = ptrdiff_t ;
  using difference_type = ptrdiff_t ;
  using pointer = typename accessor::pointer;
  using reference = typename accessor::reference;

  // Constructors, assignment, and destructor
  constexpr basic_mdspan() noexcept;
  constexpr basic_mdspan(const basic_mdspan&) noexcept;
  constexpr basic_mdspan(basic_mdspan&&) noexcept;
  template<class... IndexType>
    explicit constexpr basic_mdspan(pointer, IndexType... dynamic_extents);
  template<class... IndexType>
    explicit constexpr basic_mdspan(span<element_type>, IndexType... dynamic_extents);
  constexpr basic_mdspan(pointer p, const mapping& m);
  constexpr basic_mdspan(pointer p, const mapping& m, const accessor& a);
  template<class OtherElementType, class OtherExtents, class OtherLayoutPolicy, class OtherAccessor>
    constexpr basic_mdspan(const basic_mdspan<OtherElementType, OtherExtents, OtherLayoutPolicy, OtherAccessor>& other);
  template<class IndexType, size_t N>
    explicit constexpr basic_mdspan(const pointer& p,const array<IndexType, N>& dynamic_extents);
  template<class IndexType, size_t N>
    explicit constexpr basic_mdspan(const span<element_type>& sp,const array<IndexType, N>& dynamic_extents) noexcept;

  ~basic_mdspan();

  constexpr basic_mdspan& operator=(const basic_mdspan&) noexcept = default;
  constexpr basic_mdspan& operator=(basic_mdspan&&) noexcept = default;
  template<class OtherElementType, class OtherExtents, class OtherLayoutPolicy, class OtherAccessor>
    constexpr basic_mdspan& operator=(const basic_mdspan<OtherElementType, OtherExtents, OtherLayoutPolicy, OtherAccessor>& other) noexcept;

  // Mapping domain multi-index to access codomain element
  constexpr reference operator[](index_type) const noexcept;
  template<class... IndexType>
    constexpr reference operator()(IndexType... indices) const noexcept;
  template<class IndexType, size_t N>
    constexpr reference operator()(const array<IndexType, N>& indices) const noexcept;
  accessor get_accessor() const;

  // Observers of the domain multi-index space
  static constexpr int rank() noexcept;
  static constexpr int rank_dynamic() noexcept;
  static constexpr index_type static_extent(int) noexcept;

  constexpr Extents get_extents() const noexcept;
  constexpr index_type extent(int) const noexcept;
  constexpr index_type size() const noexcept;
  constexpr index_type unique_size() const noexcept;

  // Observers of the codomain:
  constexpr span<element_type> span() const noexcept;

  // Observers of the mapping : domain -> codomain
  static constexpr bool is_always_unique() noexcept;
  static constexpr bool is_always_contiguous() noexcept;
  static constexpr bool is_always_strided() noexcept;

  constexpr mapping get_mapping() const noexcept;
  constexpr bool is_unique() const noexcept;
  constexpr bool is_contiguous() const noexcept;
  constexpr bool is_strided() const noexcept;
  constexpr index_type stride(int) const;

private:
  accessor acc_; // exposition only
  mapping map_; // exposition only
  pointer ptr_; // exposition only
};

}}}
```

<!--

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

-->
<br/>
<b>26.7.�.1 `basic_mdspan` constructors, assignment, and destructor [mdspan.basic.cons]</b>
  // Mapping domain multi-index to access codomain element

```c++
constexpr basic_mdspan() noexcept;
```

<!-- TODO check for periods, commas, and "and" here. -->
<!-- TODO: span excludes this constructor if there are no dynamic extents.  Should we do the same? -->
<!-- TODO: decide if we want to include invocation of `span()` in the postconditions. An accessor may want to make this undefined behavior. -->
* *Effects:*
    * zero-initializes `ptr_`
    * value-initializes `map_`
    * value-initializes `acc_`
* *Postconditions:* 
    + `size() == 0`
    + `get_extents() == Extents()`
    + `get_mapping() == mapping()`
* *Remarks:* This constructor does not participate in overload resolution unless
    + `is_default_constructible_v<mapping>`, and
    + `is_default_constructible_v<accessor>`

<br/>

```c++
constexpr basic_mdspan(const basic_mdspan& other) noexcept;
```

* *Effects:*
    + initializes `ptr_` with `other.ptr_`
    + initializes `map_` with `other.map_`
    + initializes `acc_` with `other.acc_`
* *Postconditions:*
    + `size() == other.size()`
    + `get_extents() == other.get_extents()`
    + `get_mapping() == other.get_mapping()`

<br/>

```c++
constexpr basic_mdspan(basic_mdspan&& other) noexcept;
```

* *Effects:*
    + initializes `ptr_` with `move(other.ptr_)`
    + initializes `map_` with `move(other.map_)`
    + initializes `acc_` with `move(other.acc_)`

<br/>

```c++
template<class... IndexType>
  explicit constexpr basic_mdspan(pointer ptr, IndexType... dynamic_extents);
```

* *Requires:* `[ptr, ptr + required_span_size(dynamic_extents...))` shall be a valid range.
* *Effects:*
    + initializes `ptr_` with `ptr`
    + initializes `map_` with `Extents(dynamic_extents...)`
    + value-initializes `acc_`
* *Postconditions:* 
    + `size() == 0`
    + `get_extents() == Extents(dynamic_extents...)`
    + `get_mapping() == mapping(Extents(dynamic_extents...))`
* *Remarks:* This constructor will not participate in overload resolution unless:
    + `(is_convertible_v<IndexType, index_type> && ...)`,
    + `sizeof...(dynamic_extents) == rank_dynamic()`,
    + `is_constructible_v<mapping, Extents>`, and
    + `is_default_constructible_v<accessor>`.
* *Throws:* Nothing.

<!-- TODO is there any reason to prefer `(is_integral_v<IndexType> && ...)`? -->

<br/>

```c++
template<class... IndexType, ptrdiff_t N>
  explicit constexpr basic_mdspan(span<element_type, N> s, IndexType... dynamic_extents);
```

* *Requires:* `s.size() == required_span_size(dynamic_extents...)`
* *Effects:*
    + initializes `ptr_` with `s.ptr_`
    + value-initializes `map_`
    + value-initializes `acc_`
* *Postconditions:* 
    + `get_extents() == Extents(dynamic_extents...)`
    + `get_mapping() == mapping(Extents(dynamic_extents...))`
* *Remarks:* This constructor will not participate in overload resolution unless:
    + `(is_convertible_v<IndexType, index_type> && ...)`,
    + `sizeof...(dynamic_extents) == rank_dynamic()`,
    + `N == dynamic_extent || (rank_dynamic() == 0 && N == required_span_size(dynamic_extents...))`,
    + `is_constructible_v<mapping, Extents>`, and
    + `is_default_constructible_v<accessor>`.
* *Throws:* Nothing.

<br/>

```c++
constexpr basic_mdspan(pointer ptr, const mapping& m);
```

* *Effects:*
    + initializes `ptr_` with `p`
    + initializes `map_` with `m`
    + value-initializes `acc_`
* *Postconditions:* 
    + `get_extents() == m.get_extents()`
    + `get_mapping() == m`
* *Remarks:* This constructor will not participate in overload resolution unless `is_default_constructible_v<accessor>`.
* *Throws:* Nothing.

<br/>


```c++
constexpr basic_mdspan(pointer p, const mapping& m, const accessor& a);
```

* *Effects:*
    + initializes `ptr_` with `p`
    + initializes `map_` with `m`
    + initializes `acc_` with `a`
* *Postconditions:* 
    + `get_extents() == m.get_extents()`
    + `get_mapping() == m`
* *Throws:* Nothing.

<br/>

<!-- TODO review this wording! -->
```c++
template<class OtherElementType, class OtherExtents, class OtherLayoutPolicy, class OtherAccessor>
  constexpr basic_mdspan(const basic_mdspan<OtherElementType, OtherExtents, OtherLayoutPolicy, OtherAccessor>& other);
```

* *Requires:*
    + For all `r` in the range `[0, rank())`, if `other.static_extent(r) == dynamic_extent` or `static_extent(r) == dynamic_extent`, then `other.extent(r) == extent(r)`
* *Effects:*
    + initializes `ptr_` with `other.ptr_`
    + initializes `map_` with `other.map_`
    + initializes `acc_` with `other.acc_`
* *Postconditions:* 
    + `get_extents() == Extents(other.get_extents())`
    + `get_mapping() == mapping(other.get_mapping())`
* *Remarks:* This constructor will not participate in overload resolution unless all of the following conditions are met:
    + `OtherElementType(*)[]` is convertible to `ElementType(*)[]`, <!-- lifted directly from span wording -->
    + `OtherLayoutPolicy::template mapping<OtherExtents>` is convertible to `mapping`
    + `OtherAccessor` is convertible to `Accessor`, and
    + `OtherAccessor::pointer` is convertible to `pointer`.
* *Throws:* Nothing.

<br/>

```c++
template<class IndexType, size_t N>
  explicit constexpr basic_mdspan(pointer, const array<IndexType, N>& dynamic_extents) noexcept;
```

* *Effects:* Equivalent to `basic_mdspan(pointer, dynamic_extents[Rs]...)`, with `Rs...` from `index_sequence<Rs...>` matching `make_index_sequence<N>`.
* *Remarks:* This constructor does not participate in overload resolution unless
    + `IndexType` is convertible to `index_type`, and
    + `N == rank_dynamic()`,
    + `is_constructible_v<mapping, Extents>`, and
    + `is_default_constructible_v<accessor>`.

<br/>

```c++
template<class IndexType, ptrdiff_t K, size_t N>
  explicit constexpr basic_mdspan(span<element_type, K> s, const array<IndexType, N>& dynamic_extent) noexcept;
```

* *Effects:* Equivalent to `basic_mdspan(pointer, dynamic_extents[Rs]...)`, with `Rs...` from `index_sequence<Rs...>` matching `make_index_sequence<N>`.
* *Remarks:* This constructor does not participate in overload resolution unless
    + `IndexType` is convertible to `index_type`,
    + `N == rank_dynamic()`,
    + `K == dynamic_extent || (rank_dynamic() == 0 && K == required_span_size(dynamic_extents))`,
    + `is_constructible_v<mapping, Extents>`, and
    + `is_default_constructible_v<accessor>`.

<!-- TODO review this wording! -->
```c++
template<class OtherElementType, class OtherExtents, class OtherLayoutPolicy, class OtherAccessor>
  constexpr basic_mdspan& operator=(const basic_mdspan<OtherElementType, OtherExtents, OtherLayoutPolicy, OtherAccessor>& other);
```

* *Requires:*
    + For all `r` in the range `[0, rank())`, if `other.static_extent(r) == dynamic_extent` or `static_extent(r) == dynamic_extent`, then `other.extent(r) == extent(r)`
* *Effects:*
    + assigns `other.ptr_` to `ptr_`.
    + assigns `other.map_` to `map_`
    + assigns `other.acc_` to `acc_`
* *Postconditions:* 
    + `get_extents() == Extents(other.get_extents())`
    + `get_mapping() == mapping(other.get_mapping())`
* *Remarks:* This constructor will not participate in overload resolution unless all of the following conditions are met:
    + `OtherElementType(*)[]` is assignable to `ElementType(*)[]`, <!-- lifted directly from span wording -->
    + `OtherLayoutPolicy::template mapping<OtherExtents>` is assignable to `mapping`
    + `OtherAccessor` is assignable to `Accessor`, and
    + `OtherAccessor::pointer` is assignable to `pointer`.
* *Throws:* Nothing.


<!--

  #              #                           #
### ### ###  ##     ##      ###  ## ### ###     ##  ###
# # # # ### # #  #  # #     ### # # # # # #  #  # # # #
### ### # # ###  ## # #     # # ### ### ###  ## # #  ##
                                    #   #           ###
-->

<br/>
<b>26.7.�.2 `basic_mdspan` mapping domain multi-index to access codomain element [mdspan.basic.mapping]</b>

```c++
constexpr reference operator[](index_type i) const;
```

* *Effects:* Equivalent to `return (*this)(i);`.
* *Remarks:* This operator does not participate in overload resolution unless `rank() == 1`

<br/>

```c++
template<class... IndexType>
  constexpr reference operator()(IndexType... indices) const;
```

* *Requires:* `0 <= array<index_type, sizeof...(indices)>{indices...}[r] < extent(r)` for all `r` in the range `[0, rank())`.
* *Effects:* Equivalent to `return acc_(ptr_, indices...);`
* *Remarks:* This operator does not participate in overload resolution unless
    + `is_convertible_v<IndexType, index_type> && ...`
    + `sizeof...(IndexType) == rank()`
* *Throws:* nothing.

<br/>

```c++
template<class IndexType, size_t N>
  constexpr reference operator()(const array<IndexType, N>& indices) const;
```

<!-- TODO: Do I need a requires clause if I already have an equivalent effects clause? -->
* *Effects:* Equivalent to `return std::apply(*this, indices);`
* *Remarks:* This operator does not participate in overload resolution unless
    + `is_convertible_v<IndexType, index_type>`
    + `rank() == N`
* *Throws:* nothing.


```c++
accessor get_accessor() const;
```

* *Returns:* `acc_`.

<!--

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

-->
<br/>
<b>26.7.�.3 `basic_mdspan` observers of the domain multi-index space [mdspan.basic.domobs]</b>

```c++
static constexpr int rank() noexcept;
```

* *Returns:* `Extents::rank()`.

<br/>

```c++
static constexpr int rank_dynamic() noexcept;
```

* *Returns:* `Extents::rank_dynamic()`.

<br/>

```c++
static constexpr index_type static_extent(int r) noexcept;
```

* *Returns:* `Extents::static_extent(r)`.

<br/>

```c++
constexpr Extents get_extents() const noexcept;
```

* *Returns:* `get_mapping().get_extents()`.

<br/>

```c++
constexpr index_type extent(int r) const noexcept;
```

* *Returns:* `get_extents().extent(r)`.

<br/>

```c++
constexpr index_type size() const noexcept;
```

* *Returns:* Product of `extent(r)` for all `r` where `0 <= r < get_extents().rank()`.

```c++
constexpr index_type unique_size() const noexcept;
```

* *Returns:* The number of unique elements in the codomain. *[Note:* If `get_mapping().is_unique()` is `true`, this is identical to `size()` *—end note]*


<!--

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

-->

<br/>
<b>26.7.�.3 `basic_mdspan` observers of the codomain [mdspan.basic.codomain]</b>

```c++
constexpr span<element_type> span() const noexcept;
```

* *Returns:* The codomain `span`.


<!--

# #              #                  #
###  ## ### ###     ##  ###     ### ###  ## ### ### # # ### ###  ##
### # # # # # #  #  # # # #     # # # #  #  ##  #   # # ##  #    #
# # ### ### ###  ## # #  ##     ### ### ##  ### #    #  ### #   ##
# #     #   #           ###
-->

<br/>
<b>26.7.�.4 `basic_mdspan` observers of the mapping [mdspan.basic.obs]</b>

<br/>

```c++
static constexpr bool is_always_unique() noexcept;
```

* *Returns:* `mapping::is_always_unique()`

<br/>

```c++
static constexpr bool is_always_contiguous() noexcept;
```

* *Returns:* `mapping::is_always_contiguous()`

<br/>

```c++
static constexpr bool is_always_strided() noexcept;
```

* *Returns:* `mapping::is_always_strided()`

<br/>

```c++
constexpr mapping get_mapping() const noexcept;
```

* *Returns:* `map_`

<br/>

```c++
constexpr bool is_unique() const noexcept;
```

* *Returns:* `get_mapping().is_unique()`

<br/>

```c++
constexpr bool is_contiguous() const noexcept;
```

* *Returns:* `get_mapping().is_contiguous()`

<br/>

```c++
constexpr bool is_strided() const noexcept;
```

* *Returns:* `get_mapping().is_strided()`

<br/>

```c++
constexpr index_type stride(int r) const;
```

* *Returns:* `get_mapping().stride(r)`


<!--
                  888
                  888
                  888
.d8888b  888  888 88888b.  .d8888b  88888b.   8888b.  88888b.
88K      888  888 888 "88b 88K      888 "88b     "88b 888 "88b
"Y8888b. 888  888 888  888 "Y8888b. 888  888 .d888888 888  888
     X88 Y88b 888 888 d88P      X88 888 d88P 888  888 888  888
 88888P'  "Y88888 88888P"   88888P' 88888P"  "Y888888 888  888
                                    888
                                    888
                                    888
-->

<br/>
<br/>
<b>26.7.� Function template subspan [mdspan.subspan]</b>

<!-- TODO review wording here! -->
1. `subspan` creates a `basic_mdspan` that is a view on a (potentially trivial) subset of another `basic_mdspan`.
2. The `SliceSpecifier` parameters indicate the subset that the return value references.
3. Let `slices[r]` denote the `r`th value in the parameter pack `slices`.
4. When `mds` is an instance of a specialization of `basic_mdspan`, define *SLICE_BEGIN(*`mds`*, *`sl`*)* as:
    + `sl`, if `sl` is convertible to `ptrdiff_t`;
    + otherwise, `get<0>(sl)` if that expression is well-formed and convertible to `ptrdiff_t`;
    + otherwise, `0` when `sl` is an instance of `all_tag`;
    + otherwise, ill-formed.
5. When `mds` is an instance of a specialization of `basic_mdspan`, define *SLICE_END(*`mds`*, *`sl`*, *`r`*)* as:
    + `sl + 1`, if `sl` is convertible to `ptrdiff_t`;
    + otherwise, `get<1>(sl)` if that expression is well-formed and convertible to `ptrdiff_t`;
    + otherwise, `mds.extent(r)` if `sl` is an instance of `all_tag`;
    + otherwise, ill-formed.
6. The second template parameter of the return type is `E`, a specialization of `extents` with `E::rank() == Extents::rank()` and for each integer `r` in the range `[0, E::rank())`, `E::static_extent(r)` is:
    + `1` if `slices[r]` is convertible to `ptrdiff_t`;
    + otherwise, `dynamic_extent` if `get<0>(slices[r])` and `get<1>(slices[r])` are well-formed and convertible to `ptrdiff_t`;
    + otherwise, `Extents::static_extent(r)`.
7. The third template parameter of the return type is `LM`, a specialization of `layout_stride`, with TODO WRITE THIS

```c++
template<class ElementType, class Extents, class LayoutPolicy,
          class Accessor, class... SliceSpecifiers>
  basic_mdspan<ElementType, /* see-below */, /* see-below */, Accessor>
    subspan(const basic_mdspan<ElementType, Extents, LayoutPolicy, Accessor>& s, SliceSpecifiers... slices);
```

* *Requires:* For all integers `r` in the range `[0, s.rank())`,
    + *SLICE_BEGIN(*`s`, `slices[r]`*)* `>= 0`,
    + *SLICE_END(*`s`, `slices[r]`, `r`*)* `<= s.extent(r)`, and
    + *SLICE_END(*`s`, `slices[r]`, `r`*)* `<= s.extent(r)` >= *SLICE_BEGIN(*`s`, `slices[r]`*)* `>= 0`.
* *Returns:* An instance `m` of type `basic_mdspan<ElementTYpe, E, LM, Accessor>` such that:
    + for each integer `r` in the range `[0, s.rank())`, `m.extent(r) == `*SLICE_END(*`s`, `slices[r]`, `r`*)*` - `*SLICE_BEGIN(*`s`, `slices[r]`*)*
    + TODO describe the layout mapping
    + for each integer `r` in the range `[0, s.rank())` and for each integer `k(r)` in each range `[0, `*SLICE_END(*`s`, `slices[r]`, `r`*)*` - `*SLICE_BEGIN(*`s`, `slices[r]`*)*`)`, invoking `m(k(Rs)...)` is equivalent to invoking `s((`*SLICE_BEGIN(*`s`, `slices[Rs]`*)*` + k(Rs))...)` with `Rs...` from `index_sequence<Rs...>` matching `make_index_sequence<Extents::rank()>`.
* *Remarks:* This function does not participate in overload resolution unless:
    + `sizeof...(slices) == Extents::rank()`
    + *SLICE_BEGIN(*`s`, `slices[r]`*)* and *SLICE_END(*`s`, `slices[r]`, `r`*)* are well-formed for all integers `r` in the range `[0, rank())`.



Next Steps
==========

-   Wording editing as per guidance from LWG.

Related Work
============

[LEWG issue](https://issues.isocpp.org/show_bug.cgi?id=80)

**Previous paper:**

-   [[N4355]]

**P0860 : Access Policy Generating Proxy Reference**

The `reference` type may be a proxy for accessing an `element_type`
object. For example, the *atomic* `AccessorPolicy` in **P0860** defines
`AccessorPolicy::accessor<T>::reference` to be `atomic_ref<T>` from
**P0019**.

**Related papers:**

-   **P0122** : span: bounds-safe views for sequences of objects The
    `mdspan` codomain concept of *span* is well-aligned with this paper.
-   **P0367** : Accessors The P0367 Accessors proposal includes
    polymorphic mechanisms for accessing the memory an object or span of
    objects. The `AccessPolicy` extension point in this proposal is
    intended to include such memory access properties.
-   **P0331** : Motivation and Examples for Multidimensional Array
-   **P0332** : Relaxed Incomplete Multidimensional Array Type
    Declaration
-   **P0454** : Wording for a Minimal `mdspan` Included proposed
    modification of `span` to better align `span` with `mdspan`.
-   **P0546** : Preparing `span` for the future Proposed modification of
    `span`
-   **P0856** : Restrict access property for `mdspan` and `span`
-   **P0860** : atomic access policy for `mdspan`
-   **P0900** : An Ontology of Properties for `mdspan`

TODO
====

* Design questions:
    + <strike>Need a way to construct span with non-default-initialized `mapping` and `accessor`</strike> Added, please review
    + Should we be constraining things with `is_integral_v<IndexType>` or `is_convertible_v<IndexType, index_type>`?
    + <strike>Extents and/or mapping conversion?</strike> Done, please review
    + <strike>Constrain constructors of `basic_mdspan` based on `Mapping` and `Accessor` constraints.</strike> Done, please review
    + <strike>`unique_size()`</strike> done