[mdspan.layout] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpeybii2hx/{from.md → to.md} +1074 -28

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

@@ -1,11 +1,10 @@
 #### 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]].
@@ -14,19 +13,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
@@ -150,20 +174,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()
@@ -172,11 +200,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()
@@ -185,11 +213,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>
@@ -214,15 +242,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>
@@ -233,13 +273,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;
@@ -248,10 +288,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;
@@ -277,10 +321,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
@@ -318,11 +373,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:*
@@ -334,10 +389,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);
 ```
@@ -389,11 +478,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`.
@@ -420,13 +509,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;
@@ -435,10 +524,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;
@@ -464,10 +557,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
@@ -521,10 +625,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;
 ```
@@ -544,11 +684,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
@@ -607,13 +747,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
@@ -654,10 +794,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
@@ -676,11 +827,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
@@ -748,11 +903,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
@@ -780,11 +936,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`.
@@ -796,13 +952,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
@@ -867,5 +1025,893 @@ 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`.

 #### 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`.

Diff to HTML by rtfpessoa