[views.multidim] - C++20 → C++23

Files changed (1) hide show

tmp/tmpr_27_uu6/{from.md → to.md} +2029 -0

tmp/tmpr_27_uu6/{from.md → to.md} RENAMED Viewed

	@@ -0,0 +1,2029 @@

+### Multidimensional access <a id="views.multidim">[[views.multidim]]</a>
+#### Overview <a id="mdspan.overview">[[mdspan.overview]]</a>
+A *multidimensional index space* is a Cartesian product of integer
+intervals. Each interval can be represented by a half-open range
+[Lᵢ, Uᵢ), where Lᵢ and Uᵢ are the lower and upper bounds of the iᵗʰ
+dimension. The *rank* of a multidimensional index space is the number of
+intervals it represents. The *size of a multidimensional index space* is
+the product of Uᵢ - Lᵢ for each dimension i if its rank is greater than
+0, and 1 otherwise.
+An integer r is a *rank index* of an index space S if r is in the range
+[0, rank of $S$).
+A pack of integers `idx` is a *multidimensional index* in a
+multidimensional index space S (or representation thereof) if both of
+the following are true:
+- `sizeof...(idx)` is equal to the rank of S, and
+- for every rank index i of S, the iᵗʰ value of `idx` is an integer in
+  the interval [Lᵢ, Uᵢ) of S.
+#### Header `<mdspan>` synopsis <a id="mdspan.syn">[[mdspan.syn]]</a>
+``` cpp
+namespace std {
+  // [mdspan.extents], class template extents
+  template<class IndexType, size_t... Extents>
+    class extents;
+  // [mdspan.extents.dextents], alias template dextents
+  template<class IndexType, size_t Rank>
+    using dextents = see below;
+  // [mdspan.layout], layout mapping
+  struct layout_left;
+  struct layout_right;
+  struct layout_stride;
+  // [mdspan.accessor.default], class template default_accessor
+  template<class ElementType>
+    class default_accessor;
+  // [mdspan.mdspan], class template mdspan
+  template<class ElementType, class Extents, class LayoutPolicy = layout_right,
+           class AccessorPolicy = default_accessor<ElementType>>
+    class mdspan;
+}
+```
+#### Class template `extents` <a id="mdspan.extents">[[mdspan.extents]]</a>
+##### Overview <a id="mdspan.extents.overview">[[mdspan.extents.overview]]</a>
+The class template `extents` represents a multidimensional index space
+of rank equal to `sizeof...(Extents)`. In subclause [[views]], `extents`
+is used synonymously with multidimensional index space.
+``` cpp
+namespace std {
+  template<class IndexType, size_t... Extents>
+  class extents {
+  public:
+    using index_type = IndexType;
+    using size_type = make_unsigned_t<index_type>;
+    using rank_type = size_t;
+    // [mdspan.extents.obs], observers of the multidimensional index space
+    static constexpr rank_type rank() noexcept { return sizeof...(Extents); }
+    static constexpr rank_type rank_dynamic() noexcept { return dynamic-index(rank()); }
+    static constexpr size_t static_extent(rank_type) noexcept;
+    constexpr index_type extent(rank_type) const noexcept;
+    // [mdspan.extents.cons], constructors
+    constexpr extents() noexcept = default;
+    template<class OtherIndexType, size_t... OtherExtents>
+      constexpr explicit(see below)
+        extents(const extents<OtherIndexType, OtherExtents...>&) noexcept;
+    template<class... OtherIndexTypes>
+      constexpr explicit extents(OtherIndexTypes...) noexcept;
+    template<class OtherIndexType, size_t N>
+      constexpr explicit(N != rank_dynamic())
+        extents(span<OtherIndexType, N>) noexcept;
+    template<class OtherIndexType, size_t N>
+      constexpr explicit(N != rank_dynamic())
+        extents(const array<OtherIndexType, N>&) noexcept;
+    // [mdspan.extents.cmp], comparison operators
+    template<class OtherIndexType, size_t... OtherExtents>
+      friend constexpr bool operator==(const extents&,
+                                       const extents<OtherIndexType, OtherExtents...>&) noexcept;
+    // [mdspan.extents.expo], exposition-only helpers
+    constexpr size_t fwd-prod-of-extents(rank_type) const noexcept;     // exposition only
+    constexpr size_t rev-prod-of-extents(rank_type) const noexcept;     // exposition only
+    template<class OtherIndexType>
+      static constexpr auto index-cast(OtherIndexType&&) noexcept;      // exposition only
+  private:
+    static constexpr rank_type dynamic-index(rank_type) noexcept;       // exposition only
+    static constexpr rank_type dynamic-index-inv(rank_type) noexcept;   // exposition only
+    array<index_type, rank_dynamic()> dynamic-extents{};                // exposition only
+  };
+  template<class... Integrals>
+    explicit extents(Integrals...)
+      -> see below;
+}
+```
+*Mandates:*
+- `IndexType` is a signed or unsigned integer type, and
+- each element of `Extents` is either equal to `dynamic_extent`, or is
+  representable as a value of type `IndexType`.
+Each specialization of `extents` models `regular` and is trivially
+copyable.
+Let Eᵣ be the rᵗʰ element of `Extents`. Eᵣ is a *dynamic extent* if it
+is equal to `dynamic_extent`, otherwise Eᵣ is a *static extent*. Let Dᵣ
+be the value of `dynamic-extents[dynamic-index(r)]` if Eᵣ is a dynamic
+extent, otherwise Eᵣ.
+The rᵗʰ interval of the multidimensional index space represented by an
+`extents` object is [0, Dᵣ).
+##### Exposition-only helpers <a id="mdspan.extents.expo">[[mdspan.extents.expo]]</a>
+``` cpp
+static constexpr rank_type dynamic-index(rank_type i) noexcept;
+```
+*Preconditions:* `i <= rank()` is `true`.
+*Returns:* The number of Eᵣ with r < `i` for which Eᵣ is a dynamic
+extent.
+``` cpp
+static constexpr rank_type dynamic-index-inv(rank_type i) noexcept;
+```
+*Preconditions:* `i < rank_dynamic()` is `true`.
+*Returns:* The minimum value of r such that
+*`dynamic-index`*`(`r` + 1) == i + 1` is `true`.
+``` cpp
+constexpr size_t fwd-prod-of-extents(rank_type i) const noexcept;
+```
+*Preconditions:* `i <= rank()` is `true`.
+*Returns:* If `i > 0` is `true`, the product of `extent(`k`)` for all k
+in the range [0, `i`), otherwise `1`.
+``` cpp
+constexpr size_t rev-prod-of-extents(rank_type i) const noexcept;
+```
+*Preconditions:* `i < rank()` is `true`.
+*Returns:* If `i + 1 < rank()` is `true`, the product of `extent(`k`)`
+for all k in the range [`i + 1`, `rank()`), otherwise `1`.
+``` cpp
+template<class OtherIndexType>
+  static constexpr auto index-cast(OtherIndexType&& i) noexcept;
+```
+*Effects:*
+- If `OtherIndexType` is an integral type other than `bool`, then
+  equivalent to `return i;`,
+- otherwise, equivalent to `return static_cast<index_type>(i);`.
+[*Note 1*: This function will always return an integral type other than
+`bool`. Since this function’s call sites are constrained on
+convertibility of `OtherIndexType` to `index_type`, integer-class types
+can use the `static_cast` branch without loss of
+precision. — *end note*]
+##### Constructors <a id="mdspan.extents.cons">[[mdspan.extents.cons]]</a>
+``` cpp
+template<class OtherIndexType, size_t... OtherExtents>
+  constexpr explicit(see below)
+    extents(const extents<OtherIndexType, OtherExtents...>& other) noexcept;
+```
+*Constraints:*
+- `sizeof...(OtherExtents) == rank()` is `true`.
+- `((OtherExtents == dynamic_extent || Extents == dynamic_extent || OtherExtents == Extents) && ...)`
+  is `true`.
+*Preconditions:*
+- `other.extent(`r`)` equals Eᵣ for each r for which Eᵣ is a static
+  extent, and
+- either
+  - `sizeof...(OtherExtents)` is zero, or
+  - `other.extent(`r`)` is representable as a value of type `index_type`
+    for every rank index r of `other`.
+*Ensures:* `*this == other` is `true`.
+*Remarks:* The expression inside `explicit` is equivalent to:
+``` cpp
+(((Extents != dynamic_extent) && (OtherExtents == dynamic_extent)) || ... ) ||
+(numeric_limits<index_type>::max() < numeric_limits<OtherIndexType>::max())
+```
+``` cpp
+template<class... OtherIndexTypes>
+  constexpr explicit extents(OtherIndexTypes... exts) noexcept;
+```
+Let `N` be `sizeof...(OtherIndexTypes)`, and let `exts_arr` be
+`array<index_type, N>{static_cast<`
+`index_type>(std::move(exts))...}`.
+*Constraints:*
+- `(is_convertible_v<OtherIndexTypes, index_type> && ...)` is `true`,
+- `(is_nothrow_constructible_v<index_type, OtherIndexTypes> && ...)` is
+  `true`, and
+- `N == rank_dynamic() || N == rank()` is `true`. \[*Note 1*: One can
+  construct `extents` from just dynamic extents, which are all the
+  values getting stored, or from all the extents with a
+  precondition. — *end note*]
+*Preconditions:*
+- If `N != rank_dynamic()` is `true`, `exts_arr[`r`]` equals Eᵣ for each
+  r for which Eᵣ is a static extent, and
+- either
+  - `sizeof...(exts) == 0` is `true`, or
+  - each element of `exts` is nonnegative and is representable as a
+    value of type `index_type`.
+*Ensures:* `*this == extents(exts_arr)` is `true`.
+``` cpp
+template<class OtherIndexType, size_t N>
+  constexpr explicit(N != rank_dynamic())
+    extents(span<OtherIndexType, N> exts) noexcept;
+template<class OtherIndexType, size_t N>
+  constexpr explicit(N != rank_dynamic())
+    extents(const array<OtherIndexType, N>& exts) noexcept;
+```
+*Constraints:*
+- `is_convertible_v<const OtherIndexType&, index_type>` is `true`,
+- `is_nothrow_constructible_v<index_type, const OtherIndexType&>` is
+  `true`, and
+- `N == rank_dynamic() || N == rank()` is `true`.
+*Preconditions:*
+- If `N != rank_dynamic()` is `true`, `exts[`r`]` equals Eᵣ for each r
+  for which Eᵣ is a static extent, and
+- either
+  - `N` is zero, or
+  - `exts[`r`]` is nonnegative and is representable as a value of type
+    `index_type` for every rank index r.
+*Effects:*
+- If `N` equals `dynamic_rank()`, for all d in the range
+  [0, `rank_dynamic()`), direct-non-list-initializes
+  *`dynamic-extents`*`[`d`]` with `as_const(exts[`d`])`.
+- Otherwise, for all d in the range [0, `rank_dynamic()`),
+  direct-non-list-initializes *`dynamic-extents`*`[`d`]` with
+  `as_const(exts[`*`dynamic-index-inv`*`(`d`)])`.
+``` cpp
+template<class... Integrals>
+  explicit extents(Integrals...) -> see below;
+```
+*Constraints:* `(is_convertible_v<Integrals, size_t> && ...)` is `true`.
+*Remarks:* The deduced type is `dextents<size_t, sizeof...(Integrals)>`.
+##### Observers of the multidimensional index space <a id="mdspan.extents.obs">[[mdspan.extents.obs]]</a>
+``` cpp
+static constexpr size_t static_extent(rank_type i) noexcept;
+```
+*Preconditions:* `i < rank()` is `true`.
+*Returns:* E_`i`.
+``` cpp
+constexpr index_type extent(rank_type i) const noexcept;
+```
+*Preconditions:* `i < rank()` is `true`.
+*Returns:* D_`i`.
+##### Comparison operators <a id="mdspan.extents.cmp">[[mdspan.extents.cmp]]</a>
+``` cpp
+template<class OtherIndexType, size_t... OtherExtents>
+  friend constexpr bool operator==(const extents& lhs,
+                                   const extents<OtherIndexType, OtherExtents...>& rhs) noexcept;
+```
+*Returns:* `true` if `lhs.rank()` equals `rhs.rank()` and if
+`lhs.extent(r)` equals `rhs.extent(r)` for every rank index `r` of
+`rhs`, otherwise `false`.
+##### Alias template `dextents` <a id="mdspan.extents.dextents">[[mdspan.extents.dextents]]</a>
+``` cpp
+template<class IndexType, size_t Rank>
+  using dextents = see below;
+```
+*Result:* A type `E` that is a specialization of `extents` such that
+`E::rank() == Rank && E::rank() == E::rank_dynamic()` is `true`, and
+`E::index_type` denotes `IndexType`.
+#### Layout mapping <a id="mdspan.layout">[[mdspan.layout]]</a>
+##### General <a id="mdspan.layout.general">[[mdspan.layout.general]]</a>
+In subclauses [[mdspan.layout.reqmts]] and
+[[mdspan.layout.policy.reqmts]]:
+- `M` denotes a layout mapping class.
+- `m` denotes a (possibly const) value of type `M`.
+- `i` and `j` are packs of (possibly const) integers that are
+  multidimensional indices in `m.extents()` [[mdspan.overview]].
+  \[*Note 1*: The type of each element of the packs can be a different
+  integer type. — *end note*]
+- `r` is a (possibly const) rank index of `typename M::extents_type`.
+- `dᵣ` is a pack of (possibly const) integers for which
+  `sizeof...(dᵣ) == M::extents_type::rank()` is `true`, the rᵗʰ element
+  is equal to 1, and all other elements are equal to 0.
+In subclauses [[mdspan.layout.reqmts]] through [[mdspan.layout.stride]],
+let *`is-mapping-of`* be the exposition-only variable template defined
+as follows:
+``` cpp
+template<class Layout, class Mapping>
+constexpr bool is-mapping-of =  // exposition only
+  is_same_v<typename Layout::template mapping<typename Mapping::extents_type>, Mapping>;
+```
+##### Requirements <a id="mdspan.layout.reqmts">[[mdspan.layout.reqmts]]</a>
+A type `M` meets the *layout mapping* requirements if
+- `M` models `copyable` and `equality_comparable`,
+- `is_nothrow_move_constructible_v<M>` is `true`,
+- `is_nothrow_move_assignable_v<M>` is `true`,
+- `is_nothrow_swappable_v<M>` is `true`, and
+- the following types and expressions are well-formed and have the
+  specified semantics.
+``` cpp
+typename M::extents_type
+```
+*Result:* A type that is a specialization of `extents`.
+``` cpp
+typename M::index_type
+```
+*Result:* `typename M::extents_type::index_type`.
+``` cpp
+typename M::rank_type
+```
+*Result:* `typename M::extents_type::rank_type`.
+``` cpp
+typename M::layout_type
+```
+*Result:* A type `MP` that meets the layout mapping policy
+requirements [[mdspan.layout.policy.reqmts]] and for which
+*`is-mapping-of`*`<MP, M>` is `true`.
+``` cpp
+m.extents()
+```
+*Result:* `const typename M::extents_type&`
+``` cpp
+m(i...)
+```
+*Result:* `typename M::index_type`
+*Returns:* A nonnegative integer less than
+`numeric_limits<typename M::index_type>::max()` and less than or equal
+to `numeric_limits<size_t>::max()`.
+``` cpp
+m(i...) == m(static_cast<typename M::index_type>(i)...)
+```
+*Result:* `bool`
+*Returns:* `true`
+``` cpp
+m.required_span_size()
+```
+*Result:* `typename M::index_type`
+*Returns:* If the size of the multidimensional index space `m.extents()`
+is 0, then `0`, else `1` plus the maximum value of `m(i...)` for all
+`i`.
+``` cpp
+m.is_unique()
+```
+*Result:* `bool`
+*Returns:* `true` only if for every `i` and `j` where `(i != j || ...)`
+is `true`, `m(i...) != m(j...)` is `true`.
+[*Note 1*: A mapping can return `false` even if the condition is met.
+For certain layouts, it is possibly not feasible to determine
+efficiently whether the layout is unique. — *end note*]
+``` cpp
+m.is_exhaustive()
+```
+*Result:* `bool`
+*Returns:* `true` only if for all k in the range
+[0, `m.required_span_size()`) there exists an `i` such that `m(i...)`
+equals k.
+[*Note 2*: A mapping can return `false` even if the condition is met.
+For certain layouts, it is possibly not feasible to determine
+efficiently whether the layout is exhaustive. — *end note*]
+``` cpp
+m.is_strided()
+```
+*Result:* `bool`
+*Returns:* `true` only if for every rank index r of `m.extents()` there
+exists an integer sᵣ such that, for all `i` where (`i`+dᵣ) is a
+multidimensional index in `m.extents()` [[mdspan.overview]],
+`m((i + `dᵣ`)...) - m(i...)` equals sᵣ.
+[*Note 3*: This implies that for a strided layout
+m(i₀, …, iₖ) = m(0, …, 0) + i₀ × s₀ + … + iₖ × sₖ. — *end note*]
+[*Note 4*: A mapping can return `false` even if the condition is met.
+For certain layouts, it is possibly not feasible to determine
+efficiently whether the layout is strided. — *end note*]
+``` cpp
+m.stride(r)
+```
+*Preconditions:* `m.is_strided()` is `true`.
+*Result:* `typename M::index_type`
+*Returns:* sᵣ as defined in `m.is_strided()` above.
+``` cpp
+M::is_always_unique()
+```
+*Result:* A constant expression [[expr.const]] of type `bool`.
+*Returns:* `true` only if `m.is_unique()` is `true` for all possible
+objects `m` of type `M`.
+[*Note 5*: A mapping can return `false` even if the above condition is
+met. For certain layout mappings, it is possibly not feasible to
+determine whether every instance is unique. — *end note*]
+``` cpp
+M::is_always_exhaustive()
+```
+*Result:* A constant expression [[expr.const]] of type `bool`.
+*Returns:* `true` only if `m.is_exhaustive()` is `true` for all possible
+objects `m` of type `M`.
+[*Note 6*: A mapping can return `false` even if the above condition is
+met. For certain layout mappings, it is possibly not feasible to
+determine whether every instance is exhaustive. — *end note*]
+``` cpp
+M::is_always_strided()
+```
+*Result:* A constant expression [[expr.const]] of type `bool`.
+*Returns:* `true` only if `m.is_strided()` is `true` for all possible
+objects `m` of type `M`.
+[*Note 7*: A mapping can return `false` even if the above condition is
+met. For certain layout mappings, it is possibly not feasible to
+determine whether every instance is strided. — *end note*]
+##### Layout mapping policy requirements <a id="mdspan.layout.policy.reqmts">[[mdspan.layout.policy.reqmts]]</a>
+A type `MP` meets the *layout mapping policy* requirements if for a type
+`E` that is a specialization of `extents`, `MP::mapping<E>` is valid and
+denotes a type `X` that meets the layout mapping requirements
+[[mdspan.layout.reqmts]], and for which the *qualified-id*
+`X::layout_type` is valid and denotes the type `MP` and the
+*qualified-id* `X::extents_type` denotes `E`.
+##### Layout mapping policies <a id="mdspan.layout.policy.overview">[[mdspan.layout.policy.overview]]</a>
+``` cpp
+namespace std {
+  struct layout_left {
+    template<class Extents>
+      class mapping;
+  };
+  struct layout_right {
+    template<class Extents>
+      class mapping;
+  };
+  struct layout_stride {
+    template<class Extents>
+      class mapping;
+  };
+}
+```
+Each of `layout_left`, `layout_right`, and `layout_stride` meets the
+layout mapping policy requirements and is a trivial type.
+##### Class template `layout_left::mapping` <a id="mdspan.layout.left">[[mdspan.layout.left]]</a>
+###### Overview <a id="mdspan.layout.left.overview">[[mdspan.layout.left.overview]]</a>
+`layout_left` provides a layout mapping where the leftmost extent has
+stride 1, and strides increase left-to-right as the product of extents.
+``` cpp
+namespace std {
+  template<class Extents>
+  class layout_left::mapping {
+  public:
+    using extents_type = Extents;
+    using index_type = typename extents_type::index_type;
+    using size_type = typename extents_type::size_type;
+    using rank_type = typename extents_type::rank_type;
+    using layout_type = layout_left;
+    // [mdspan.layout.left.cons], constructors
+    constexpr mapping() noexcept = default;
+    constexpr mapping(const mapping&) noexcept = default;
+    constexpr mapping(const extents_type&) noexcept;
+    template<class OtherExtents>
+      constexpr explicit(!is_convertible_v<OtherExtents, extents_type>)
+        mapping(const mapping<OtherExtents>&) noexcept;
+    template<class OtherExtents>
+      constexpr explicit(!is_convertible_v<OtherExtents, extents_type>)
+        mapping(const layout_right::mapping<OtherExtents>&) noexcept;
+    template<class OtherExtents>
+      constexpr explicit(extents_type::rank() > 0)
+        mapping(const layout_stride::mapping<OtherExtents>&);
+    constexpr mapping& operator=(const mapping&) noexcept = default;
+    // [mdspan.layout.left.obs], observers
+    constexpr const extents_type& extents() const noexcept { return extents_; }
+    constexpr index_type required_span_size() const noexcept;
+    template<class... Indices>
+      constexpr index_type operator()(Indices...) const noexcept;
+    static constexpr bool is_always_unique() noexcept { return true; }
+    static constexpr bool is_always_exhaustive() noexcept { return true; }
+    static constexpr bool is_always_strided() noexcept { return true; }
+    static constexpr bool is_unique() noexcept { return true; }
+    static constexpr bool is_exhaustive() noexcept { return true; }
+    static constexpr bool is_strided() noexcept { return true; }
+    constexpr index_type stride(rank_type) const noexcept;
+    template<class OtherExtents>
+      friend constexpr bool operator==(const mapping&, const mapping<OtherExtents>&) noexcept;
+  private:
+    extents_type extents_{};    // exposition only
+  };
+}
+```
+If `Extents` is not a specialization of `extents`, then the program is
+ill-formed.
+`layout_left::mapping<E>` is a trivially copyable type that models
+`regular` for each `E`.
+*Mandates:* If `Extents::rank_dynamic() == 0` is `true`, then the size
+of the multidimensional index space `Extents()` is representable as a
+value of type `typename Extents::index_type`.
+###### Constructors <a id="mdspan.layout.left.cons">[[mdspan.layout.left.cons]]</a>
+``` cpp
+constexpr mapping(const extents_type& e) noexcept;
+```
+*Preconditions:* The size of the multidimensional index space `e` is
+representable as a value of type `index_type` [[basic.fundamental]].
+*Effects:* Direct-non-list-initializes *extents\_* with `e`.
+``` cpp
+template<class OtherExtents>
+  constexpr explicit(!is_convertible_v<OtherExtents, extents_type>)
+    mapping(const mapping<OtherExtents>& other) noexcept;
+```
+*Constraints:* `is_constructible_v<extents_type, OtherExtents>` is
+`true`.
+*Preconditions:* `other.required_span_size()` is representable as a
+value of type `index_type` [[basic.fundamental]].
+*Effects:* Direct-non-list-initializes *extents\_* with
+`other.extents()`.
+``` cpp
+template<class OtherExents>
+  constexpr explicit(!is_convertible_v<OtherExtents, extents_type>)
+    mapping(const layout_right::mapping<OtherExtents>& other) noexcept;
+```
+*Constraints:*
+- `extents_type::rank() <= 1` is `true`, and
+- `is_constructible_v<extents_type, OtherExtents>` is `true`.
+*Preconditions:* `other.required_span_size()` is representable as a
+value of type `index_type` [[basic.fundamental]].
+*Effects:* Direct-non-list-initializes *extents\_* with
+`other.extents()`.
+``` cpp
+template<class OtherExtents>
+  constexpr explicit(extents_type::rank() > 0)
+    mapping(const layout_stride::mapping<OtherExtents>& other);
+```
+*Constraints:* `is_constructible_v<extents_type, OtherExtents>` is
+`true`.
+*Preconditions:*
+- If `extents_type::rank() > 0` is `true`, then for all r in the range
+  [0, `extents_type::rank()`), `other.stride(`r`)` equals
+  `other.extents().`*`fwd-prod-of-extents`*`(`r`)`, and
+- `other.required_span_size()` is representable as a value of type
+  `index_type` [[basic.fundamental]].
+*Effects:* Direct-non-list-initializes *extents\_* with
+`other.extents()`.
+###### Observers <a id="mdspan.layout.left.obs">[[mdspan.layout.left.obs]]</a>
+``` cpp
+constexpr index_type required_span_size() const noexcept;
+```
+*Returns:* `extents().`*`fwd-prod-of-extents`*`(extents_type::rank())`.
+``` cpp
+template<class... Indices>
+  constexpr index_type operator()(Indices... i) const noexcept;
+```
+*Constraints:*
+- `sizeof...(Indices) == extents_type::rank()` is `true`,
+- `(is_convertible_v<Indices, index_type> && ...)` is `true`, and
+- `(is_nothrow_constructible_v<index_type, Indices> && ...)` is `true`.
+*Preconditions:* `extents_type::`*`index-cast`*`(i)` is a
+multidimensional index in *extents\_*[[mdspan.overview]].
+*Effects:* Let `P` be a parameter pack such that
+``` cpp
+is_same_v<index_sequence_for<Indices...>, index_sequence<P...>>
+```
+is `true`. Equivalent to:
+``` cpp
+return ((static_cast<index_type>(i) * stride(P)) + ... + 0);
+```
+``` cpp
+constexpr index_type stride(rank_type i) const;
+```
+*Constraints:* `extents_type::rank() > 0` is `true`.
+*Preconditions:* `i < extents_type::rank()` is `true`.
+*Returns:* `extents().`*`fwd-prod-of-extents`*`(i)`.
+``` cpp
+template<class OtherExtents>
+  friend constexpr bool operator==(const mapping& x, const mapping<OtherExtents>& y) noexcept;
+```
+*Constraints:* `extents_type::rank() == OtherExtents::rank()` is `true`.
+*Effects:* Equivalent to: `return x.extents() == y.extents();`
+##### Class template `layout_right::mapping` <a id="mdspan.layout.right">[[mdspan.layout.right]]</a>
+###### Overview <a id="mdspan.layout.right.overview">[[mdspan.layout.right.overview]]</a>
+`layout_right` provides a layout mapping where the rightmost extent is
+stride 1, and strides increase right-to-left as the product of extents.
+``` cpp
+namespace std {
+  template<class Extents>
+  class layout_right::mapping {
+  public:
+    using extents_type = Extents;
+    using index_type = typename extents_type::index_type;
+    using size_type = typename extents_type::size_type;
+    using rank_type = typename extents_type::rank_type;
+    using layout_type = layout_right;
+    // [mdspan.layout.right.cons], constructors
+    constexpr mapping() noexcept = default;
+    constexpr mapping(const mapping&) noexcept = default;
+    constexpr mapping(const extents_type&) noexcept;
+    template<class OtherExtents>
+      constexpr explicit(!is_convertible_v<OtherExtents, extents_type>)
+        mapping(const mapping<OtherExtents>&) noexcept;
+    template<class OtherExtents>
+      constexpr explicit(!is_convertible_v<OtherExtents, extents_type>)
+        mapping(const layout_left::mapping<OtherExtents>&) noexcept;
+    template<class OtherExtents>
+      constexpr explicit(extents_type::rank() > 0)
+        mapping(const layout_stride::mapping<OtherExtents>&) noexcept;
+    constexpr mapping& operator=(const mapping&) noexcept = default;
+    // [mdspan.layout.right.obs], observers
+    constexpr const extents_type& extents() const noexcept { return extents_; }
+    constexpr index_type required_span_size() const noexcept;
+    template<class... Indices>
+      constexpr index_type operator()(Indices...) const noexcept;
+    static constexpr bool is_always_unique() noexcept { return true; }
+    static constexpr bool is_always_exhaustive() noexcept { return true; }
+    static constexpr bool is_always_strided() noexcept { return true; }
+    static constexpr bool is_unique() noexcept { return true; }
+    static constexpr bool is_exhaustive() noexcept { return true; }
+    static constexpr bool is_strided() noexcept { return true; }
+    constexpr index_type stride(rank_type) const noexcept;
+    template<class OtherExtents>
+      friend constexpr bool operator==(const mapping&, const mapping<OtherExtents>&) noexcept;
+  private:
+    extents_type extents_{};    // exposition only
+  };
+}
+```
+If `Extents` is not a specialization of `extents`, then the program is
+ill-formed.
+`layout_right::mapping<E>` is a trivially copyable type that models
+`regular` for each `E`.
+*Mandates:* If `Extents::rank_dynamic() == 0` is `true`, then the size
+of the multidimensional index space `Extents()` is representable as a
+value of type `typename Extents::index_type`.
+###### Constructors <a id="mdspan.layout.right.cons">[[mdspan.layout.right.cons]]</a>
+``` cpp
+constexpr mapping(const extents_type& e) noexcept;
+```
+*Preconditions:* The size of the multidimensional index space `e` is
+representable as a value of type `index_type` [[basic.fundamental]].
+*Effects:* Direct-non-list-initializes *extents\_* with `e`.
+``` cpp
+template<class OtherExtents>
+  constexpr explicit(!is_convertible_v<OtherExtents, extents_type>)
+    mapping(const mapping<OtherExtents>& other) noexcept;
+```
+*Constraints:* `is_constructible_v<extents_type, OtherExtents>` is
+`true`.
+*Preconditions:* `other.required_span_size()` is representable as a
+value of type `index_type` [[basic.fundamental]].
+*Effects:* Direct-non-list-initializes *extents\_* with
+`other.extents()`.
+``` cpp
+template<class OtherExtents>
+  constexpr explicit(!is_convertible_v<OtherExtents, extents_type>)
+    mapping(const layout_left::mapping<OtherExtents>& other) noexcept;
+```
+*Constraints:*
+- `extents_type::rank() <= 1` is `true`, and
+- `is_constructible_v<extents_type, OtherExtents>` is `true`.
+*Preconditions:* `other.required_span_size()` is representable as a
+value of type `index_type` [[basic.fundamental]].
+*Effects:* Direct-non-list-initializes *extents\_* with
+`other.extents()`.
+``` cpp
+template<class OtherExtents>
+ constexpr explicit(extents_type::rank() > 0)
+    mapping(const layout_stride::mapping<OtherExtents>& other) noexcept;
+```
+*Constraints:* `is_constructible_v<extents_type, OtherExtents>` is
+`true`.
+*Preconditions:*
+- If `extents_type::rank() > 0` is `true`, then for all r in the range
+  [0, `extents_type::rank()`), `other.stride(`r`)` equals
+  `other.extents().`*`rev-prod-of-extents`*`(`r`)`.
+- `other.required_span_size()` is representable as a value of type
+  `index_type` [[basic.fundamental]].
+*Effects:* Direct-non-list-initializes *extents\_* with
+`other.extents()`.
+###### Observers <a id="mdspan.layout.right.obs">[[mdspan.layout.right.obs]]</a>
+``` cpp
+index_type required_span_size() const noexcept;
+```
+*Returns:* `extents().`*`fwd-prod-of-extents`*`(extents_type::rank())`.
+``` cpp
+template<class... Indices>
+  constexpr index_type operator()(Indices... i) const noexcept;
+```
+*Constraints:*
+- `sizeof...(Indices) == extents_type::rank()` is `true`,
+- `(is_convertible_v<Indices, index_type> && ...)` is `true`, and
+- `(is_nothrow_constructible_v<index_type, Indices> && ...)` is `true`.
+*Preconditions:* `extents_type::`*`index-cast`*`(i)` is a
+multidimensional index in *extents\_*[[mdspan.overview]].
+*Effects:* Let `P` be a parameter pack such that
+``` cpp
+is_same_v<index_sequence_for<Indices...>, index_sequence<P...>>
+```
+is `true`. Equivalent to:
+``` cpp
+return ((static_cast<index_type>(i) * stride(P)) + ... + 0);
+```
+``` cpp
+constexpr index_type stride(rank_type i) const noexcept;
+```
+*Constraints:* `extents_type::rank() > 0` is `true`.
+*Preconditions:* `i < extents_type::rank()` is `true`.
+*Returns:* `extents().`*`rev-prod-of-extents`*`(i)`.
+``` cpp
+template<class OtherExtents>
+  friend constexpr bool operator==(const mapping& x, const mapping<OtherExtents>& y) noexcept;
+```
+*Constraints:* `extents_type::rank() == OtherExtents::rank()` is `true`.
+*Effects:* Equivalent to: `return x.extents() == y.extents();`
+##### Class template `layout_stride::mapping` <a id="mdspan.layout.stride">[[mdspan.layout.stride]]</a>
+###### Overview <a id="mdspan.layout.stride.overview">[[mdspan.layout.stride.overview]]</a>
+`layout_stride` provides a layout mapping where the strides are
+user-defined.
+``` cpp
+namespace std {
+  template<class Extents>
+  class layout_stride::mapping {
+  public:
+    using extents_type = Extents;
+    using index_type = typename extents_type::index_type;
+    using size_type = typename extents_type::size_type;
+    using rank_type = typename extents_type::rank_type;
+    using layout_type = layout_stride;
+  private:
+    static constexpr rank_type rank_ = extents_type::rank();    // exposition only
+  public:
+    // [mdspan.layout.stride.cons], constructors
+    constexpr mapping() noexcept;
+    constexpr mapping(const mapping&) noexcept = default;
+    template<class OtherIndexType>
+      constexpr mapping(const extents_type&, span<OtherIndexType, rank_>) noexcept;
+    template<class OtherIndexType>
+      constexpr mapping(const extents_type&, const array<OtherIndexType, rank_>&) noexcept;
+    template<class StridedLayoutMapping>
+      constexpr explicit(see below) mapping(const StridedLayoutMapping&) noexcept;
+    constexpr mapping& operator=(const mapping&) noexcept = default;
+    // [mdspan.layout.stride.obs], observers
+    constexpr const extents_type& extents() const noexcept { return extents_; }
+    constexpr array<index_type, rank_> strides() const noexcept { return strides_; }
+    constexpr index_type required_span_size() const noexcept;
+    template<class... Indices>
+      constexpr index_type operator()(Indices...) const noexcept;
+    static constexpr bool is_always_unique() noexcept { return true; }
+    static constexpr bool is_always_exhaustive() noexcept { return false; }
+    static constexpr bool is_always_strided() noexcept { return true; }
+    static constexpr bool is_unique() noexcept { return true; }
+    constexpr bool is_exhaustive() const noexcept;
+    static constexpr bool is_strided() noexcept { return true; }
+    constexpr index_type stride(rank_type i) const noexcept { return strides_[i]; }
+    template<class OtherMapping>
+      friend constexpr bool operator==(const mapping&, const OtherMapping&) noexcept;
+  private:
+    extents_type extents_{};                    // exposition only
+    array<index_type, rank_> strides_{};        // exposition only
+  };
+}
+```
+If `Extents` is not a specialization of `extents`, then the program is
+ill-formed.
+`layout_stride::mapping<E>` is a trivially copyable type that models
+`regular` for each `E`.
+*Mandates:* If `Extents::rank_dynamic() == 0` is `true`, then the size
+of the multidimensional index space `Extents()` is representable as a
+value of type `typename Extents::index_type`.
+###### Exposition-only helpers <a id="mdspan.layout.stride.expo">[[mdspan.layout.stride.expo]]</a>
+Let `REQUIRED-SPAN-SIZE(e, strides)` be:
+- `1`, if `e.rank() == 0` is `true`,
+- otherwise `0`, if the size of the multidimensional index space `e` is
+  0,
+- otherwise `1` plus the sum of products of `(e.extent(r) - 1)` and
+  `strides[r]` for all r in the range [0, `e.rank()`).
+Let `OFFSET(m)` be:
+- `m()`, if `e.rank() == 0` is `true`,
+- otherwise `0`, if the size of the multidimensional index space `e` is
+  0,
+- otherwise `m(z...)` for a pack of integers `z` that is a
+  multidimensional index in `m.extents()` and each element of `z` equals
+  0.
+Let *`is-extents`* be the exposition-only variable template defined as
+follows:
+``` cpp
+template<class T>
+  constexpr bool is-extents = false;                              // exposition only
+template<class IndexType, size_t... Args>
+  constexpr bool is-extents<extents<IndexType, Args...>> = true;  // exposition only
+```
+Let `layout-mapping-alike` be the exposition-only concept defined as
+follows:
+``` cpp
+template<class M>
+concept layout-mapping-alike = requires {                         // exposition only
+  requires is-extents<typename M::extents_type>;
+  { M::is_always_strided() } -> same_as<bool>;
+  { M::is_always_exhaustive() } -> same_as<bool>;
+  { M::is_always_unique() } -> same_as<bool>;
+  bool_constant<M::is_always_strided()>::value;
+  bool_constant<M::is_always_exhaustive()>::value;
+  bool_constant<M::is_always_unique()>::value;
+};
+```
+[*Note 2*: This concept checks that the functions
+`M::is_always_strided()`, `M::is_always_exhaustive()`, and
+`M::is_always_unique()` exist, are constant expressions, and have a
+return type of `bool`. — *end note*]
+###### Constructors <a id="mdspan.layout.stride.cons">[[mdspan.layout.stride.cons]]</a>
+``` cpp
+constexpr mapping() noexcept;
+```
+*Preconditions:*
+`layout_right::mapping<extents_type>().required_span_size()` is
+representable as a value of type `index_type` [[basic.fundamental]].
+*Effects:* Direct-non-list-initializes *extents\_* with
+`extents_type()`, and for all d in the range \[`0`, *`rank_`*),
+direct-non-list-initializes *`strides_`*`[`d`]` with
+`layout_right::mapping<extents_type>().stride(`d`)`.
+``` cpp
+template<class OtherIndexType>
+  constexpr mapping(const extents_type& e, span<OtherIndexType, rank_> s) noexcept;
+template<class OtherIndexType>
+  constexpr mapping(const extents_type& e, const array<OtherIndexType, rank_>& s) noexcept;
+```
+*Constraints:*
+- `is_convertible_v<const OtherIndexType&, index_type>` is `true`, and
+- `is_nothrow_constructible_v<index_type, const OtherIndexType&>` is
+  `true`.
+*Preconditions:*
+- `s[`i`] > 0` is `true` for all i in the range [0, rank_).
+- *`REQUIRED-SPAN-SIZE`*`(e, s)` is representable as a value of type
+  `index_type` [[basic.fundamental]].
+- If *rank\_* is greater than 0, then there exists a permutation P of
+  the integers in the range [0, rank_), such that
+  `s[`pᵢ`] >= s[`pᵢ₋₁`] * e.extent(p`ᵢ₋₁`)` is `true` for all i in the
+  range [1, rank_), where pᵢ is the iᵗʰ element of P. \[*Note 3*: For
+  `layout_stride`, this condition is necessary and sufficient for
+  `is_unique()` to be `true`. — *end note*]
+*Effects:* Direct-non-list-initializes *extents\_* with `e`, and for all
+d in the range [0, rank_), direct-non-list-initializes `strides_[`d`]`
+with `as_const(s[`d`])`.
+``` cpp
+template<class StridedLayoutMapping>
+  constexpr explicit(see below)
+    mapping(const StridedLayoutMapping& other) noexcept;
+```
+*Constraints:*
+- `layout-mapping-alike<StridedLayoutMapping>` is satisfied.
+- `is_constructible_v<extents_type, typename StridedLayoutMapping::extents_type>`
+  is
+  `true`.
+- `StridedLayoutMapping::is_always_unique()` is `true`.
+- `StridedLayoutMapping::is_always_strided()` is `true`.
+*Preconditions:*
+- `StridedLayoutMapping` meets the layout mapping
+  requirements [[mdspan.layout.policy.reqmts]],
+- `other.stride(`r`) > 0` is `true` for every rank index r of
+  `extents()`,
+- `other.required_span_size()` is representable as a value of type
+  `index_type` [[basic.fundamental]], and
+- *`OFFSET`*`(other) == 0` is `true`.
+*Effects:* Direct-non-list-initializes *extents\_* with
+`other.extents()`, and for all d in the range [0, rank_),
+direct-non-list-initializes *`strides_`*`[`d`]` with
+`other.stride(`d`)`.
+Remarks: The expression inside `explicit` is equivalent to:
+``` cpp
+!(is_convertible_v<typename StridedLayoutMapping::extents_type, extents_type> &&
+  (is-mapping-of<layout_left, LayoutStrideMapping> ||
+   is-mapping-of<layout_right, LayoutStrideMapping> ||
+   is-mapping-of<layout_stride, LayoutStrideMapping>))
+```
+###### Observers <a id="mdspan.layout.stride.obs">[[mdspan.layout.stride.obs]]</a>
+``` cpp
+constexpr index_type required_span_size() const noexcept;
+```
+*Returns:* *`REQUIRED-SPAN-SIZE`*`(extents(), `*`strides_`*`)`.
+``` cpp
+template<class... Indices>
+  constexpr index_type operator()(Indices... i) const noexcept;
+```
+*Constraints:*
+- `sizeof...(Indices) == `*`rank_`* is `true`,
+- `(is_convertible_v<Indices, index_type> && ...)` is `true`, and
+- `(is_nothrow_constructible_v<index_type, Indices> && ...)` is `true`.
+*Preconditions:* `extents_type::`*`index-cast`*`(i)` is a
+multidimensional index in *extents\_*[[mdspan.overview]].
+*Effects:* Let `P` be a parameter pack such that
+``` cpp
+is_same_v<index_sequence_for<Indices...>, index_sequence<P...>>
+```
+is `true`. Equivalent to:
+``` cpp
+return ((static_cast<index_type>(i) * stride(P)) + ... + 0);
+```
+``` cpp
+constexpr bool is_exhaustive() const noexcept;
+```
+*Returns:*
+- `true` if *rank\_* is 0.
+- Otherwise, `true` if there is a permutation P of the integers in the
+  range [0, rank_) such that `stride(`p₀`)` equals 1, and `stride(`pᵢ`)`
+  equals `stride(`pᵢ₋₁`) * extents().extent(`pᵢ₋₁`)` for i in the range
+  [1, rank_), where pᵢ is the iᵗʰ element of P.
+- Otherwise, `false`.
+``` cpp
+template<class OtherMapping>
+  friend constexpr bool operator==(const mapping& x, const OtherMapping& y) noexcept;
+```
+*Constraints:*
+- `layout-mapping-alike<OtherMapping>` is satisfied.
+- *`rank_`*` == OtherMapping::extents_type::rank()` is `true`.
+- `OtherMapping::is_always_strided()` is `true`.
+*Preconditions:* `OtherMapping` meets the layout mapping
+requirements [[mdspan.layout.policy.reqmts]].
+*Returns:* `true` if `x.extents() == y.extents()` is `true`,
+*`OFFSET`*`(y) == 0` is `true`, and each of
+`x.stride(`r`) == y.stride(`r`)` is `true` for r in the range
+[0, `x.extents().rank()`). Otherwise, `false`.
+#### Accessor policy <a id="mdspan.accessor">[[mdspan.accessor]]</a>
+##### General <a id="mdspan.accessor.general">[[mdspan.accessor.general]]</a>
+An *accessor policy* defines types and operations by which a reference
+to a single object is created from an abstract data handle to a number
+of such objects and an index.
+A range of indices [0, N) is an *accessible range* of a given data
+handle and an accessor if, for each i in the range, the accessor
+policy’s `access` function produces a valid reference to an object.
+In subclause [[mdspan.accessor.reqmts]],
+- `A` denotes an accessor policy.
+- `a` denotes a value of type `A` or `const A`.
+- `p` denotes a value of type `A::data_handle_type` or
+  `const A::data_handle_type`. \[*Note 1*: The type
+  `A::data_handle_type` need not be dereferenceable. — *end note*]
+- `n`, `i`, and `j` each denote values of type `size_t`.
+##### Requirements <a id="mdspan.accessor.reqmts">[[mdspan.accessor.reqmts]]</a>
+A type `A` meets the accessor policy requirements if
+- `A` models `copyable`,
+- `is_nothrow_move_constructible_v<A>` is `true`,
+- `is_nothrow_move_assignable_v<A>` is `true`,
+- `is_nothrow_swappable_v<A>` is `true`, and
+- the following types and expressions are well-formed and have the
+  specified semantics.
+``` cpp
+typename A::element_type
+```
+*Result:* A complete object type that is not an abstract class type.
+``` cpp
+typename A::data_handle_type
+```
+*Result:* A type that models `copyable`, and for which
+`is_nothrow_move_constructible_v<A::data_handle_type>` is `true`,
+`is_nothrow_move_assignable_v<A::data_handle_type>` is `true`, and
+`is_nothrow_swappable_v<A::data_handle_type>` is `true`.
+[*Note 1*: The type of `data_handle_type` need not be
+`element_type*`. — *end note*]
+``` cpp
+typename A::reference
+```
+*Result:* A type that models
+`common_reference_with<A::reference&&, A::element_type&>`.
+[*Note 2*: The type of `reference` need not be
+`element_type&`. — *end note*]
+``` cpp
+typename A::offset_policy
+```
+*Result:* A type `OP` such that:
+- `OP` meets the accessor policy requirements,
+- `constructible_from<OP, const A&>` is modeled, and
+- `is_same_v<typename OP::element_type, typename A::element_type>` is
+  `true`.
+``` cpp
+a.access(p, i)
+```
+*Result:* `A::reference`
+*Remarks:* The expression is equality preserving.
+[*Note 3*: Concrete accessor policies can impose preconditions for
+their `access` function. However, they might not. For example, an
+accessor where `p` is `span<A::element_type, dynamic_extent>` and
+`access(p, i)` returns `p[i % p.size()]` does not need to impose a
+precondition on `i`. — *end note*]
+``` cpp
+a.offset(p, i)
+```
+*Result:* `A::offset_policy::data_handle_type`
+*Returns:* `q` such that for `b` being `A::offset_policy(a)`, and any
+integer `n` for which [0, `n`) is an accessible range of `p` and `a`:
+- [0, `n` - `i`) is an accessible range of `q` and `b`; and
+- `b.access(q, j)` provides access to the same element as
+  `a.access(p, i + j)`, for every `j` in the range [0, `n` - `i`).
+*Remarks:* The expression is equality-preserving.
+##### Class template `default_accessor` <a id="mdspan.accessor.default">[[mdspan.accessor.default]]</a>
+###### Overview <a id="mdspan.accessor.default.overview">[[mdspan.accessor.default.overview]]</a>
+``` cpp
+namespace std {
+  template<class ElementType>
+  struct default_accessor {
+    using offset_policy = default_accessor;
+    using element_type = ElementType;
+    using reference = ElementType&;
+    using data_handle_type = ElementType*;
+    constexpr default_accessor() noexcept = default;
+    template<class OtherElementType>
+      constexpr default_accessor(default_accessor<OtherElementType>) noexcept;
+    constexpr reference access(data_handle_type p, size_t i) const noexcept;
+    constexpr data_handle_type offset(data_handle_type p, size_t i) const noexcept;
+  };
+}
+```
+`default_accessor` meets the accessor policy requirements.
+`ElementType` is required to be a complete object type that is neither
+an abstract class type nor an array type.
+Each specialization of `default_accessor` is a trivially copyable type
+that models `semiregular`.
+[0, n) is an accessible range for an object `p` of type
+`data_handle_type` and an object of type `default_accessor` if and only
+if \[`p`, `p + `n) is a valid range.
+###### Members <a id="mdspan.accessor.default.members">[[mdspan.accessor.default.members]]</a>
+``` cpp
+template<class OtherElementType>
+  constexpr default_accessor(default_accessor<OtherElementType>) noexcept {}
+```
+*Constraints:*
+`is_convertible_v<OtherElementType(*)[], element_type(*)[]>` is `true`.
+``` cpp
+constexpr reference access(data_handle_type p, size_t i) const noexcept;
+```
+*Effects:* Equivalent to: `return p[i];`
+``` cpp
+constexpr data_handle_type offset(data_handle_type p, size_t i) const noexcept;
+```
+*Effects:* Equivalent to: `return p + i;`
+#### Class template `mdspan` <a id="mdspan.mdspan">[[mdspan.mdspan]]</a>
+##### Overview <a id="mdspan.mdspan.overview">[[mdspan.mdspan.overview]]</a>
+`mdspan` is a view of a multidimensional array of elements.
+``` cpp
+namespace std {
+  template<class ElementType, class Extents, class LayoutPolicy = layout_right,
+           class AccessorPolicy = default_accessor<ElementType>>
+  class mdspan {
+  public:
+    using extents_type = Extents;
+    using layout_type = LayoutPolicy;
+    using accessor_type = AccessorPolicy;
+    using mapping_type = typename layout_type::template mapping<extents_type>;
+    using element_type = ElementType;
+    using value_type = remove_cv_t<element_type>;
+    using index_type = typename extents_type::index_type;
+    using size_type = typename extents_type::size_type;
+    using rank_type = typename extents_type::rank_type;
+    using data_handle_type = typename accessor_type::data_handle_type;
+    using reference = typename accessor_type::reference;
+    static constexpr rank_type rank() noexcept { return extents_type::rank(); }
+    static constexpr rank_type rank_dynamic() noexcept { return extents_type::rank_dynamic(); }
+    static constexpr size_t static_extent(rank_type r) noexcept
+      { return extents_type::static_extent(r); }
+    constexpr index_type extent(rank_type r) const noexcept { return extents().extent(r); }
+    // [mdspan.mdspan.cons], constructors
+    constexpr mdspan();
+    constexpr mdspan(const mdspan& rhs) = default;
+    constexpr mdspan(mdspan&& rhs) = default;
+    template<class... OtherIndexTypes>
+      constexpr explicit mdspan(data_handle_type ptr, OtherIndexTypes... exts);
+    template<class OtherIndexType, size_t N>
+      constexpr explicit(N != rank_dynamic())
+        mdspan(data_handle_type p, span<OtherIndexType, N> exts);
+    template<class OtherIndexType, size_t N>
+      constexpr explicit(N != rank_dynamic())
+        mdspan(data_handle_type p, const array<OtherIndexType, N>& exts);
+    constexpr mdspan(data_handle_type p, const extents_type& ext);
+    constexpr mdspan(data_handle_type p, const mapping_type& m);
+    constexpr mdspan(data_handle_type p, const mapping_type& m, const accessor_type& a);
+    template<class OtherElementType, class OtherExtents,
+             class OtherLayoutPolicy, class OtherAccessorPolicy>
+      constexpr explicit(see below)
+        mdspan(const mdspan<OtherElementType, OtherExtents,
+                            OtherLayoutPolicy, OtherAccessorPolicy>& other);
+    constexpr mdspan& operator=(const mdspan& rhs) = default;
+    constexpr mdspan& operator=(mdspan&& rhs) = default;
+    // [mdspan.mdspan.members], members
+    template<class... OtherIndexTypes>
+      constexpr reference operator[](OtherIndexTypes... indices) const;
+    template<class OtherIndexType>
+      constexpr reference operator[](span<OtherIndexType, rank()> indices) const;
+    template<class OtherIndexType>
+      constexpr reference operator[](const array<OtherIndexType, rank()>& indices) const;
+    constexpr size_type size() const noexcept;
+    [[nodiscard]] constexpr bool empty() const noexcept;
+    friend constexpr void swap(mdspan& x, mdspan& y) noexcept;
+    constexpr const extents_type& extents() const noexcept { return map_.extents(); }
+    constexpr const data_handle_type& data_handle() const noexcept { return ptr_; }
+    constexpr const mapping_type& mapping() const noexcept { return map_; }
+    constexpr const accessor_type& accessor() const noexcept { return acc_; }
+    static constexpr bool is_always_unique()
+      { return mapping_type::is_always_unique(); }
+    static constexpr bool is_always_exhaustive()
+      { return mapping_type::is_always_exhaustive(); }
+    static constexpr bool is_always_strided()
+      { return mapping_type::is_always_strided(); }
+    constexpr bool is_unique() const
+      { return map_.is_unique(); }
+    constexpr bool is_exhaustive() const
+      { return map_.is_exhaustive(); }
+    constexpr bool is_strided() const
+      { return map_.is_strided(); }
+    constexpr index_type stride(rank_type r) const
+      { return map_.stride(r); }
+  private:
+    accessor_type acc_;         // exposition only
+    mapping_type map_;          // exposition only
+    data_handle_type ptr_;      // exposition only
+  };
+  template<class CArray>
+    requires(is_array_v<CArray> && rank_v<CArray> == 1)
+    mdspan(CArray&)
+      -> mdspan<remove_all_extents_t<CArray>, extents<size_t, extent_v<CArray, 0>>>;
+  template<class Pointer>
+    requires(is_pointer_v<remove_reference_t<Pointer>>)
+    mdspan(Pointer&&)
+      -> mdspan<remove_pointer_t<remove_reference_t<Pointer>>, extents<size_t>>;
+  template<class ElementType, class... Integrals>
+    requires((is_convertible_v<Integrals, size_t> && ...) && sizeof...(Integrals) > 0)
+    explicit mdspan(ElementType*, Integrals...)
+      -> mdspan<ElementType, dextents<size_t, sizeof...(Integrals)>>;
+  template<class ElementType, class OtherIndexType, size_t N>
+    mdspan(ElementType*, span<OtherIndexType, N>)
+      -> mdspan<ElementType, dextents<size_t, N>>;
+  template<class ElementType, class OtherIndexType, size_t N>
+    mdspan(ElementType*, const array<OtherIndexType, N>&)
+      -> mdspan<ElementType, dextents<size_t, N>>;
+  template<class ElementType, class IndexType, size_t... ExtentsPack>
+    mdspan(ElementType*, const extents<IndexType, ExtentsPack...>&)
+      -> mdspan<ElementType, extents<IndexType, ExtentsPack...>>;
+  template<class ElementType, class MappingType>
+    mdspan(ElementType*, const MappingType&)
+      -> mdspan<ElementType, typename MappingType::extents_type,
+                typename MappingType::layout_type>;
+  template<class MappingType, class AccessorType>
+    mdspan(const typename AccessorType::data_handle_type&, const MappingType&,
+           const AccessorType&)
+      -> mdspan<typename AccessorType::element_type, typename MappingType::extents_type,
+                typename MappingType::layout_type, AccessorType>;
+}
+```
+*Mandates:*
+- `ElementType` is a complete object type that is neither an abstract
+  class type nor an array type,
+- `Extents` is a specialization of `extents`, and
+- `is_same_v<ElementType, typename AccessorPolicy::element_type>` is
+  `true`.
+`LayoutPolicy` shall meet the layout mapping policy requirements
+[[mdspan.layout.policy.reqmts]], and `AccessorPolicy` shall meet the
+accessor policy requirements [[mdspan.accessor.reqmts]].
+Each specialization `MDS` of `mdspan` models `copyable` and
+- `is_nothrow_move_constructible_v<MDS>` is `true`,
+- `is_nothrow_move_assignable_v<MDS>` is `true`, and
+- `is_nothrow_swappable_v<MDS>` is `true`.
+A specialization of `mdspan` is a trivially copyable type if its
+`accessor_type`, `mapping_type`, and `data_handle_type` are trivially
+copyable types.
+##### Constructors <a id="mdspan.mdspan.cons">[[mdspan.mdspan.cons]]</a>
+``` cpp
+constexpr mdspan();
+```
+*Constraints:*
+- `rank_dynamic() > 0` is `true`.
+- `is_default_constructible_v<data_handle_type>` is `true`.
+- `is_default_constructible_v<mapping_type>` is `true`.
+- `is_default_constructible_v<accessor_type>` is `true`.
+*Preconditions:* $[0, \texttt{\textit{map_}.required_span_size()})$ is
+an accessible range of *ptr\_* and *acc\_* for the values of *map\_* and
+*acc\_* after the invocation of this constructor.
+*Effects:* Value-initializes *ptr\_*, *map\_*, and *acc\_*.
+``` cpp
+template<class... OtherIndexTypes>
+  constexpr explicit mdspan(data_handle_type p, OtherIndexTypes... exts);
+```
+Let `N` be `sizeof...(OtherIndexTypes)`.
+*Constraints:*
+- `(is_convertible_v<OtherIndexTypes, index_type> && ...)` is `true`,
+- `(is_nothrow_constructible<index_type, OtherIndexTypes> && ...)` is
+  `true`,
+- `N == rank() || N == rank_dynamic()` is `true`,
+- `is_constructible_v<mapping_type, extents_type>` is `true`, and
+- `is_default_constructible_v<accessor_type>` is `true`.
+*Preconditions:* $[0, \texttt{\textit{map_}.required_span_size()})$ is
+an accessible range of `p` and *acc\_* for the values of *map\_* and
+*acc\_* after the invocation of this constructor.
+*Effects:*
+- Direct-non-list-initializes *ptr\_* with `std::move(p)`,
+- direct-non-list-initializes *map\_* with
+  `extents_type(static_cast<index_type>(std::move(exts))...)`, and
+- value-initializes *acc\_*.
+``` cpp
+template<class OtherIndexType, size_t N>
+  constexpr explicit(N != rank_dynamic())
+    mdspan(data_handle_type p, span<OtherIndexType, N> exts);
+template<class OtherIndexType, size_t N>
+  constexpr explicit(N != rank_dynamic())
+    mdspan(data_handle_type p, const array<OtherIndexType, N>& exts);
+```
+*Constraints:*
+- `is_convertible_v<const OtherIndexType&, index_type>` is `true`,
+- `(is_nothrow_constructible<index_type, const OtherIndexType&> && ...)`
+  is `true`,
+- `N == rank() || N == rank_dynamic()` is `true`,
+- `is_constructible_v<mapping_type, extents_type>` is `true`, and
+- `is_default_constructible_v<accessor_type>` is `true`.
+*Preconditions:* $[0, \texttt{\textit{map_}.required_span_size()})$ is
+an accessible range of `p` and *acc\_* for the values of *map\_* and
+*acc\_* after the invocation of this constructor.
+*Effects:*
+- Direct-non-list-initializes *ptr\_* with `std::move(p)`,
+- direct-non-list-initializes *map\_* with `extents_type(exts)`, and
+- value-initializes *acc\_*.
+``` cpp
+constexpr mdspan(data_handle_type p, const extents_type& ext);
+```
+*Constraints:*
+- `is_constructible_v<mapping_type, const extents_type&>` is `true`, and
+- `is_default_constructible_v<accessor_type>` is `true`.
+*Preconditions:* $[0, \texttt{\textit{map_}.required_span_size()})$ is
+an accessible range of `p` and *acc\_* for the values of *map\_* and
+*acc\_* after the invocation of this constructor.
+*Effects:*
+- Direct-non-list-initializes *ptr\_* with `std::move(p)`,
+- direct-non-list-initializes *map\_* with `ext`, and
+- value-initializes *acc\_*.
+``` cpp
+constexpr mdspan(data_handle_type p, const mapping_type& m);
+```
+*Constraints:* `is_default_constructible_v<accessor_type>` is `true`.
+*Preconditions:* [0, `m.required_span_size()`) is an accessible range of
+`p` and *acc\_* for the value of *acc\_* after the invocation of this
+constructor.
+*Effects:*
+- Direct-non-list-initializes *ptr\_* with `std::move(p)`,
+- direct-non-list-initializes *map\_* with `m`, and
+- value-initializes *acc\_*.
+``` cpp
+constexpr mdspan(data_handle_type p, const mapping_type& m, const accessor_type& a);
+```
+*Preconditions:* [0, `m.required_span_size()`) is an accessible range of
+`p` and `a`.
+*Effects:*
+- Direct-non-list-initializes *ptr\_* with `std::move(p)`,
+- direct-non-list-initializes *map\_* with `m`, and
+- direct-non-list-initializes *acc\_* with `a`.
+``` cpp
+template<class OtherElementType, class OtherExtents,
+         class OtherLayoutPolicy, class OtherAccessor>
+  constexpr explicit(see below)
+    mdspan(const mdspan<OtherElementType, OtherExtents,
+                        OtherLayoutPolicy, OtherAccessor>& other);
+```
+*Constraints:*
+- `is_constructible_v<mapping_type, const OtherLayoutPolicy::template mapping<Oth- erExtents>&>`
+  is `true`, and
+- `is_constructible_v<accessor_type, const OtherAccessor&>` is `true`.
+*Mandates:*
+- `is_constructible_v<data_handle_type, const OtherAccessor::data_handle_type&>`
+  is `true`, and
+- `is_constructible_v<extents_type, OtherExtents>` is `true`.
+*Preconditions:*
+- For each rank index `r` of `extents_type`,
+  `static_extent(r) == dynamic_extent || static_extent(r) == other.extent(r)`
+  is `true`.
+- $[0, \texttt{\textit{map_}.required_span_size()})$ is an accessible
+  range of *ptr\_* and *acc\_* for values of *ptr\_*, *map\_*, and
+  *acc\_* after the invocation of this constructor.
+*Effects:*
+- Direct-non-list-initializes *ptr\_* with `other.`*`ptr_`*,
+- direct-non-list-initializes *map\_* with `other.`*`map_`*, and
+- direct-non-list-initializes *acc\_* with `other.`*`acc_`*.
+*Remarks:* The expression inside `explicit` is equivalent to:
+``` cpp
+!is_convertible_v<const OtherLayoutPolicy::template mapping<OtherExtents>&, mapping_type>
+|| !is_convertible_v<const OtherAccessor&, accessor_type>
+```
+##### Members <a id="mdspan.mdspan.members">[[mdspan.mdspan.members]]</a>
+``` cpp
+template<class... OtherIndexTypes>
+  constexpr reference operator[](OtherIndexTypes... indices) const;
+```
+*Constraints:*
+- `(is_convertible_v<OtherIndexTypes, index_type> && ...)` is `true`,
+- `(is_nothrow_constructible_v<index_type, OtherIndexTypes> && ...)` is
+  `true`, and
+- `sizeof...(OtherIndexTypes) == rank()` is `true`.
+Let `I` be `extents_type::`*`index-cast`*`(std::move(indices))`.
+*Preconditions:* `I` is a multidimensional index in `extents()`.
+[*Note 1*: This implies that
+*`map_`*`(I) < `*`map_`*`.required_span_size()` is
+`true`. — *end note*]
+*Effects:* Equivalent to:
+``` cpp
+return acc_.access(ptr_, map_(static_cast<index_type>(std::move(indices))...));
+```
+``` cpp
+template<class OtherIndexType>
+  constexpr reference operator[](span<OtherIndexType, rank()> indices) const;
+template<class OtherIndexType>
+  constexpr reference operator[](const array<OtherIndexType, rank()>& indices) const;
+```
+*Constraints:*
+- `is_convertible_v<const OtherIndexType&, index_type>` is `true`, and
+- `is_nothrow_constructible_v<index_type, const OtherIndexType&>` is
+  `true`.
+*Effects:* Let `P` be a parameter pack such that
+``` cpp
+is_same_v<make_index_sequence<rank()>, index_sequence<P...>>
+```
+is `true`. Equivalent to:
+``` cpp
+return operator[](as_const(indices[P])...);
+```
+``` cpp
+constexpr size_type size() const noexcept;
+```
+*Preconditions:* The size of the multidimensional index space
+`extents()` is representable as a value of type `size_type`
+[[basic.fundamental]].
+*Returns:* `extents().`*`fwd-prod-of-extents`*`(rank())`.
+``` cpp
+[[nodiscard]] constexpr bool empty() const noexcept;
+```
+*Returns:* `true` if the size of the multidimensional index space
+`extents()` is 0, otherwise `false`.
+``` cpp
+friend constexpr void swap(mdspan& x, mdspan& y) noexcept;
+```
+*Effects:* Equivalent to:
+``` cpp
+swap(x.ptr_, y.ptr_);
+swap(x.map_, y.map_);
+swap(x.acc_, y.acc_);
+```
+<!-- Link reference definitions -->
+[alg.equal]: algorithms.md#alg.equal
+[alg.sorting]: algorithms.md#alg.sorting
+[algorithm.stable]: library.md#algorithm.stable
+[algorithms]: algorithms.md#algorithms
+[algorithms.requirements]: algorithms.md#algorithms.requirements
+[allocator.requirements]: library.md#allocator.requirements
+[allocator.requirements.completeness]: library.md#allocator.requirements.completeness
+[allocator.traits.members]: mem.md#allocator.traits.members
+[allocator.uses.construction]: mem.md#allocator.uses.construction
+[array]: #array
+[array.cons]: #array.cons
+[array.creation]: #array.creation
+[array.members]: #array.members
+[array.overview]: #array.overview
+[array.special]: #array.special
+[array.syn]: #array.syn
+[array.tuple]: #array.tuple
+[array.zero]: #array.zero
+[associative]: #associative
+[associative.general]: #associative.general
+[associative.map.syn]: #associative.map.syn
+[associative.reqmts]: #associative.reqmts
+[associative.reqmts.except]: #associative.reqmts.except
+[associative.reqmts.general]: #associative.reqmts.general
+[associative.set.syn]: #associative.set.syn
+[basic.fundamental]: basic.md#basic.fundamental
+[basic.string]: strings.md#basic.string
+[class.copy.ctor]: class.md#class.copy.ctor
+[class.default.ctor]: class.md#class.default.ctor
+[class.dtor]: class.md#class.dtor
+[container.adaptors]: #container.adaptors
+[container.adaptors.format]: #container.adaptors.format
+[container.adaptors.general]: #container.adaptors.general
+[container.alloc.reqmts]: #container.alloc.reqmts
+[container.gen.reqmts]: #container.gen.reqmts
+[container.insert.return]: #container.insert.return
+[container.node]: #container.node
+[container.node.compat]: #container.node.compat
+[container.node.cons]: #container.node.cons
+[container.node.dtor]: #container.node.dtor
+[container.node.modifiers]: #container.node.modifiers
+[container.node.observers]: #container.node.observers
+[container.node.overview]: #container.node.overview
+[container.opt.reqmts]: #container.opt.reqmts
+[container.reqmts]: #container.reqmts
+[container.requirements]: #container.requirements
+[container.requirements.dataraces]: #container.requirements.dataraces
+[container.requirements.general]: #container.requirements.general
+[container.requirements.pre]: #container.requirements.pre
+[container.rev.reqmts]: #container.rev.reqmts
+[containers]: #containers
+[containers.general]: #containers.general
+[containers.summary]: #containers.summary
+[dcl.init.aggr]: dcl.md#dcl.init.aggr
+[defns.valid]: intro.md#defns.valid
+[deque]: #deque
+[deque.capacity]: #deque.capacity
+[deque.cons]: #deque.cons
+[deque.erasure]: #deque.erasure
+[deque.modifiers]: #deque.modifiers
+[deque.overview]: #deque.overview
+[deque.syn]: #deque.syn
+[expr.const]: expr.md#expr.const
+[flat.map]: #flat.map
+[flat.map.access]: #flat.map.access
+[flat.map.capacity]: #flat.map.capacity
+[flat.map.cons]: #flat.map.cons
+[flat.map.defn]: #flat.map.defn
+[flat.map.erasure]: #flat.map.erasure
+[flat.map.modifiers]: #flat.map.modifiers
+[flat.map.overview]: #flat.map.overview
+[flat.map.syn]: #flat.map.syn
+[flat.multimap]: #flat.multimap
+[flat.multimap.cons]: #flat.multimap.cons
+[flat.multimap.defn]: #flat.multimap.defn
+[flat.multimap.erasure]: #flat.multimap.erasure
+[flat.multimap.overview]: #flat.multimap.overview
+[flat.multiset]: #flat.multiset
+[flat.multiset.cons]: #flat.multiset.cons
+[flat.multiset.defn]: #flat.multiset.defn
+[flat.multiset.erasure]: #flat.multiset.erasure
+[flat.multiset.modifiers]: #flat.multiset.modifiers
+[flat.multiset.overview]: #flat.multiset.overview
+[flat.set]: #flat.set
+[flat.set.cons]: #flat.set.cons
+[flat.set.defn]: #flat.set.defn
+[flat.set.erasure]: #flat.set.erasure
+[flat.set.modifiers]: #flat.set.modifiers
+[flat.set.overview]: #flat.set.overview
+[flat.set.syn]: #flat.set.syn
+[forward.iterators]: iterators.md#forward.iterators
+[forward.list]: #forward.list
+[forward.list.access]: #forward.list.access
+[forward.list.cons]: #forward.list.cons
+[forward.list.erasure]: #forward.list.erasure
+[forward.list.iter]: #forward.list.iter
+[forward.list.modifiers]: #forward.list.modifiers
+[forward.list.ops]: #forward.list.ops
+[forward.list.overview]: #forward.list.overview
+[forward.list.syn]: #forward.list.syn
+[hash.requirements]: library.md#hash.requirements
+[iterator.concept.contiguous]: iterators.md#iterator.concept.contiguous
+[iterator.concept.random.access]: iterators.md#iterator.concept.random.access
+[iterator.requirements]: iterators.md#iterator.requirements
+[iterator.requirements.general]: iterators.md#iterator.requirements.general
+[list]: #list
+[list.capacity]: #list.capacity
+[list.cons]: #list.cons
+[list.erasure]: #list.erasure
+[list.modifiers]: #list.modifiers
+[list.ops]: #list.ops
+[list.overview]: #list.overview
+[list.syn]: #list.syn
+[map]: #map
+[map.access]: #map.access
+[map.cons]: #map.cons
+[map.erasure]: #map.erasure
+[map.modifiers]: #map.modifiers
+[map.overview]: #map.overview
+[mdspan.accessor]: #mdspan.accessor
+[mdspan.accessor.default]: #mdspan.accessor.default
+[mdspan.accessor.default.members]: #mdspan.accessor.default.members
+[mdspan.accessor.default.overview]: #mdspan.accessor.default.overview
+[mdspan.accessor.general]: #mdspan.accessor.general
+[mdspan.accessor.reqmts]: #mdspan.accessor.reqmts
+[mdspan.extents]: #mdspan.extents
+[mdspan.extents.cmp]: #mdspan.extents.cmp
+[mdspan.extents.cons]: #mdspan.extents.cons
+[mdspan.extents.dextents]: #mdspan.extents.dextents
+[mdspan.extents.expo]: #mdspan.extents.expo
+[mdspan.extents.obs]: #mdspan.extents.obs
+[mdspan.extents.overview]: #mdspan.extents.overview
+[mdspan.layout]: #mdspan.layout
+[mdspan.layout.general]: #mdspan.layout.general
+[mdspan.layout.left]: #mdspan.layout.left
+[mdspan.layout.left.cons]: #mdspan.layout.left.cons
+[mdspan.layout.left.obs]: #mdspan.layout.left.obs
+[mdspan.layout.left.overview]: #mdspan.layout.left.overview
+[mdspan.layout.policy.overview]: #mdspan.layout.policy.overview
+[mdspan.layout.policy.reqmts]: #mdspan.layout.policy.reqmts
+[mdspan.layout.reqmts]: #mdspan.layout.reqmts
+[mdspan.layout.right]: #mdspan.layout.right
+[mdspan.layout.right.cons]: #mdspan.layout.right.cons
+[mdspan.layout.right.obs]: #mdspan.layout.right.obs
+[mdspan.layout.right.overview]: #mdspan.layout.right.overview
+[mdspan.layout.stride]: #mdspan.layout.stride
+[mdspan.layout.stride.cons]: #mdspan.layout.stride.cons
+[mdspan.layout.stride.expo]: #mdspan.layout.stride.expo
+[mdspan.layout.stride.obs]: #mdspan.layout.stride.obs
+[mdspan.layout.stride.overview]: #mdspan.layout.stride.overview
+[mdspan.mdspan]: #mdspan.mdspan
+[mdspan.mdspan.cons]: #mdspan.mdspan.cons
+[mdspan.mdspan.members]: #mdspan.mdspan.members
+[mdspan.mdspan.overview]: #mdspan.mdspan.overview
+[mdspan.overview]: #mdspan.overview
+[mdspan.syn]: #mdspan.syn
+[multimap]: #multimap
+[multimap.cons]: #multimap.cons
+[multimap.erasure]: #multimap.erasure
+[multimap.modifiers]: #multimap.modifiers
+[multimap.overview]: #multimap.overview
+[multiset]: #multiset
+[multiset.cons]: #multiset.cons
+[multiset.erasure]: #multiset.erasure
+[multiset.overview]: #multiset.overview
+[priority.queue]: #priority.queue
+[priqueue.cons]: #priqueue.cons
+[priqueue.cons.alloc]: #priqueue.cons.alloc
+[priqueue.members]: #priqueue.members
+[priqueue.overview]: #priqueue.overview
+[priqueue.special]: #priqueue.special
+[queue]: #queue
+[queue.cons]: #queue.cons
+[queue.cons.alloc]: #queue.cons.alloc
+[queue.defn]: #queue.defn
+[queue.mod]: #queue.mod
+[queue.ops]: #queue.ops
+[queue.special]: #queue.special
+[queue.syn]: #queue.syn
+[random.access.iterators]: iterators.md#random.access.iterators
+[res.on.data.races]: library.md#res.on.data.races
+[sequence.reqmts]: #sequence.reqmts
+[sequences]: #sequences
+[sequences.general]: #sequences.general
+[set]: #set
+[set.cons]: #set.cons
+[set.erasure]: #set.erasure
+[set.overview]: #set.overview
+[span.cons]: #span.cons
+[span.deduct]: #span.deduct
+[span.elem]: #span.elem
+[span.iterators]: #span.iterators
+[span.objectrep]: #span.objectrep
+[span.obs]: #span.obs
+[span.overview]: #span.overview
+[span.sub]: #span.sub
+[span.syn]: #span.syn
+[stack]: #stack
+[stack.cons]: #stack.cons
+[stack.cons.alloc]: #stack.cons.alloc
+[stack.defn]: #stack.defn
+[stack.general]: #stack.general
+[stack.mod]: #stack.mod
+[stack.ops]: #stack.ops
+[stack.special]: #stack.special
+[stack.syn]: #stack.syn
+[strings]: strings.md#strings
+[swappable.requirements]: library.md#swappable.requirements
+[temp.deduct]: temp.md#temp.deduct
+[temp.param]: temp.md#temp.param
+[temp.type]: temp.md#temp.type
+[term.trivially.copyable.type]: basic.md#term.trivially.copyable.type
+[unord]: #unord
+[unord.general]: #unord.general
+[unord.hash]: utilities.md#unord.hash
+[unord.map]: #unord.map
+[unord.map.cnstr]: #unord.map.cnstr
+[unord.map.elem]: #unord.map.elem
+[unord.map.erasure]: #unord.map.erasure
+[unord.map.modifiers]: #unord.map.modifiers
+[unord.map.overview]: #unord.map.overview
+[unord.map.syn]: #unord.map.syn
+[unord.multimap]: #unord.multimap
+[unord.multimap.cnstr]: #unord.multimap.cnstr
+[unord.multimap.erasure]: #unord.multimap.erasure
+[unord.multimap.modifiers]: #unord.multimap.modifiers
+[unord.multimap.overview]: #unord.multimap.overview
+[unord.multiset]: #unord.multiset
+[unord.multiset.cnstr]: #unord.multiset.cnstr
+[unord.multiset.erasure]: #unord.multiset.erasure
+[unord.multiset.overview]: #unord.multiset.overview
+[unord.req]: #unord.req
+[unord.req.except]: #unord.req.except
+[unord.req.general]: #unord.req.general
+[unord.set]: #unord.set
+[unord.set.cnstr]: #unord.set.cnstr
+[unord.set.erasure]: #unord.set.erasure
+[unord.set.overview]: #unord.set.overview
+[unord.set.syn]: #unord.set.syn
+[vector]: #vector
+[vector.bool]: #vector.bool
+[vector.bool.fmt]: #vector.bool.fmt
+[vector.bool.pspc]: #vector.bool.pspc
+[vector.capacity]: #vector.capacity
+[vector.cons]: #vector.cons
+[vector.data]: #vector.data
+[vector.erasure]: #vector.erasure
+[vector.modifiers]: #vector.modifiers
+[vector.overview]: #vector.overview
+[vector.syn]: #vector.syn
+[views]: #views
+[views.contiguous]: #views.contiguous
+[views.general]: #views.general
+[views.multidim]: #views.multidim
+[views.span]: #views.span
+[^1]: Equality comparison is a refinement of partitioning if no two
+    objects that compare equal fall into different partitions.
+[^2]: These member functions are only provided by containers whose
+    iterators are random access iterators.
+[^3]: As specified in  [[allocator.requirements]], the requirements in
+    this Clause apply only to lists whose allocators compare equal.
+[^4]: `reserve()` uses `Allocator::allocate()` which can throw an
+    appropriate exception.

Diff to HTML by rtfpessoa