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

Files changed (1) hide show

tmp/tmplf9zx76c/{from.md → to.md} +1994 -57

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

@@ -22,42 +22,81 @@ the following are true:
   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 {
@@ -237,12 +276,12 @@ Let `N` be `sizeof...(OtherIndexTypes)`, and let `exts_arr` be
 - 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>
@@ -264,16 +303,16 @@ template<class OtherIndexType, size_t N>
 - 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`)])`.
@@ -283,11 +322,12 @@ 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;
@@ -326,16 +366,26 @@ template<class IndexType, size_t Rank>
 *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]].
@@ -344,19 +394,44 @@ In subclauses [[mdspan.layout.reqmts]] and
 - `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
@@ -480,20 +555,24 @@ m.stride(r)
 *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()
@@ -502,11 +581,11 @@ 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()
@@ -515,11 +594,11 @@ 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>
@@ -544,15 +623,27 @@ namespace std {
   };
   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>
@@ -563,13 +654,13 @@ stride 1, and strides increase left-to-right as the product of extents.
 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;
@@ -578,10 +669,14 @@ namespace std {
       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;
@@ -607,10 +702,21 @@ namespace std {
     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
@@ -648,11 +754,11 @@ 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:*
@@ -664,10 +770,44 @@ template<class OtherExents>
 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);
 ```
@@ -719,11 +859,11 @@ 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`.
@@ -750,13 +890,13 @@ stride 1, and strides increase right-to-left as the product of extents.
 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;
@@ -765,10 +905,14 @@ namespace std {
       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;
@@ -794,10 +938,21 @@ namespace std {
     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
@@ -851,10 +1006,46 @@ template<class OtherExtents>
 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;
 ```
@@ -874,11 +1065,11 @@ template<class OtherExtents>
 `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
@@ -937,13 +1128,13 @@ user-defined.
 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
@@ -984,10 +1175,21 @@ namespace std {
       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
@@ -1006,11 +1208,15 @@ 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
@@ -1078,11 +1284,12 @@ template<class OtherIndexType>
 - `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
@@ -1110,11 +1317,11 @@ template<class StridedLayoutMapping>
 - `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`.
@@ -1126,13 +1333,15 @@ direct-non-list-initializes *`strides_`*`[`d`]` with
 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
@@ -1197,10 +1406,898 @@ 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
@@ -1209,11 +2306,11 @@ 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
@@ -1353,10 +2450,155 @@ 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;
 ```
 *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.
@@ -1368,18 +2610,18 @@ namespace std {
   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); }
@@ -1417,12 +2659,22 @@ namespace std {
     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_; }
@@ -1462,11 +2714,11 @@ namespace std {
       -> 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>>;
@@ -1569,12 +2821,12 @@ template<class OtherIndexType, size_t N>
 ```
 *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
@@ -1653,18 +2905,17 @@ template<class OtherElementType, class OtherExtents,
 - `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
@@ -1691,11 +2942,11 @@ template<class... OtherIndexTypes>
   `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*]
@@ -1725,11 +2976,55 @@ 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;
 ```
@@ -1739,11 +3034,11 @@ constexpr size_type size() const noexcept;
 [[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`.
@@ -1757,10 +3052,599 @@ friend constexpr void swap(mdspan& x, mdspan& y) noexcept;
 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
@@ -1784,20 +3668,21 @@ swap(x.acc_, y.acc_);
 [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
@@ -1825,28 +3710,32 @@ swap(x.acc_, y.acc_);
 [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
@@ -1859,10 +3748,26 @@ swap(x.acc_, y.acc_);
 [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
@@ -1878,45 +3783,73 @@ swap(x.acc_, y.acc_);
 [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
@@ -1938,17 +3871,19 @@ swap(x.acc_, y.acc_);
 [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
@@ -1964,15 +3899,16 @@ swap(x.acc_, y.acc_);
 [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
@@ -1995,10 +3931,11 @@ swap(x.acc_, y.acc_);
 [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

   the interval [Lᵢ, Uᵢ) of S.
 #### Header `<mdspan>` synopsis <a id="mdspan.syn">[[mdspan.syn]]</a>
 ``` cpp
+// mostly freestanding
 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.extents.dims], alias template dims
+  template<size_t Rank, class IndexType = size_t>
+    using dims = see below;
   // [mdspan.layout], layout mapping
   struct layout_left;
   struct layout_right;
   struct layout_stride;
+  template<size_t PaddingValue = dynamic_extent>
+    struct layout_left_padded;
+  template<size_t PaddingValue = dynamic_extent>
+    struct layout_right_padded;
   // [mdspan.accessor.default], class template default_accessor
   template<class ElementType>
     class default_accessor;
+  // [mdspan.accessor.aligned], class template aligned_accessor
+  template<class ElementType, size_t ByteAlignment>
+    class aligned_accessor;
   // [mdspan.mdspan], class template mdspan
   template<class ElementType, class Extents, class LayoutPolicy = layout_right,
            class AccessorPolicy = default_accessor<ElementType>>
+    class mdspan;                                                           // partially freestanding
+  // [mdspan.sub], submdspan creation
+  template<class OffsetType, class LengthType, class StrideType>
+    struct strided_slice;
+  template<class LayoutMapping>
+    struct submdspan_mapping_result;
+  struct full_extent_t { explicit full_extent_t() = default; };
+  inline constexpr full_extent_t full_extent{};
+  template<class IndexType, size_t... Extents, class... SliceSpecifiers>
+    constexpr auto submdspan_extents(const extents<IndexType, Extents...>&, SliceSpecifiers...);
+  // [mdspan.sub.sub], submdspan function template
+  template<class ElementType, class Extents, class LayoutPolicy,
+           class AccessorPolicy, class... SliceSpecifiers>
+    constexpr auto submdspan(
+      const mdspan<ElementType, Extents, LayoutPolicy, AccessorPolicy>& src,
+      SliceSpecifiers... slices) -> see below;
+  template<class T, class IndexType>
+    concept index-pair-like =               // exposition only
+      pair-like<T> &&
+      convertible_to<tuple_element_t<0, T>, IndexType> &&
+      convertible_to<tuple_element_t<1, T>, IndexType>;
 }
 ```
 #### 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  [[views]], `extents` is used
+synonymously with multidimensional index space.
 ``` cpp
 namespace std {
   template<class IndexType, size_t... Extents>
   class extents {
 - 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 representable as a nonnegative value of
+    type `index_type`.
 *Ensures:* `*this == extents(exts_arr)` is `true`.
 ``` cpp
 template<class OtherIndexType, size_t N>
 - 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 representable as a nonnegative value of type
     `index_type` for every rank index r.
 *Effects:*
+- If `N` equals `rank_dynamic()`, 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`)])`.
   explicit extents(Integrals...) -> see below;
 ```
 *Constraints:* `(is_convertible_v<Integrals, size_t> && ...)` is `true`.
+*Remarks:* The deduced type is
+`extents<size_t, maybe-static-ext<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;
 *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`.
+##### Alias template `dims` <a id="mdspan.extents.dims">[[mdspan.extents.dims]]</a>
+``` cpp
+template<size_t Rank, class IndexType = size_t>
+  using dims = 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 [[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]].
 - `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 [[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>;
   ```
+- Let *`is-layout-left-padded-mapping-of`* be the exposition-only
+  variable template defined as follows:
+  ``` cpp
+  template<class Mapping>
+  constexpr bool is-layout-left-padded-mapping-of = see below;   // exposition only
+  ```
+  where `is-layout-left-padded-mapping-of<Mapping>` is `true` if and
+  only if `Mapping` denotes a specialization of
+  `layout_left_padded<S>::mapping` for some value `S` of type `size_t`.
+- Let *`is-layout-right-padded-mapping-of`* be the exposition-only
+  variable template defined as follows:
+  ``` cpp
+  template<class Mapping>
+  constexpr bool is-layout-right-padded-mapping-of = see below;   // exposition only
+  ```
+  where `is-layout-right-padded-mapping-of<Mapping>` is `true` if and
+  only if `Mapping` denotes a specialization of
+  `layout_right_padded<S>::mapping` for some value `S` of type `size_t`.
+- For nonnegative integers x and y, let LEAST-MULTIPLE-AT-LEAST(x, y)
+  denote
+  - y if x is zero,
+  - otherwise, the least multiple of x that is greater than or equal to
+    y.
 ##### Requirements <a id="mdspan.layout.reqmts">[[mdspan.layout.reqmts]]</a>
 A type `M` meets the *layout mapping* requirements if
 *Result:* `typename M::index_type`
 *Returns:* sᵣ as defined in `m.is_strided()` above.
+[*Note 5*: It is not required for `m.stride(r)` to be well-formed if
+`m.extents().rank()` is zero, even if `m.is_always_strided()` is
+`true`. — *end note*]
 ``` 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 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 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 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 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 8*: 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>
   };
   struct layout_stride {
     template<class Extents>
       class mapping;
   };
+  template<size_t PaddingValue>
+  struct layout_left_padded {
+    template<class Extents> class mapping;
+  };
+  template<size_t PaddingValue>
+  struct layout_right_padded {
+    template<class Extents> class mapping;
+  };
 }
 ```
+Each of `layout_left`, `layout_right`, and `layout_stride`, as well as
+each specialization of `layout_left_padded` and `layout_right_padded`,
+meets the layout mapping policy requirements and is a trivially copyable
+type. Furthermore, `is_trivially_default_constructible_v<T>` is `true`
+for any such type `T`.
 ##### 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>
 namespace std {
   template<class Extents>
   class layout_left::mapping {
   public:
     using extents_type = Extents;
+    using index_type = extents_type::index_type;
+    using size_type = extents_type::size_type;
+    using rank_type = 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 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 LayoutLeftPaddedMapping>
+      constexpr explicit(!is_convertible_v<typename LayoutLeftPaddedMapping::extents_type,
+                                           extents_type>)
+        mapping(const LayoutLeftPaddedMapping&) noexcept;
     template<class OtherExtents>
       constexpr explicit(extents_type::rank() > 0)
         mapping(const layout_stride::mapping<OtherExtents>&);
     constexpr mapping& operator=(const mapping&) noexcept = default;
     template<class OtherExtents>
       friend constexpr bool operator==(const mapping&, const mapping<OtherExtents>&) noexcept;
   private:
     extents_type extents_{};                                               // exposition only
+    // [mdspan.sub.map], submdspan mapping specialization
+    template<class... SliceSpecifiers>
+      constexpr auto submdspan-mapping-impl(SliceSpecifiers...) const     // exposition only
+        -> see below;
+    template<class... SliceSpecifiers>
+      friend constexpr auto submdspan_mapping(
+        const mapping& src, SliceSpecifiers... slices) {
+          return src.submdspan-mapping-impl(slices...);
+      }
   };
 }
 ```
 If `Extents` is not a specialization of `extents`, then the program is
 *Effects:* Direct-non-list-initializes *extents\_* with
 `other.extents()`.
 ``` cpp
+template<class OtherExtents>
   constexpr explicit(!is_convertible_v<OtherExtents, extents_type>)
     mapping(const layout_right::mapping<OtherExtents>& other) noexcept;
 ```
 *Constraints:*
 value of type `index_type` [[basic.fundamental]].
 *Effects:* Direct-non-list-initializes *extents\_* with
 `other.extents()`.
+``` cpp
+template<class LayoutLeftPaddedMapping>
+  constexpr explicit(!is_convertible_v<typename LayoutLeftPaddedMapping::extents_type,
+                                       extents_type>)
+    mapping(const LayoutLeftPaddedMapping&) noexcept;
+```
+*Constraints:*
+- *`is-layout-left-padded-mapping-of`*`<LayoutLeftPaddedMapping>` is
+  `true`.
+- `is_constructible_v<extents_type, typename LayoutLeftPaddedMapping::extents_type>`
+  is `true`.
+*Mandates:* If
+- `Extents::rank()` is greater than one,
+- `Extents::static_extent(0)` does not equal `dynamic_extent`, and
+- `LayoutLeftPaddedMapping::`*`static-padding-stride`* does not equal
+  `dynamic_extent`,
+then `Extents::static_extent(0)` equals
+`LayoutLeftPaddedMapping::`*`static-padding-stride`*.
+*Preconditions:*
+- If `extents_type::rank() > 1` is `true`, then `other.stride(1)` equals
+  `other.extents().extent(0)`.
+- `other.required_span_size()` is representable as a value of type
+  `index_type`.
+*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);
 ```
 ``` 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`.
 namespace std {
   template<class Extents>
   class layout_right::mapping {
   public:
     using extents_type = Extents;
+    using index_type = extents_type::index_type;
+    using size_type = extents_type::size_type;
+    using rank_type = 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 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 LayoutRightPaddedMapping>
+      constexpr explicit(!is_convertible_v<typename LayoutRightPaddedMapping::extents_type,
+                                           extents_type>)
+        mapping(const LayoutRightPaddedMapping&) noexcept;
     template<class OtherExtents>
       constexpr explicit(extents_type::rank() > 0)
         mapping(const layout_stride::mapping<OtherExtents>&) noexcept;
     constexpr mapping& operator=(const mapping&) noexcept = default;
     template<class OtherExtents>
       friend constexpr bool operator==(const mapping&, const mapping<OtherExtents>&) noexcept;
   private:
     extents_type extents_{};    // exposition only
+    // [mdspan.sub.map], submdspan mapping specialization
+    template<class... SliceSpecifiers>
+      constexpr auto submdspan-mapping-impl(SliceSpecifiers...) const       // exposition only
+        -> see below;
+    template<class... SliceSpecifiers>
+      friend constexpr auto submdspan_mapping(
+        const mapping& src, SliceSpecifiers... slices) {
+          return src.submdspan-mapping-impl(slices...);
+      }
   };
 }
 ```
 If `Extents` is not a specialization of `extents`, then the program is
 value of type `index_type` [[basic.fundamental]].
 *Effects:* Direct-non-list-initializes *extents\_* with
 `other.extents()`.
+``` cpp
+template<class LayoutRightPaddedMapping>
+  constexpr explicit(!is_convertible_v<typename LayoutRightPaddedMapping::extents_type,
+                                       extents_type>)
+    mapping(const LayoutRightPaddedMapping&) noexcept;
+```
+*Constraints:*
+- *`is-layout-right-padded-mapping-of`*`<LayoutRightPaddedMapping>` is
+  `true`.
+- `is_constructible_v<extents_type, typename LayoutRightPaddedMapping::extents_- type>`
+  is `true`.
+*Mandates:* If
+- `Extents::rank()` is greater than one,
+- `Extents::static_extent(Extents::rank() - 1)` does not equal
+  `dynamic_extent`, and
+- `LayoutRightPaddedMapping::`*`static-padding-stride`* does not equal
+  `dynamic_extent`,
+then `Extents::static_extent(Extents::rank() - 1)` equals
+`LayoutRightPaddedMapping::`*`static-padding-stride`*.
+*Preconditions:*
+- If `extents_type::rank() > 1` is `true`, then
+  `other.stride(extents_type::rank() - 2)` equals
+  `other.extents().extent(extents_type::rank() - 1)`.
+- `other.required_span_size()` is representable as a value of type
+  `index_type`.
+*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;
 ```
 `other.extents()`.
 ###### Observers <a id="mdspan.layout.right.obs">[[mdspan.layout.right.obs]]</a>
 ``` cpp
+constexpr index_type required_span_size() const noexcept;
 ```
 *Returns:* `extents().`*`fwd-prod-of-extents`*`(extents_type::rank())`.
 ``` cpp
 namespace std {
   template<class Extents>
   class layout_stride::mapping {
   public:
     using extents_type = Extents;
+    using index_type = extents_type::index_type;
+    using size_type = extents_type::size_type;
+    using rank_type = extents_type::rank_type;
     using layout_type = layout_stride;
   private:
     static constexpr rank_type rank_ = extents_type::rank();    // exposition only
       friend constexpr bool operator==(const mapping&, const OtherMapping&) noexcept;
   private:
     extents_type extents_{};                    // exposition only
     array<index_type, rank_> strides_{};        // exposition only
+    // [mdspan.sub.map], submdspan mapping specialization
+    template<class... SliceSpecifiers>
+      constexpr auto submdspan-mapping-impl(SliceSpecifiers...) const       // exposition only
+        -> see below;
+    template<class... SliceSpecifiers>
+      friend constexpr auto submdspan_mapping(
+        const mapping& src, SliceSpecifiers... slices) {
+          return src.submdspan-mapping-impl(slices...);
+      }
   };
 }
 ```
 If `Extents` is not a specialization of `extents`, then the program is
 - `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
+  ``` cpp
+  extents_type::index-cast(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
 - `is_nothrow_constructible_v<index_type, const OtherIndexType&>` is
   `true`.
 *Preconditions:*
+- The result of converting `s[`i`]` to `index_type` is greater than `0`
+  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
 - `StridedLayoutMapping::is_always_strided()` is `true`.
 *Preconditions:*
 - `StridedLayoutMapping` meets the layout mapping
+  requirements [[mdspan.layout.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`.
 Remarks: The expression inside `explicit` is equivalent to:
 ``` cpp
 !(is_convertible_v<typename StridedLayoutMapping::extents_type, extents_type> &&
+  (is-mapping-of<layout_left, StridedLayoutMapping> ||
+   is-mapping-of<layout_right, StridedLayoutMapping> ||
+   is-layout-left-padded-mapping-of<StridedLayoutMapping> ||
+   is-layout-right-padded-mapping-of<StridedLayoutMapping> ||
+   is-mapping-of<layout_stride, StridedLayoutMapping>))
 ```
 ###### Observers <a id="mdspan.layout.stride.obs">[[mdspan.layout.stride.obs]]</a>
 ``` cpp
 *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`.
+##### Class template `layout_left_padded::mapping` <a id="mdspan.layout.leftpad">[[mdspan.layout.leftpad]]</a>
+###### Overview <a id="mdspan.layout.leftpad.overview">[[mdspan.layout.leftpad.overview]]</a>
+`layout_left_padded` provides a layout mapping that behaves like
+`layout_left::mapping`, except that the padding stride `stride(1)` can
+be greater than or equal to `extent(0)`.
+``` cpp
+namespace std {
+  template<size_t PaddingValue>
+  template<class Extents>
+  class layout_left_padded<PaddingValue>::mapping {
+  public:
+    static constexpr size_t padding_value = PaddingValue;
+    using extents_type = Extents;
+    using index_type = extents_type::index_type;
+    using size_type = extents_type::size_type;
+    using rank_type = extents_type::rank_type;
+    using layout_type = layout_left_padded<PaddingValue>;
+  private:
+    static constexpr size_t rank_ = extents_type::rank();         // exposition only
+    static constexpr size_t first-static-extent =                 // exposition only
+      extents_type::static_extent(0);
+    // [mdspan.layout.leftpad.expo], exposition-only members
+    static constexpr size_t static-padding-stride = see below;  // exposition only
+  public:
+    // [mdspan.layout.leftpad.cons], constructors
+    constexpr mapping() noexcept : mapping(extents_type{}) {}
+    constexpr mapping(const mapping&) noexcept = default;
+    constexpr mapping(const extents_type&);
+    template<class OtherIndexType>
+      constexpr mapping(const extents_type&, OtherIndexType);
+    template<class OtherExtents>
+      constexpr explicit(!is_convertible_v<OtherExtents, extents_type>)
+        mapping(const layout_left::mapping<OtherExtents>&);
+    template<class OtherExtents>
+      constexpr explicit(extents_type::rank() > 0)
+        mapping(const layout_stride::mapping<OtherExtents>&);
+    template<class LayoutLeftPaddedMapping>
+      constexpr explicit(see below)
+        mapping(const LayoutLeftPaddedMapping&);
+    template<class LayoutRightPaddedMapping>
+      constexpr explicit(see below)
+        mapping(const LayoutRightPaddedMapping&) noexcept;
+    constexpr mapping& operator=(const mapping&) noexcept = default;
+    // [mdspan.layout.leftpad.obs], observers
+    constexpr const extents_type& extents() const noexcept { return extents_; }
+    constexpr array<index_type, rank_> strides() const noexcept;
+    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;
+    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) const noexcept;
+    template<class LayoutLeftPaddedMapping>
+      friend constexpr bool operator==(const mapping&, const LayoutLeftPaddedMapping&) noexcept;
+  private:
+    // [mdspan.layout.leftpad.expo], exposition-only members
+    index_type stride-1 = static-padding-stride;                           // exposition only
+    extents_type extents_{};                                               // exposition only
+    // [mdspan.sub.map], submdspan mapping specialization
+    template<class... SliceSpecifiers>
+      constexpr auto submdspan-mapping-impl(SliceSpecifiers...) const     // exposition only
+        -> see below;
+    template<class... SliceSpecifiers>
+      friend constexpr auto submdspan_mapping(const mapping& src, SliceSpecifiers... slices) {
+      return src.submdspan-mapping-impl(slices...);
+    }
+  };
+}
+```
+If `Extents` is not a specialization of `extents`, then the program is
+ill-formed.
+`layout_left_padded::mapping<E>` is a trivially copyable type that
+models `regular` for each `E`.
+Throughout [[mdspan.layout.leftpad]], let `P_rank` be the following size
+*`rank_`* parameter pack of `size_`t values:
+- the empty parameter pack, if *`rank_`* equals zero;
+- otherwise, `0zu`, if *`rank_`* equals one;
+- otherwise, the parameter pack `0zu`, `1zu`, …, `rank_- 1`.
+*Mandates:*
+- If `rank_dynamic() == 0` is `true`, then the size of the
+  multidimensional index space `Extents()` is representable as a value
+  of type `index_type`.
+- `padding_value` is representable as a value of type `index_type`.
+- If
+  - *`rank_`* is greater than one,
+  - `padding_value` does not equal `dynamic_extent`, and
+  - *`first-static-extent`* does not equal `dynamic_extent`,
+  then `LEAST-MULTIPLE-AT-LEAST(padding_value, first-static-extent)` is
+  representable as a value of type `size_t`, and is representable as a
+  value of type `index_type`.
+- If
+  - *`rank_`* is greater than one,
+  - `padding_value` does not equal `dynamic_extent`, and
+  - `extents_type::static_extent(k)` does not equal `dynamic_extent` for
+    all k in the range \[`0`, `extents_type::rank()`),
+  then the product of
+  `LEAST-MULTIPLE-AT-LEAST(padding_value, ext.static_extent(0))` and all
+  values `ext.static_extent(k)` with k in the range of \[`1`, *`rank_`*)
+  is representable as a value of type `size_t`, and is representable as
+  a value of type `index_type`.
+###### Exposition-only members <a id="mdspan.layout.leftpad.expo">[[mdspan.layout.leftpad.expo]]</a>
+``` cpp
+static constexpr size_t static-padding-stride = see below;
+```
+The value is
+- `0`, if *rank\_* equals zero or one;
+- otherwise, `dynamic_extent`, if `padding_value` or
+  *first-static-extent* equals `dynamic_extent`;
+- otherwise, the `size_t` value which is
+  *`LEAST-MULTIPLE-AT-LEAST`*`(padding_value, `*`first-static-extent`*`)`.
+``` cpp
+index_type stride-1 = static-padding-stride;
+```
+*Recommended practice:* Implementations should not store this value if
+*static-padding-stride* is not `dynamic_extent`.
+[*Note 9*: Using `extents<index_type, `*`static-padding-stride`*`>`
+instead of `index_type` as the type of *stride-1* would achieve
+this. — *end note*]
+###### Constructors <a id="mdspan.layout.leftpad.cons">[[mdspan.layout.leftpad.cons]]</a>
+``` cpp
+constexpr mapping(const extents_type& ext);
+```
+*Preconditions:*
+- The size of the multidimensional index space `ext` is representable as
+  a value of type `index_type`.
+- If *rank\_* is greater than one and `padding_value` does not equal
+  `dynamic_extent`, then
+  *`LEAST-MULTIPLE-AT-LEAST`*`(padding_value, ext.extent(0))` is
+  representable as a value of type *index_type*.
+- If *rank\_* is greater than one and `padding_value` does not equal
+  `dynamic_extent`, then the product of
+  *`LEAST-MULTIPLE-AT-LEAST`*`(padding_value, ext.extent(0))` and all
+  values `ext.extent(`k`)` with k in the range of \[`1`, *`rank_`*) is
+  representable as a value of type `index_type`.
+*Effects:*
+- Direct-non-list-initializes *extents\_* with `ext`; and
+- if *rank\_* is greater than one, direct-non-list-initializes
+  *stride-1*
+  - with `ext.extent(0)` if padding_value is `dynamic_extent`,
+  - otherwise with
+    *`LEAST-MULTIPLE-AT-LEAST`*`(padding_value, ext.extent(0))`.
+``` cpp
+template<class OtherIndexType>
+constexpr mapping(const extents_type& ext, OtherIndexType pad);
+```
+*Constraints:*
+- `is_convertible_v<OtherIndexType, index_type>` is `true`.
+- `is_nothrow_constructible_v<index_type, OtherIndexType>` is `true`.
+*Preconditions:*
+- `pad` is representable as a value of type `index_type`.
+- `extents_type::`*`index-cast`*`(pad)` is greater than zero.
+- If *rank\_* is greater than one, then
+  *`LEAST-MULTIPLE-AT-LEAST`*`(pad, ext.extent(0))` is representable as
+  a value of type `index_type.`
+- If *rank\_* is greater than one, then the product of
+  *`LEAST-MULTIPLE-AT-LEAST`*`(pad, ext.extent(0))` and all values
+  `ext.extent(`k`)` with k in the range of \[`1`, *`rank_`*) is
+  representable as a value of type `index_type`.
+- If `padding_value` is not equal to `dynamic_extent`, `padding_value`
+  equals `extents_type::`*`index-cast`*`(pad)`.
+*Effects:* Direct-non-list-initializes *extents\_* with `ext`, and if
+*rank\_* is greater than one, direct-non-list-initializes *stride-1*
+with *`LEAST-MULTIPLE-AT-LEAST`*`(pad, ext.extent(0))`.
+``` cpp
+template<class OtherExtents>
+  constexpr explicit(!is_convertible_v<OtherExtents, extents_type>)
+    mapping(const layout_left::mapping<OtherExtents>& other);
+```
+*Constraints:* `is_constructible_v<extents_type, OtherExtents>` is
+`true`.
+*Mandates:* If `OtherExtents::rank()` is greater than `1`, then
+``` cpp
+(static-padding-stride == dynamic_extent) ||
+(OtherExtents::static_extent(0) == dynamic_extent) ||
+(static-padding-stride == OtherExtents::static_extent(0))
+```
+is `true`.
+*Preconditions:*
+- If `extents_type::rank() > 1` is `true` and `padding_value` ==
+  `dynamic_extent` is `false`, then `other.stride(1)` equals
+  ``` cpp
+  LEAST-MULTIPLE-AT-LEAST(padding_value,
+                          extents_type::index-cast(other.extents().extent(0)))
+  ```
+  and
+- `other.required_span_size()` is representable as a value of type
+  `index_type`.
+*Effects:* Equivalent to `mapping(other.extents())`.
+``` cpp
+template<class OtherExtents>
+  constexpr explicit(rank_ > 0)
+    mapping(const layout_stride::mapping<OtherExtents>& other);
+```
+*Constraints:* `is_constructible_v<extents_type, OtherExtents>` is
+`true`.
+*Preconditions:*
+- If *rank\_* is greater than `1` and `padding_value` does not equal
+  `dynamic_extent`, then `other.stride(1)` equals
+  ``` cpp
+  LEAST-MULTIPLE-AT-LEAST(padding_value,
+                          extents_type::index-cast(other.extents().extent(0)))
+  ```
+- If *rank\_* is greater than 0, then `other.stride(0)` equals 1.
+- If *rank\_* is greater than 2, then for all r in the range \[`2`,
+  *`rank_`*), `other.stride(r)` equals
+  ``` cpp
+  (other.extents().fwd-prod-of-extents(r) / other.extents().extent(0)) * other.stride(1)
+  ```
+- `other.required_span_size()` is representable as a value of type
+  *index_type*.
+*Effects:*
+- Direct-non-list-initializes *extents\_* with `other.extents()` and
+- if *rank\_* is greater than one, direct-non-list-initializes
+  *stride-1* with `other.stride(1)`.
+``` cpp
+template<class LayoutLeftPaddedMapping>
+  constexpr explicit(see below)
+    mapping(const LayoutLeftPaddedMapping& other);
+```
+*Constraints:*
+- *`is-layout-left-padded-mapping-of`*`<LayoutLeftPaddedMapping>` is
+  `true`.
+- `is_constructible_v<extents_type, typename LayoutLeftPaddedMapping::extents_type>`
+  is `true`.
+*Mandates:* If *rank\_* is greater than 1, then
+``` cpp
+padding_value == dynamic_extent ||
+LayoutLeftPaddedMapping::padding_value == dynamic_extent ||
+padding_value == LayoutLeftPaddedMapping::padding_value
+```
+is `true`.
+*Preconditions:*
+- If *rank\_* is greater than 1 and `padding_value` does not equal
+  `dynamic_extent`, then `other.stride(1)` equals
+  ``` cpp
+  LEAST-MULTIPLE-AT-LEAST(padding_value,
+                          extents_type::index-cast(other.extent(0)))
+  ```
+- `other.required_span_size()` is representable as a value of type
+  `index_type`.
+*Effects:*
+- Direct-non-list-initializes *extents\_* with `other.extents()` and
+- if *rank\_* is greater than one, direct-non-list-initializes
+  *stride-1* with `other.stride(1)`.
+*Remarks:* The expression inside `explicit` is equivalent to:
+``` cpp
+rank_> 1 &&
+(padding_value != dynamic_extent ||
+ LayoutLeftPaddedMapping::padding_value == dynamic_extent)
+```
+``` cpp
+template<class LayoutRightPaddedMapping>
+  constexpr explicit(see below)
+    mapping(const LayoutRightPaddedMapping& other) noexcept;
+```
+*Constraints:*
+- *`is-layout-right-padded-mapping-of`*`<LayoutRightPaddedMapping>` is
+  `true` or *`is-mapping-of`*`<layout_right, LayoutRightPaddedMapping>`
+  is `true`.
+- *rank\_* equals zero or one.
+- `is_constructible_v<extents_type, typename LayoutRightPaddedMapping::extents_- type>`
+  is `true`.
+*Preconditions:* `other.required_span_size()` is representable as a
+value of type `index_type`.
+*Effects:* Direct-non-list-initializes *extents\_* with
+`other.extents()`.
+*Remarks:* The expression inside `explicit` is equivalent to:
+``` cpp
+!is_convertible_v<typename LayoutRightPaddedMapping::extents_type, extents_type>
+```
+[*Note 10*: Neither the input mapping nor the mapping to be constructed
+uses the padding stride in the rank-0 or rank-1 case, so the padding
+stride does not affect either the constraints or the
+preconditions. — *end note*]
+###### Observers <a id="mdspan.layout.leftpad.obs">[[mdspan.layout.leftpad.obs]]</a>
+``` cpp
+constexpr array<index_type, rank_> strides() const noexcept;
+```
+*Returns:* `array<index_type, `*`rank_`*`>({stride(P_rank)...})`.
+``` cpp
+constexpr index_type required_span_size() const noexcept;
+```
+*Returns:*
+- `0` if the multidimensional index space *extents\_* is empty,
+- otherwise,
+  `(*this)(`*`extents_`*`.extent(P_rank) - index_type(1)...) + 1`.
+``` cpp
+template<class... Indices>
+constexpr size_t operator()(Indices... idxs) const noexcept;
+```
+*Constraints:*
+- `sizeof...(Indices) == `*`rank_`* is `true`.
+- `(is_convertible_v<Indices, index_type> && ...)` is `true`.
+- `(is_nothrow_constructible_v<index_type, Indices> && ...)` is `true`.
+*Preconditions:* `extents_type::`*`index-cast`*`(idxs)` is a
+multidimensional index in `extents()` [[mdspan.overview]].
+*Returns:*
+`((static_cast<index_type>(idxs) * stride(P_rank)) + ... + 0)`.
+``` cpp
+static constexpr bool is_always_exhaustive() noexcept;
+```
+*Returns:*
+- If *rank\_* equals zero or one, then `true`;
+- otherwise, if neither *static-padding-stride* nor
+  *first-static-extent* equal `dynamic_extent`, then
+  *`static-padding-stride`*` == `*`first-static-extent`*;
+- otherwise, `false`.
+``` cpp
+constexpr bool is_exhaustive() const noexcept;
+```
+*Returns:* `true` if *rank\_* equals zero or one; otherwise,
+`extents_.extent(0) == stride(1)`.
+``` cpp
+constexpr index_type stride(rank_type r) const noexcept;
+```
+*Preconditions:* `r` is smaller than *rank\_*.
+*Returns:*
+- If `r` equals zero: 1;
+- otherwise, if `r` equals one: *stride-1*;
+- otherwise, the product of *stride-1* and all values
+  `extents_.extent(`k`)` with k in the range \[`1`, `r`).
+``` cpp
+template<class LayoutLeftPaddedMapping>
+  friend constexpr bool operator==(const mapping& x, const LayoutLeftPaddedMapping& y) noexcept;
+```
+*Constraints:*
+- *`is-layout-left-padded-mapping-of`*`<LayoutLeftPaddedMapping>` is
+  `true`.
+- `LayoutLeftPaddedMapping::extents_type::rank() == rank_` is `true`.
+*Returns:* `true` if `x.extents() == y.extents()` is `true` and
+*`rank_`*` < 2 || x.stride(1) == y. stride(1)` is `true`. Otherwise,
+`false`.
+##### Class template `layout_right_padded::mapping` <a id="mdspan.layout.rightpad">[[mdspan.layout.rightpad]]</a>
+###### Overview <a id="mdspan.layout.rightpad.overview">[[mdspan.layout.rightpad.overview]]</a>
+`layout_right_padded` provides a layout mapping that behaves like
+`layout_right::mapping`, except that the padding stride
+`stride(extents_type::rank() - 2)` can be greater than or equal to
+`extents_type::extent(extents_type::rank() - 1)`.
+``` cpp
+namespace std {
+  template<size_t PaddingValue>
+  template<class Extents>
+  class layout_right_padded<PaddingValue>::mapping {
+  public:
+    static constexpr size_t padding_value = PaddingValue;
+    using extents_type = Extents;
+    using index_type = extents_type::index_type;
+    using size_type = extents_type::size_type;
+    using rank_type = extents_type::rank_type;
+    using layout_type = layout_right_padded<PaddingValue>;
+  private:
+    static constexpr size_t rank_ = extents_type::rank();    // exposition only
+    static constexpr size_t last-static-extent =             // exposition only
+      extents_type::static_extent(rank_ - 1);
+    // [mdspan.layout.rightpad.expo], exposition-only members
+    static constexpr size_t static-padding-stride = see below; // exposition only
+  public:
+    // [mdspan.layout.rightpad.cons], constructors
+    constexpr mapping() noexcept : mapping(extents_type{}) {}
+    constexpr mapping(const mapping&) noexcept = default;
+    constexpr mapping(const extents_type&);
+    template<class OtherIndexType>
+      constexpr mapping(const extents_type&, OtherIndexType);
+    template<class OtherExtents>
+      constexpr explicit(!is_convertible_v<OtherExtents, extents_type>)
+        mapping(const layout_right::mapping<OtherExtents>&);
+    template<class OtherExtents>
+      constexpr explicit(rank_ > 0)
+        mapping(const layout_stride::mapping<OtherExtents>&);
+    template<class LayoutRightPaddedMapping>
+      constexpr explicit(see below)
+        mapping(const LayoutRightPaddedMapping&);
+    template<class LayoutLeftPaddedMapping>
+      constexpr explicit(see below)
+        mapping(const LayoutLeftPaddedMapping&) noexcept;
+    constexpr mapping& operator=(const mapping&) noexcept = default;
+    // [mdspan.layout.rightpad.obs], observers
+    constexpr const extents_type& extents() const noexcept { return extents_; }
+    constexpr array<index_type, rank_> strides() const noexcept;
+    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;
+    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) const noexcept;
+    template<class LayoutRightPaddedMapping>
+      friend constexpr bool operator==(const mapping&, const LayoutRightPaddedMapping&) noexcept;
+  private:
+    // [mdspan.layout.rightpad.expo], exposition-only members
+    index_type stride-rm2 = static-padding-stride;                         // exposition only
+    extents_type extents_{};                                               // exposition only
+    // [mdspan.sub.map], submdspan mapping specialization
+    template<class... SliceSpecifiers>
+      constexpr auto submdspan-mapping-impl(SliceSpecifiers...) const     // exposition only
+        -> see below;
+    template<class... SliceSpecifiers>
+      friend constexpr auto submdspan_mapping(const mapping& src, SliceSpecifiers... slices) {
+      return src.submdspan-mapping-impl(slices...);
+    }
+  };
+}
+```
+If `Extents` is not a specialization of `extents`, then the program is
+ill-formed.
+`layout_right_padded::mapping<E>` is a trivially copyable type that
+models `regular` for each `E`.
+Throughout [[mdspan.layout.rightpad]], let `P_rank` be the following
+size *`rank_`* parameter pack of `size_`t values:
+- the empty parameter pack, if *`rank_`* equals zero;
+- otherwise, `0zu`, if *`rank_`* equals one;
+- otherwise, the parameter pack `0zu`, `1zu`, …, `rank_- 1`.
+*Mandates:*
+- If `rank_dynamic() == 0` is `true`, then the size of the
+  multidimensional index space `Extents()` is representable as a value
+  of type `index_type`.
+- `padding_value` is representable as a value of type `index_type`.
+- If
+  - *`rank_`* is greater than one,
+  - `padding_value` does not equal `dynamic_extent`, and
+  - *`last-static-extent`* does not equal `dynamic_extent`,
+  then `LEAST-MULTIPLE-AT-LEAST(padding_value, last-static-extent)` is
+  representable as a value of type `size_t`, and is representable as a
+  value of type `index_type`.
+- If
+  - *`rank_`* is greater than one,
+  - `padding_value` does not equal `dynamic_extent`, and
+  - `extents_type::static_extent(k)` does not equal `dynamic_extent` for
+    all k in the range \[`0`, *`rank_`*),
+  then the product of
+  `LEAST-MULTIPLE-AT-LEAST(padding_value, ext.static_extent(rank_ - 1))`
+  and all values `ext.static_extent(k)` with k in the range of \[`0`,
+  *`rank_`*` - 1`) is representable as a value of type `size_t`, and is
+  representable as a value of type `index_type`.
+###### Exposition-only members <a id="mdspan.layout.rightpad.expo">[[mdspan.layout.rightpad.expo]]</a>
+``` cpp
+static constexpr size_t static-padding-stride = see below;
+```
+The value is
+- `0`, if *rank\_* equals zero or one;
+- otherwise, `dynamic_extent`, if `padding_value` or
+  *last-static-extent* equals `dynamic_extent`;
+- otherwise, the `size_t` value which is
+  *`LEAST-MULTIPLE-AT-LEAST`*`(padding_value, `*`last-static-extent`*`)`.
+``` cpp
+index_type stride-rm2 = static-padding-stride;
+```
+*Recommended practice:* Implementations should not store this value if
+*static-padding-stride* is not `dynamic_extent`.
+[*Note 11*: Using `extents<index_type, `*`static-padding-stride`*`>`
+instead of `index_type` as the type of *stride-rm2* would achieve
+this. — *end note*]
+###### Constructors <a id="mdspan.layout.rightpad.cons">[[mdspan.layout.rightpad.cons]]</a>
+``` cpp
+constexpr mapping(const extents_type& ext);
+```
+*Preconditions:*
+- The size of the multidimensional index space `ext` is representable as
+  a value of type `index_type`.
+- If *rank\_* is greater than one and `padding_value` does not equal
+  `dynamic_extent`, then
+  *`LEAST-MULTIPLE-AT-LEAST`*`(padding_value, ext.extent(`*`rank_`*` - 1))`
+  is representable as a value of type *index_type*.
+- If *rank\_* is greater than one and `padding_value` does not equal
+  `dynamic_extent`, then the product of
+  *`LEAST-MULTIPLE-AT-LEAST`*`(padding_value, ext.extent(`*`rank_`*` - 1))`
+  and all values `ext.extent(`k`)` with k in the range of \[`0`,
+  *`rank_`*` - 1`) is representable as a value of type `index_type`.
+*Effects:*
+- Direct-non-list-initializes *extents\_* with `ext`; and
+- if *rank\_* is greater than one, direct-non-list-initializes
+  *stride-rm2*
+  - with `ext.extent(`*`rank_`*` - 1)` if `padding_value` is
+    `dynamic_extent`,
+  - otherwise with
+    *`LEAST-MULTIPLE-AT-LEAST`*`(padding_value, ext.extent(`*`rank_`*` - 1))`.
+``` cpp
+template<class OtherIndexType>
+constexpr mapping(const extents_type& ext, OtherIndexType pad);
+```
+*Constraints:*
+- `is_convertible_v<OtherIndexType, index_type>` is `true`.
+- `is_nothrow_constructible_v<index_type, OtherIndexType>` is `true`.
+*Preconditions:*
+- `pad` is representable as a value of type `index_type`.
+- `extents_type::`*`index-cast`*`(pad)` is greater than zero.
+- If *rank\_* is greater than one, then
+  *`LEAST-MULTIPLE-AT-LEAST`*`(pad, ext.extent(`*`rank_`*` - 1))` is
+  representable as a value of type `index_type`.
+- If *rank\_* is greater than one, then the product of
+  *`LEAST-MULTIPLE-AT-LEAST`*`(pad, ext.extent(`*`rank_`*` - 1))` and
+  all values `ext.extent(`k`)` with k in the range of \[`0`,
+  *`rank_`*` - 1`) is representable as a value of type `index_type`.
+- If `padding_value` is not equal to `dynamic_extent`, `padding_value`
+  equals `extents_type::`*`index-cast`*`(pad)`.
+*Effects:* Direct-non-list-initializes *extents\_* with `ext`, and if
+*rank\_* is greater than one, direct-non-list-initializes *stride-rm2*
+with *`LEAST-MULTIPLE-AT-LEAST`*`(pad, ext.extent(`*`rank_`*` - 1))`.
+``` cpp
+template<class OtherExtents>
+  constexpr explicit(!is_convertible_v<OtherExtents, extents_type>)
+    mapping(const layout_right::mapping<OtherExtents>& other);
+```
+*Constraints:* `is_constructible_v<extents_type, OtherExtents>` is
+`true`.
+*Mandates:* If `OtherExtents::rank()` is greater than 1, then
+``` cpp
+(static-padding-stride == dynamic_extent) ||
+(OtherExtents::static_extent(rank_ - 1) == dynamic_extent) ||
+(static-padding-stride == OtherExtents::static_extent(rank_ - 1))
+```
+is `true`.
+*Preconditions:*
+- If *`rank_`*` > 1` is `true` and `padding_value == dynamic_extent` is
+  `false`, then `other.stride( `*`rank_`*` - 2)` equals
+  ``` cpp
+  LEAST-MULTIPLE-AT-LEAST(padding_value,
+                          extents_type::index-cast(other.extents().extent(rank_ - 1)))
+  ```
+  and
+- `other.required_span_size()` is representable as a value of type
+  `index_type`.
+*Effects:* Equivalent to `mapping(other.extents())`.
+``` cpp
+template<class OtherExtents>
+  constexpr explicit(rank_ > 0)
+    mapping(const layout_stride::mapping<OtherExtents>& other);
+```
+*Constraints:* `is_constructible_v<extents_type, OtherExtents>` is
+`true`.
+*Preconditions:*
+- If *rank\_* is greater than 1 and `padding_value` does not equal
+  `dynamic_extent`, then `other.stride(`*`rank_`*` - 2)` equals
+  ``` cpp
+  LEAST-MULTIPLE-AT-LEAST(padding_value,
+                          extents_type::index-cast(other.extents().extent(rank_ - 1)))
+  ```
+- If *rank\_* is greater than 0, then other.stride(*rank\_* - 1) equals
+  1.
+- If *rank\_* is greater than 2, then for all r in the range \[`0`,
+  *`rank_`*` - 2`), `other.stride(`r`)` equals
+  ``` cpp
+  (other.extents().rev-prod-of-extents(r) / other.extents().extent(rank_ - 1)) *
+    other.stride(rank_ - 2)
+  ```
+- `other.required_span_size()` is representable as a value of type
+  `index_type`.
+*Effects:*
+- Direct-non-list-initializes *extents\_* with `other.extents()`; and
+- if *rank\_* is greater than one, direct-non-list-initializes
+  *stride-rm2* with `other.stride(`*`rank_`*` - 2)`.
+``` cpp
+template<class LayoutRightPaddedMapping>
+  constexpr explicit(see below)
+    mapping(const LayoutRightPaddedMapping& other);
+```
+*Constraints:*
+- *`is-layout-right-padded-mapping-of`*`<LayoutRightPaddedMapping>` is
+  `true`.
+- `is_constructible_v<extents_type, typename LayoutRightPaddedMapping::extents_- type>`
+  is `true`.
+*Mandates:* If *rank\_* is greater than 1, then
+``` cpp
+padding_value == dynamic_extent ||
+LayoutRightPaddedMapping::padding_value == dynamic_extent ||
+padding_value == LayoutRightPaddedMapping::padding_value
+```
+is `true`.
+*Preconditions:*
+- If *rank\_* is greater than 1 and `padding_value` does not equal
+  `dynamic_extent`, then `other.stride(`*`rank_`*` - 2)` equals
+  ``` cpp
+  LEAST-MULTIPLE-AT-LEAST(padding_value,
+                          extents_type::index-cast(other.extent(rank_ - 1)))
+  ```
+- `other.required_span_size()` is representable as a value of type
+  `index_type`.
+*Effects:*
+- Direct-non-list-initializes *extents\_* with `other.extents()`; and
+- if *rank\_* is greater than one, direct-non-list-initializes
+  *stride-rm2* with `other.stride(rank_ - 2)`.
+*Remarks:* The expression inside `explicit` is equivalent to:
+``` cpp
+rank_ > 1 &&
+(padding_value != dynamic_extent ||
+ LayoutRightPaddedMapping::padding_value == dynamic_extent)
+```
+``` cpp
+template<class LayoutLeftPaddedMapping>
+  constexpr explicit(see below)
+    mapping(const LayoutLeftPaddedMapping& other) noexcept;
+```
+*Constraints:*
+- *`is-layout-left-padded-mapping-of`*`<LayoutLeftPaddedMapping>` is
+  `true` or *`is-mapping-of`*`<layout_left, LayoutLeftPaddedMapping>` is
+  `true`.
+- *rank\_* equals zero or one.
+- `is_constructible_v<extents_type, typename LayoutLeftPaddedMapping::extents_type>`
+  is `true`.
+*Preconditions:* `other.required_span_size()` is representable as a
+value of type `index_type`.
+*Effects:* Direct-non-list-initializes *extents\_* with
+`other.extents()`.
+*Remarks:* The expression inside `explicit` is equivalent to:
+``` cpp
+!is_convertible_v<typename LayoutLeftPaddedMapping::extents_type, extents_type>
+```
+[*Note 12*: Neither the input mapping nor the mapping to be constructed
+uses the padding stride in the rank-0 or rank-1 case, so the padding
+stride affects neither the constraints nor the
+preconditions. — *end note*]
+###### Observers <a id="mdspan.layout.rightpad.obs">[[mdspan.layout.rightpad.obs]]</a>
+``` cpp
+constexpr array<index_type, rank_> strides() const noexcept;
+```
+*Returns:* `array<index_type, `*`rank_`*`>(``stride(P_rank)...``)`.
+``` cpp
+constexpr index_type required_span_size() const noexcept;
+```
+*Returns:* `0` if the multidimensional index space *extents\_* is empty,
+otherwise
+`(*this)(`*`extents_`*`.extent(P_rank) - index_type(1)...) + 1`.
+``` cpp
+template<class... Indices>
+constexpr size_t operator()(Indices... idxs) const noexcept;
+```
+*Constraints:*
+- `sizeof...(Indices) == `*`rank_`* is `true`.
+- `(is_convertible_v<Indices, index_type> && ...)` is `true`.
+- `(is_nothrow_constructible_v<index_type, Indices> && ...)` is `true`.
+*Preconditions:* `extents_type::`*`index-cast`*`(idxs)` is a
+multidimensional index in `extents()` [[mdspan.overview]].
+*Returns:*
+`((static_cast<index_type>(idxs) * stride(P_rank)) + ... + 0)`.
+``` cpp
+static constexpr bool is_always_exhaustive() noexcept;
+```
+*Returns:*
+- If *rank\_* equals zero or one, then `true`;
+- otherwise, if neither *static-padding-stride* nor *last-static-extent*
+  equal `dynamic_extent`, then
+  *`static-padding-stride`*` == `*`last-static-extent`*;
+- otherwise, `false`.
+``` cpp
+constexpr bool is_exhaustive() const noexcept;
+```
+*Returns:* `true` if *rank\_* equals zero or one; otherwise,
+``` cpp
+extents_.extent(rank_ - 1) == stride(rank_ - 2)
+```
+``` cpp
+constexpr index_type stride(rank_type r) const noexcept;
+```
+*Preconditions:* `r` is smaller than *rank\_*.
+*Returns:*
+- If `r` equals *`rank_`*` - 1`: `1`;
+- otherwise, if `r` equals *`rank_`*` - 2`: *stride-rm2*;
+- otherwise, the product of *stride-rm2* and all values
+  `extents_.extent(`k`)` with k in the range of \[`r + 1`,
+  *`rank_`*` - 1`).
+``` cpp
+template<class LayoutRightPaddedMapping>
+  friend constexpr bool operator==(const mapping& x, const LayoutRightPaddedMapping& y) noexcept;
+```
+*Constraints:*
+- *`is-layout-right-padded-mapping-of`*`<LayoutRightPaddedMapping>` is
+  `true`.
+- `LayoutRightPaddedMapping::extents_type::rank() == `*`rank_`* is
+  `true`.
+*Returns:* `true` if `x.extents() == y.extents()` is `true` and
+*`rank_`*` < 2 || x.stride(`*`rank_`*` - 2) == y.stride(`*`rank_`*` - 2)`
+is `true`. 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
 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 [[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
 constexpr data_handle_type offset(data_handle_type p, size_t i) const noexcept;
 ```
 *Effects:* Equivalent to: `return p + i;`
+##### Class template `aligned_accessor` <a id="mdspan.accessor.aligned">[[mdspan.accessor.aligned]]</a>
+###### Overview <a id="mdspan.accessor.aligned.overview">[[mdspan.accessor.aligned.overview]]</a>
+``` cpp
+namespace std {
+  template<class ElementType, size_t ByteAlignment>
+  struct aligned_accessor {
+    using offset_policy = default_accessor<ElementType>;
+    using element_type = ElementType;
+    using reference = ElementType&;
+    using data_handle_type = ElementType*;
+    static constexpr size_t byte_alignment = ByteAlignment;
+    constexpr aligned_accessor() noexcept = default;
+    template<class OtherElementType, size_t OtherByteAlignment>
+      constexpr aligned_accessor(
+        aligned_accessor<OtherElementType, OtherByteAlignment>) noexcept;
+    template<class OtherElementType>
+      constexpr explicit aligned_accessor(default_accessor<OtherElementType>) noexcept;
+    template<class OtherElementType>
+      constexpr operator default_accessor<OtherElementType>() const noexcept;
+    constexpr reference access(data_handle_type p, size_t i) const noexcept;
+    constexpr typename offset_policy::data_handle_type offset(
+      data_handle_type p, size_t i) const noexcept;
+  };
+}
+```
+*Mandates:*
+- `byte_alignment` is a power of two, and
+- `byte_alignment >= alignof(ElementType)` is `true`.
+`aligned_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 `aligned_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 `aligned_accessor` if and only
+if
+- \[`p`, `p + `n) is a valid range, and,
+- if n is greater than zero, then
+  `is_sufficiently_aligned<byte_alignment>(p)` is `true`.
+[*Example 1*:
+The following function `compute` uses `is_sufficiently_aligned` to check
+whether a given `mdspan` with `default_accessor` has a data handle with
+sufficient alignment to be used with
+`aligned_accessor<float, 4 * sizeof(float)>`. If so, the function
+dispatches to a function `compute_using_fourfold_overalignment` that
+requires fourfold over-alignment of arrays, but can therefore use
+hardware-specific instructions, such as four-wide SIMD (Single
+Instruction Multiple Data) instructions. Otherwise, `compute` dispatches
+to a possibly less optimized function
+`compute_without_requiring_overalignment` that has no over-alignment
+requirement.
+``` cpp
+void compute_using_fourfold_overalignment(
+  mdspan<float, dims<1>, layout_right, aligned_accessor<float, 4 * alignof(float)>> x);
+void compute_without_requiring_overalignment(
+  mdspan<float, dims<1>, layout_right> x);
+void compute(mdspan<float, dims<1>> x) {
+  constexpr auto byte_alignment = 4 * sizeof(float);
+  auto accessor = aligned_accessor<float, byte_alignment>{};
+  auto x_handle = x.data_handle();
+  if (is_sufficiently_aligned<byte_alignment>(x_handle)) {
+    compute_using_fourfold_overalignment(mdspan{x_handle, x.mapping(), accessor});
+  } else {
+    compute_without_requiring_overalignment(x);
+  }
+}
+```
+— *end example*]
+###### Members <a id="mdspan.accessor.aligned.members">[[mdspan.accessor.aligned.members]]</a>
+``` cpp
+template<class OtherElementType, size_t OtherByteAlignment>
+  constexpr aligned_accessor(aligned_accessor<OtherElementType, OtherByteAlignment>) noexcept;
+```
+*Constraints:*
+- `is_convertible_v<OtherElementType(*)[], element_type(*)[]>` is
+  `true`.
+- `OtherByteAlignment >= byte_alignment` is `true`.
+*Effects:* None.
+``` cpp
+template<class OtherElementType>
+  constexpr explicit aligned_accessor(default_accessor<OtherElementType>) noexcept;
+```
+*Constraints:*
+`is_convertible_v<OtherElementType(*)[], element_type(*)[]>` is `true`.
+*Effects:* None.
+``` cpp
+constexpr reference access(data_handle_type p, size_t i) const noexcept;
+```
+*Preconditions:* \[`0`, `i + 1`) is an accessible range for `p` and
+`*this`.
+*Effects:* Equivalent to: `return assume_aligned<byte_alignment>(p)[i];`
+``` cpp
+template<class OtherElementType>
+  constexpr operator default_accessor<OtherElementType>() const noexcept;
+```
+*Constraints:*
+`is_convertible_v<element_type(*)[], OtherElementType(*)[]>` is `true`.
+*Effects:* Equivalent to: `return {};`
+``` cpp
+constexpr typename offset_policy::data_handle_type
+  offset(data_handle_type p, size_t i) const noexcept;
+```
+*Preconditions:* \[`0`, `i + 1`) is an accessible range for `p` and
+`*this`.
+*Effects:* Equivalent to:
+`return assume_aligned<byte_alignment>(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.
   class mdspan {
   public:
     using extents_type = Extents;
     using layout_type = LayoutPolicy;
     using accessor_type = AccessorPolicy;
+    using mapping_type = layout_type::template mapping<extents_type>;
     using element_type = ElementType;
     using value_type = remove_cv_t<element_type>;
+    using index_type = extents_type::index_type;
+    using size_type = extents_type::size_type;
+    using rank_type = extents_type::rank_type;
+    using data_handle_type = accessor_type::data_handle_type;
+    using reference = 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); }
     template<class OtherIndexType>
       constexpr reference operator[](span<OtherIndexType, rank()> indices) const;
     template<class OtherIndexType>
       constexpr reference operator[](const array<OtherIndexType, rank()>& indices) const;
+    template<class... OtherIndexTypes>
+      constexpr reference
+        at(OtherIndexTypes... indices) const;                           // freestanding-deleted
+    template<class OtherIndexType>
+      constexpr reference
+        at(span<OtherIndexType, rank()> indices) const;                 // freestanding-deleted
+    template<class OtherIndexType>
+      constexpr reference
+        at(const array<OtherIndexType, rank()>& indices) const;         // freestanding-deleted
     constexpr size_type size() const noexcept;
+    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_; }
       -> 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, extents<size_t, maybe-static-ext<Integrals>...>>;
   template<class ElementType, class OtherIndexType, size_t N>
     mdspan(ElementType*, span<OtherIndexType, N>)
       -> mdspan<ElementType, dextents<size_t, N>>;
 ```
 *Constraints:*
 - `is_convertible_v<const OtherIndexType&, index_type>` is `true`,
+- `is_nothrow_constructible_v<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
 - `is_constructible_v<data_handle_type, const OtherAccessor::data_handle_type&>`
   is `true`, and
 - `is_constructible_v<extents_type, OtherExtents>` is `true`.
+*Preconditions:* $[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.
+For each rank index `r` of `extents_type`,
 `static_extent(r) == dynamic_extent || static_extent(r) == other.extent(r)`
 is `true`.
 *Effects:*
 - Direct-non-list-initializes *ptr\_* with `other.`*`ptr_`*,
 - direct-non-list-initializes *map\_* with `other.`*`map_`*, and
   `true`, and
 - `sizeof...(OtherIndexTypes) == rank()` is `true`.
 Let `I` be `extents_type::`*`index-cast`*`(std::move(indices))`.
+`I` is a multidimensional index in `extents()`.
 [*Note 1*: This implies that
 *`map_`*`(I) < `*`map_`*`.required_span_size()` is
 `true`. — *end note*]
 ```
 is `true`. Equivalent to:
 ``` cpp
+return operator[](extents_type::index-cast(as_const(indices[P]))...);
+```
+``` cpp
+template<class... OtherIndexTypes>
+  constexpr reference at(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))`.
+*Returns:* `(*this)[I...]`.
+*Throws:* `out_of_range` if `I` is not a multidimensional index in
+`extents()`.
+``` cpp
+template<class OtherIndexType>
+  constexpr reference at(span<OtherIndexType, rank()> indices) const;
+template<class OtherIndexType>
+  constexpr reference at(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 at(extents_type::index-cast(as_const(indices[P]))...);
 ```
 ``` cpp
 constexpr size_type size() const noexcept;
 ```
 [[basic.fundamental]].
 *Returns:* `extents().`*`fwd-prod-of-extents`*`(rank())`.
 ``` cpp
+constexpr bool empty() const noexcept;
 ```
 *Returns:* `true` if the size of the multidimensional index space
 `extents()` is 0, otherwise `false`.
 swap(x.ptr_, y.ptr_);
 swap(x.map_, y.map_);
 swap(x.acc_, y.acc_);
 ```
+#### `submdspan` <a id="mdspan.sub">[[mdspan.sub]]</a>
+##### Overview <a id="mdspan.sub.overview">[[mdspan.sub.overview]]</a>
+The `submdspan` facilities create a new `mdspan` viewing a subset of
+elements of an existing input `mdspan`. The subset viewed by the created
+`mdspan` is determined by the `SliceSpecifier` arguments.
+For each function defined in [[mdspan.sub]] that takes a parameter pack
+named `slices` as an argument:
+- let `index_type` be
+  - `M::index_type` if the function is a member of a class `M`,
+  - otherwise, `remove_reference_t<decltype(src)>::index_type` if the
+    function has a parameter named `src`,
+  - otherwise, the same type as the function’s template argument
+    `IndexType`;
+- let `rank` be the number of elements in `slices`;
+- let sₖ be the kᵗʰ element of `slices`;
+- let Sₖ be the type of sₖ; and
+- let `map-rank` be an `array<size_t, rank>` such that for each k in the
+  range \[`0`, `rank`), `map-rank[k]` equals:
+  - `dynamic_extent` if Sₖ models `convertible_to<index_type>`,
+  - otherwise, the number of types Sⱼ with j < k that do not model
+    `convertible_to<index_type>`.
+##### `strided_slice` <a id="mdspan.sub.strided.slice">[[mdspan.sub.strided.slice]]</a>
+`strided_slice` represents a set of `extent` regularly spaced integer
+indices. The indices start at `offset`, and increase by increments of
+`stride`.
+``` cpp
+namespace std {
+  template<class OffsetType, class ExtentType, class StrideType>
+  struct strided_slice {
+    using offset_type = OffsetType;
+    using extent_type = ExtentType;
+    using stride_type = StrideType;
+    [[no_unique_address]] offset_type offset{};
+    [[no_unique_address]] extent_type extent{};
+    [[no_unique_address]] stride_type stride{};
+  };
+}
+```
+`strided_slice` has the data members and special members specified
+above. It has no base classes or members other than those specified.
+*Mandates:* `OffsetType`, `ExtentType`, and `StrideType` are signed or
+unsigned integer types, or model `integral-constant-like`.
+[*Note 1*:
+`strided_slice{.offset = 1, .extent = 10, .stride = 3}`
+indicates the indices `1`, `4`, `7`, and `10`. Indices are selected from
+the half-open interval \[`1`, `1 + 10`).
+— *end note*]
+##### `submdspan_mapping_result` <a id="mdspan.sub.map.result">[[mdspan.sub.map.result]]</a>
+Specializations of `submdspan_mapping_result` are returned by overloads
+of `submdspan_mapping`.
+``` cpp
+namespace std {
+  template<class LayoutMapping>
+  struct submdspan_mapping_result {
+    [[no_unique_address]] LayoutMapping mapping = LayoutMapping();
+    size_t offset{};
+  };
+}
+```
+`submdspan_mapping_result` has the data members and special members
+specified above. It has no base classes or members other than those
+specified.
+`LayoutMapping` shall meet the layout mapping requirements
+[[mdspan.layout.policy.reqmts]].
+##### Exposition-only helpers <a id="mdspan.sub.helpers">[[mdspan.sub.helpers]]</a>
+``` cpp
+template<class T>
+  constexpr T de-ice(T val) { return val; }
+template<integral-constant-like T>
+  constexpr auto de-ice(T) { return T::value; }
+template<class IndexType, size_t k, class... SliceSpecifiers>
+  constexpr IndexType first_(SliceSpecifiers... slices);
+```
+*Mandates:* `IndexType` is a signed or unsigned integer type.
+Let φₖ denote the following value:
+- sₖ if Sₖ models `convertible_to<IndexType>`;
+- otherwise, `get<0>(`sₖ`)` if Sₖ models `index-pair-like<IndexType>`;
+- otherwise, *`de-ice`*`(`sₖ`.offset)` if Sₖ is a specialization of
+  `strided_slice`;
+- otherwise, `0`.
+*Preconditions:* φₖ is representable as a value of type `IndexType`.
+*Returns:* `extents<IndexType>::`*`index-cast`*`(`φₖ`)`.
+``` cpp
+template<size_t k, class Extents, class... SliceSpecifiers>
+  constexpr auto last_(const Extents& src, SliceSpecifiers... slices);
+```
+*Mandates:* `Extents` is a specialization of `extents`.
+Let `index_type` be `typename Extents::index_type`.
+Let λₖ denote the following value:
+- *`de-ice`*`(`sₖ`) + 1` if Sₖ models `convertible_to<index_type>`;
+  otherwise
+- `get<1>(`sₖ`)` if Sₖ models `index-pair-like<index_type>`; otherwise
+- *`de-ice`*`(`sₖ`.offset)` `+` *`de-ice`*`(`sₖ`.extent)` if Sₖ is a
+  specialization of `strided_slice`; otherwise
+- `src.extent(k)`.
+*Preconditions:* λₖ is representable as a value of type `index_type`.
+*Returns:* `Extents::`*`index-cast`*`(`λₖ`)`.
+``` cpp
+template<class IndexType, size_t N, class... SliceSpecifiers>
+  constexpr array<IndexType, sizeof...(SliceSpecifiers)>
+    src-indices(const array<IndexType, N>& indices, SliceSpecifiers... slices);
+```
+*Mandates:* `IndexType` is a signed or unsigned integer type.
+*Returns:* An `array<IndexType, sizeof...(SliceSpecifiers)> src_idx`
+such that for each k in the range \[`0`, `sizeof...(SliceSpecifiers)`),
+`src_idx[`k`]` equals
+- *`first_`*`<IndexType, `k`>(slices...)` for each k where
+  *`map-rank`*`[`k`]` equals `dynamic_extent`,
+- otherwise, *`first_`*`<IndexType, `k`>(slices...)` `+`
+  `indices[`*`map-rank`*`[`k`]]`.
+##### `submdspan_extents` function <a id="mdspan.sub.extents">[[mdspan.sub.extents]]</a>
+``` cpp
+template<class IndexType, size_t... Extents, class... SliceSpecifiers>
+  constexpr auto submdspan_extents(const extents<IndexType, Extents...>& src,
+                                   SliceSpecifiers... slices);
+```
+*Constraints:* `sizeof...(slices)` equals `sizeof...(Extents)`.
+*Mandates:* For each rank index k of `src.extents()`, exactly one of the
+following is true:
+- Sₖ models `convertible_to<IndexType>`,
+- Sₖ models `index-pair-like<IndexType>`,
+- `is_convertible_v<`Sₖ`, full_extent_t>` is `true`, or
+- Sₖ is a specialization of `strided_slice`.
+*Preconditions:* For each rank index k of `src.extents()`, all of the
+following are `true`:
+- if Sₖ is a specialization of `strided_slice`
+  - `$s_k$.extent` = 0, or
+  - `$s_k$.stride` > 0
+- $0 \le \texttt{\textit{first_}<IndexType, $k$>(slices...)}$
+  $\le \texttt{\textit{last_}<$k$>(src, slices...)}$ ≤ `src.extent($k$)`
+Let `SubExtents` be a specialization of `extents` such that:
+- `SubExtents::rank()` equals the number of k such that Sₖ does not
+  model `convertible_to<IndexType>`; and
+- for each rank index k of `Extents` such that
+  *`map-rank`*`[`k`] != dynamic_extent` is `true`,
+  `SubExtents::static_extent(`*`map-rank`*`[`k`])` equals:
+  - `Extents::static_extent(`k`)` if
+    `is_convertible_v<`Sₖ`, full_extent_t>` is `true`; otherwise
+  - *`de-ice`*`(tuple_element_t<1, `Sₖ`>()) -`
+    *`de-ice`*`(tuple_element_t<0, `Sₖ`>())` if Sₖ models
+    `index-pair-like<IndexType>`, and both `tuple_element_t<0, `Sₖ`>`
+    and `tuple_element_t<1, `Sₖ`>` model `integral-constant-like`;
+    otherwise
+  - `0`, if Sₖ is a specialization of `strided_slice`, whose
+    `extent_type` models *`integral-constant-like`*, for which
+    `extent_type()` equals zero; otherwise
+  - `1 + (`*`de-ice`*`(`Sₖ`::extent_type()) - 1) /`
+    *`de-ice`*`(`Sₖ`::stride_type())`, if Sₖ is a specialization of
+    `strided_slice` whose `extent_type` and `stride_type` model
+    *`integral-constant-like`*;
+  - otherwise, `dynamic_extent`.
+*Returns:* A value `ext` of type `SubExtents` such that for each k for
+which *`map-rank`*`[`k`] != dynamic_extent` is `true`,
+`ext.extent(`*`map-rank`*`[`k`])` equals:
+- sₖ`.extent == 0 ? 0 : 1 + (`*`de-ice`*`(`sₖ`.extent) - 1) / `*`de-ice`*`(`sₖ`.stride)`
+  if Sₖ is a specialization of `strided_slice`,
+- otherwise,
+  *`last_`*`<`k`>(src, slices...) - `*`first_`*`<IndexType, `k`>(slices...)`.
+##### Specializations of `submdspan_mapping` <a id="mdspan.sub.map">[[mdspan.sub.map]]</a>
+###### Common <a id="mdspan.sub.map.common">[[mdspan.sub.map.common]]</a>
+The following elements apply to all functions in [[mdspan.sub.map]].
+*Constraints:* `sizeof...(slices)` equals `extents_type::rank()`.
+*Mandates:* For each rank index k of `extents()`, exactly one of the
+following is true:
+- Sₖ models `convertible_to<index_type>`,
+- Sₖ models `index-pair-like<index_type>`,
+- `is_convertible_v<Sₖ, full_extent_t>` is `true`, or
+- Sₖ is a specialization of `strided_slice`.
+*Preconditions:* For each rank index k of `extents()`, all of the
+following are `true`:
+- if Sₖ is a specialization of `strided_slice`, `sₖ.extent` is equal to
+  zero or `sₖ.stride` is greater than zero; and
+- $0            \leq \tcode{\exposid{first_}<index_type, $k$>(slices...)} \\
+  \hphantom{0 } \leq \tcode{\exposid{last_}<$k$>(extents(), slices...)} \\
+  \hphantom{0 } \leq \tcode{extents().extent($k$)}$
+Let `sub_ext` be the result of `submdspan_extents(extents(), slices...)`
+and let `SubExtents` be `decltype(sub_ext)`.
+Let `sub_strides` be an
+`array<SubExtents::index_type, SubExtents::rank()>` such that for each
+rank index k of `extents()` for which `map-rank[k]` is not
+`dynamic_extent`, `sub_strides[map-rank[k]]` equals:
+- `stride(k) * de-ice(sₖ.stride)` if Sₖ is a specialization of
+  `strided_slice` and `sₖ.stride < sₖ.extent` is `true`;
+- otherwise, `stride(k)`.
+Let `P` be a parameter pack such that
+`is_same_v<make_index_sequence<rank()>, index_sequence<P...>>` is
+`true`.
+If `first_<index_type, k>(slices...)` equals `extents().extent(k)` for
+any rank index k of `extents()`, then let `offset` be a value of type
+`size_t` equal to `(*this).required_span_size()`. Otherwise, let
+`offset` be a value of type `size_t` equal to
+`(*this)(first_<index_type, P>(slices...)...)`.
+Given a layout mapping type `M`, a type `S` is a *unit-stride slice for
+`M`* if
+- `S` is a specialization of `strided_slice` where `S::stride_type`
+  models `integral-constant-like` and `S::stride_type::value` equals
+  `1`,
+- `S` models `index-pair-like<M::index_type>`, or
+- `is_convertible_v<S, full_extent_t>` is `true`.
+###### `layout_left` specialization of `submdspan_mapping` <a id="mdspan.sub.map.left">[[mdspan.sub.map.left]]</a>
+``` cpp
+template<class Extents>
+template<class... SliceSpecifiers>
+constexpr auto layout_left::mapping<Extents>::submdspan-mapping-impl(
+      SliceSpecifiers... slices) const -> see below;
+```
+*Returns:*
+- `submdspan_mapping_result{*this, 0}`, if `Extents::rank() == 0` is
+  `true`;
+- otherwise,
+  `submdspan_mapping_result{layout_left::mapping(sub_ext), offset}`, if
+  `SubExtents::rank() == 0` is `true`;
+- otherwise,
+  `submdspan_mapping_result{layout_left::mapping(sub_ext), offset}`, if
+  - for each k in the range \[`0`, `SubExtents::rank() - 1)`),
+    `is_convertible_v<`Sₖ`, full_extent_t>` is `true`; and
+  - for k equal to `SubExtents::rank() - 1`, Sₖ is a unit-stride slice
+    for `mapping`;
+  \[*Note 2*: If the above conditions are true, all Sₖ with k larger
+  than `SubExtents::rank() - 1` are convertible to
+  `index_type`. — *end note*]
+- otherwise,
+  ``` cpp
+  submdspan_mapping_result{layout_left_padded<S_static>::mapping(sub_ext, stride(u + 1)),
+                           offset}
+  ```
+  if for a value u for which u+1 is the smallest value p larger than
+  zero for which Sₚ is a unit-stride slice for `mapping`, the following
+  conditions are met:
+  - S₀ is a unit-stride slice for `mapping`; and
+  - for each k in the range \[u` + 1`, u` + SubExtents::rank() - 1`),
+    `is_convertible_v<`Sₖ`, full_extent_t>` is `true`; and
+  - for k equal to u` + SubExtents::rank() - 1`, Sₖ is a unit-stride
+    slice for `mapping`;
+  and where `S_static` is:
+  - `dynamic_extent`, if `static_extent(`k`)` is `dynamic_extent` for
+    any k in the range \[`0`, u` + 1`),
+  - otherwise, the product of all values `static_extent(`k`)` for k in
+    the range \[`0`, u` + 1`);
+- otherwise,
+  ``` cpp
+  submdspan_mapping_result{layout_stride::mapping(sub_ext, sub_strides), offset}
+  ```
+###### `layout_right` specialization of `submdspan_mapping` <a id="mdspan.sub.map.right">[[mdspan.sub.map.right]]</a>
+``` cpp
+template<class Extents>
+template<class... SliceSpecifiers>
+constexpr auto layout_right::mapping<Extents>::submdspan-mapping-impl(
+      SliceSpecifiers... slices) const -> see below;
+```
+*Returns:*
+- `submdspan_mapping_result{*this, 0}`, if `Extents::rank() == 0` is
+  `true`;
+- otherwise,
+  `submdspan_mapping_result{layout_right::mapping(sub_ext), offset}`, if
+  `SubExtents::rank() == 0` is `true`;
+- otherwise,
+  `submdspan_mapping_result{layout_right::mapping(sub_ext), offset}`, if
+  - for each k in the range \[*`rank_`*` - SubExtents::rank() + 1`,
+    *`rank_`*), `is_convertible_v<`Sₖ`, full_extent_t>` is `true`; and
+  - for k equal to *rank\_* - `SubExtents::rank()`, Sₖ is a unit-stride
+    slice for `mapping`;
+  \[*Note 3*: If the above conditions are true, all Sₖ with
+  $k < \texttt{\textit{rank_} - SubExtents::rank()}$ are convertible to
+  `index_type`. — *end note*]
+- otherwise,
+  ``` cpp
+  submdspan_mapping_result{layout_right_padded<S_static>::mapping(sub_ext,
+                               stride(rank_ - u - 2)), offset}
+  ```
+  if for a value u for which rank_ - u - 2 is the largest value p
+  smaller than *`rank_`*` - 1` for which Sₚ is a unit-stride slice for
+  `mapping`, the following conditions are met:
+  - for k equal to *`rank_`*` - 1`, Sₖ is a unit-stride slice for
+    `mapping`; and
+  - for each k in the range
+    \[*`rank_`*` - SubExtents::rank() - `u` + 1`,
+    *`rank_`*` - `u` - 1`), `is_convertible_v<`Sₖ`, full_extent_t>` is
+    `true`; and
+  - for k equal to *`rank_`*` - SubExtents::rank() - `u, Sₖ is a
+    unit-stride slice for `mapping`;
+  and where `S_static` is:
+  - `dynamic_extent`, if `static_extent(`k`)` is `dynamic_extent` for
+    any k in the range \[*`rank_`*` - `u` - 1`, *`rank_`*),
+  - otherwise, the product of all values `static_extent(`k`)` for k in
+    the range \[*`rank_`*` - `u` - 1`, *`rank_`*);
+- otherwise,
+  ``` cpp
+  submdspan_mapping_result{layout_stride::mapping(sub_ext, sub_strides), offset}
+  ```
+###### `layout_stride` specialization of `submdspan_mapping` <a id="mdspan.sub.map.stride">[[mdspan.sub.map.stride]]</a>
+``` cpp
+template<class Extents>
+template<class... SliceSpecifiers>
+constexpr auto layout_stride::mapping<Extents>::submdspan-mapping-impl(
+      SliceSpecifiers... slices) const -> see below;
+```
+*Returns:*
+- `submdspan_mapping_result{*this, 0}`, if `Extents::rank() == 0` is
+  `true`;
+- otherwise,
+  ``` cpp
+  submdspan_mapping_result{layout_stride::mapping(sub_ext, sub_strides), offset}
+  ```
+###### `layout_left_padded` specialization of `submdspan_mapping` <a id="mdspan.sub.map.leftpad">[[mdspan.sub.map.leftpad]]</a>
+``` cpp
+template<class Extents>
+template<class... SliceSpecifiers>
+constexpr auto layout_left_padded::mapping<Extents>::submdspan-mapping-impl(
+    SliceSpecifiers... slices) const -> see below;
+```
+*Returns:*
+- `submdspan_mapping_result{*this, 0}`, if `Extents::rank() == 0` is
+  `true`;
+- otherwise,
+  `submdspan_mapping_result{layout_left::mapping(sub_ext), offset}`, if
+  *`rank_`*` == 1` is `true` or `SubExtents::rank() == 0` is `true`;
+- otherwise,
+  `submdspan_mapping_result{layout_left::mapping(sub_ext), offset}`, if
+  - `SubExtents::rank() == 1` is `true` and
+  - S₀ is a unit-stride slice for `mapping`;
+- otherwise,
+  ``` cpp
+  submdspan_mapping_result{layout_left_padded<S_static>::mapping(sub_ext, stride(u + 1)),
+                           offset}
+  ```
+  if for a value u for which u` + 1` is the smallest value p larger than
+  zero for which Sₚ is a unit-stride slice for `mapping`, the following
+  conditions are met:
+  - S₀ is a unit-stride slice for `mapping`; and
+  - for each k in the range \[u` + 1`, u` + SubExtents::rank() - 1`),
+    `is_convertible_v<`Sₖ`, full_extent_t>` is `true`; and
+  - for k equal to u` + SubExtents::rank() - 1`, Sₖ is a unit-stride
+    slice for `mapping`;
+  where `S_static` is:
+  - `dynamic_extent`, if *static-padding-stride* is `dynamic_extent` or
+    `static_extent(`k`)` is `dynamic_extent` for any k in the range
+    \[`1`, u` + 1`),
+  - otherwise, the product of *static-padding-stride* and all values
+    `static_extent(`k`)` for k in the range \[`1`, u` + 1`);
+- otherwise,
+  ``` cpp
+  submdspan_mapping_result{layout_stride::mapping(sub_ext, sub_strides), offset}
+  ```
+###### `layout_right_padded` specialization of `submdspan_mapping` <a id="mdspan.sub.map.rightpad">[[mdspan.sub.map.rightpad]]</a>
+``` cpp
+template<class Extents>
+template<class... SliceSpecifiers>
+constexpr auto layout_right_padded::mapping<Extents>::submdspan-mapping-impl(
+    SliceSpecifiers... slices) const -> see below;
+```
+*Returns:*
+- `submdspan_mapping_result{*this, 0}`, if *`rank_`*` == 0` is `true`;
+- otherwise,
+  `submdspan_mapping_result{layout_right::mapping(sub_ext), offset}`, if
+  *`rank_`*` == 1` is `true` or `SubExtents::rank() == 0` is `true`;
+- otherwise,
+  `submdspan_mapping_result{layout_right::mapping(sub_ext), offset}`, if
+  - `SubExtents::rank() == 1` is `true` and
+  - for k equal to *`rank_`*` - 1`, Sₖ is a unit-stride slice for
+    `mapping`;
+- otherwise,
+  ``` cpp
+  submdspan_mapping_result{layout_right_padded<S_static>::mapping(sub_ext,
+                               stride(rank_ - u - 2)), offset}
+  ```
+  if for a value u for which *`rank_`*` - `u` - 2` is the largest value
+  p smaller than *`rank_`*` - 1` for which Sₚ is a unit-stride slice for
+  `mapping`, the following conditions are met:
+  - for k equal to *`rank_`*` - 1`, Sₖ is a unit-stride slice for
+    `mapping`; and
+  - for each k in the range
+    \[*`rank_`*` - SubExtents::rank() - `u` + 1`,
+    *`rank_`*` - `u` - 1)`), `is_convertible_v<`Sₖ`, full_extent_t>` is
+    `true`; and
+  - for k equal to *`rank_`*` - SubExtents::rank() - `u, Sₖ is a
+    unit-stride slice for `mapping`;
+  and where `S_static` is:
+  - `dynamic_extent` if *static-padding-stride* is `dynamic_extent` or
+    for any k in the range \[*`rank_`*` - `u` - 1`, *`rank_`*` - 1`)
+    `static_extent(`k`)` is `dynamic_extent`,
+  - otherwise, the product of *static-padding-stride* and all values
+    `static_extent(`k`)` with k in the range \[*`rank_`*` - `u` - 1`,
+    *`rank_`*` - 1`);
+- otherwise,
+  ``` cpp
+  submdspan_mapping_result{layout_stride::mapping(sub_ext, sub_strides), offset}
+  ```
+##### `submdspan` function template <a id="mdspan.sub.sub">[[mdspan.sub.sub]]</a>
+``` cpp
+template<class ElementType, class Extents, class LayoutPolicy,
+         class AccessorPolicy, class... SliceSpecifiers>
+  constexpr auto submdspan(
+    const mdspan<ElementType, Extents, LayoutPolicy, AccessorPolicy>& src,
+    SliceSpecifiers... slices) -> see below;
+```
+Let `index_type` be `typename Extents::index_type`.
+Let `sub_map_offset` be the result of
+`submdspan_mapping(src.mapping(), slices...)`.
+[*Note 1*: This invocation of `submdspan_mapping` selects a function
+call via overload resolution on a candidate set that includes the lookup
+set found by argument-dependent
+lookup [[basic.lookup.argdep]]. — *end note*]
+*Constraints:*
+- `sizeof...(slices)` equals `Extents::rank()`, and
+- the expression `submdspan_mapping(src.mapping(), slices...)` is
+  well-formed when treated as an unevaluated operand.
+*Mandates:*
+- `decltype(submdspan_mapping(src.mapping(), slices...))` is a
+  specialization of `submd-span_mapping_result`.
+- `is_same_v<remove_cvref_t<decltype(sub_map_offset.mapping.extents())>,`
+  `decltype(submdspan_extents(src.mapping(), slices...))>` is `true`.
+- For each rank index k of `src.extents()`, exactly one of the following
+  is true:
+  - Sₖ models `convertible_to<index_type>`,
+  - Sₖ models `index-pair-like<index_type>`,
+  - `is_convertible_v<`Sₖ`, full_extent_t>` is `true`, or
+  - Sₖ is a specialization of `strided_slice`.
+*Preconditions:*
+- For each rank index k of `src.extents()`, all of the following are
+  `true`:
+  - if Sₖ is a specialization of `strided_slice`
+    - `$s_k$.extent` = 0, or
+    - `$s_k$.stride` > 0
+  - $0 \le \texttt{\textit{first_}<index_type, $k$>(slices...)}$
+    $\le \texttt{\textit{last_}<$k$>(src.extents(), slices...)}$
+    ≤ `{}src.extent($k$)`
+- `sub_map_offset.mapping.extents() == submdspan_extents(src.mapping(), slices...)`
+  is `true`; and
+- for each integer pack `I` which is a multidimensional index in
+  `sub_map_offset.mapping.extents()`,
+  ``` cpp
+  sub_map_offset.mapping(I...) + sub_map_offset.offset ==
+    src.mapping()(src-indices(array{I...}, slices...))
+  ```
+  is `true`.
+[*Note 2*: These conditions ensure that the mapping returned by
+`submdspan_mapping` matches the algorithmically expected index-mapping
+given the slice specifiers. — *end note*]
+*Effects:* Equivalent to:
+``` cpp
+auto sub_map_result = submdspan_mapping(src.mapping(), slices...);
+return mdspan(src.accessor().offset(src.data_handle(), sub_map_result.offset),
+              sub_map_result.mapping,
+              typename AccessorPolicy::offset_policy(src.accessor()));
+```
+[*Example 1*:
+Given a rank-3 `mdspan grid3d` representing a three-dimensional grid of
+regularly spaced points in a rectangular prism, the function
+`zero_surface` sets all elements on the surface of the 3-dimensional
+shape to zero. It does so by reusing a function `zero_2d` that takes a
+rank-2 `mdspan`.
+``` cpp
+// zero out all elements in an mdspan
+template<class T, class E, class L, class A>
+void zero_2d(mdspan<T, E, L, A> a) {
+  static_assert(a.rank() == 2);
+  for (int i = 0; i < a.extent(0); i++)
+    for (int j = 0; j < a.extent(1); j++)
+      a[i, j] = 0;
+}
+// zero out just the surface
+template<class T, class E, class L, class A>
+void zero_surface(mdspan<T, E, L, A> grid3d) {
+  static_assert(grid3d.rank() == 3);
+  zero_2d(submdspan(grid3d, 0, full_extent, full_extent));
+  zero_2d(submdspan(grid3d, full_extent, 0, full_extent));
+  zero_2d(submdspan(grid3d, full_extent, full_extent, 0));
+  zero_2d(submdspan(grid3d, grid3d.extent(0) - 1, full_extent, full_extent));
+  zero_2d(submdspan(grid3d, full_extent, grid3d.extent(1) - 1, full_extent));
+  zero_2d(submdspan(grid3d, full_extent, full_extent, grid3d.extent(2) - 1));
+}
+```
+— *end example*]
 <!-- 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
 [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.lookup.argdep]: basic.md#basic.lookup.argdep
 [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.insert.return]: #container.insert.return
+[container.intro.reqmts]: #container.intro.reqmts
 [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
 [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.cons.alloc]: #flat.map.cons.alloc
 [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.cons.alloc]: #flat.multimap.cons.alloc
 [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.cons.alloc]: #flat.multiset.cons.alloc
 [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.cons.alloc]: #flat.set.cons.alloc
 [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.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
+[hive]: #hive
+[hive.capacity]: #hive.capacity
+[hive.cons]: #hive.cons
+[hive.erasure]: #hive.erasure
+[hive.modifiers]: #hive.modifiers
+[hive.operations]: #hive.operations
+[hive.overview]: #hive.overview
+[hive.syn]: #hive.syn
+[inplace.vector]: #inplace.vector
+[inplace.vector.capacity]: #inplace.vector.capacity
+[inplace.vector.cons]: #inplace.vector.cons
+[inplace.vector.data]: #inplace.vector.data
+[inplace.vector.erasure]: #inplace.vector.erasure
+[inplace.vector.modifiers]: #inplace.vector.modifiers
+[inplace.vector.overview]: #inplace.vector.overview
+[inplace.vector.syn]: #inplace.vector.syn
 [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
 [map.cons]: #map.cons
 [map.erasure]: #map.erasure
 [map.modifiers]: #map.modifiers
 [map.overview]: #map.overview
 [mdspan.accessor]: #mdspan.accessor
+[mdspan.accessor.aligned]: #mdspan.accessor.aligned
+[mdspan.accessor.aligned.members]: #mdspan.accessor.aligned.members
+[mdspan.accessor.aligned.overview]: #mdspan.accessor.aligned.overview
 [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.dims]: #mdspan.extents.dims
 [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.leftpad]: #mdspan.layout.leftpad
+[mdspan.layout.leftpad.cons]: #mdspan.layout.leftpad.cons
+[mdspan.layout.leftpad.expo]: #mdspan.layout.leftpad.expo
+[mdspan.layout.leftpad.obs]: #mdspan.layout.leftpad.obs
+[mdspan.layout.leftpad.overview]: #mdspan.layout.leftpad.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.rightpad]: #mdspan.layout.rightpad
+[mdspan.layout.rightpad.cons]: #mdspan.layout.rightpad.cons
+[mdspan.layout.rightpad.expo]: #mdspan.layout.rightpad.expo
+[mdspan.layout.rightpad.obs]: #mdspan.layout.rightpad.obs
+[mdspan.layout.rightpad.overview]: #mdspan.layout.rightpad.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.sub]: #mdspan.sub
+[mdspan.sub.extents]: #mdspan.sub.extents
+[mdspan.sub.helpers]: #mdspan.sub.helpers
+[mdspan.sub.map]: #mdspan.sub.map
+[mdspan.sub.map.common]: #mdspan.sub.map.common
+[mdspan.sub.map.left]: #mdspan.sub.map.left
+[mdspan.sub.map.leftpad]: #mdspan.sub.map.leftpad
+[mdspan.sub.map.result]: #mdspan.sub.map.result
+[mdspan.sub.map.right]: #mdspan.sub.map.right
+[mdspan.sub.map.rightpad]: #mdspan.sub.map.rightpad
+[mdspan.sub.map.stride]: #mdspan.sub.map.stride
+[mdspan.sub.overview]: #mdspan.sub.overview
+[mdspan.sub.strided.slice]: #mdspan.sub.strided.slice
+[mdspan.sub.sub]: #mdspan.sub.sub
 [mdspan.syn]: #mdspan.syn
 [multimap]: #multimap
 [multimap.cons]: #multimap.cons
 [multimap.erasure]: #multimap.erasure
 [multimap.modifiers]: #multimap.modifiers
 [queue.mod]: #queue.mod
 [queue.ops]: #queue.ops
 [queue.special]: #queue.special
 [queue.syn]: #queue.syn
 [random.access.iterators]: iterators.md#random.access.iterators
+[re.results]: text.md#re.results
 [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.modifiers]: #set.modifiers
 [set.overview]: #set.overview
 [span.cons]: #span.cons
 [span.deduct]: #span.deduct
 [span.elem]: #span.elem
 [span.iterators]: #span.iterators
 [stack.general]: #stack.general
 [stack.mod]: #stack.mod
 [stack.ops]: #stack.ops
 [stack.special]: #stack.special
 [stack.syn]: #stack.syn
+[stacktrace.basic]: diagnostics.md#stacktrace.basic
 [strings]: strings.md#strings
 [swappable.requirements]: library.md#swappable.requirements
 [temp.deduct]: temp.md#temp.deduct
 [temp.type]: temp.md#temp.type
+[term.structural.type]: temp.md#term.structural.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.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.modifiers]: #unord.set.modifiers
 [unord.set.overview]: #unord.set.overview
 [unord.set.syn]: #unord.set.syn
 [vector]: #vector
 [vector.bool]: #vector.bool
 [vector.bool.fmt]: #vector.bool.fmt

Diff to HTML by rtfpessoa