diff --git a/source/meta.tex b/source/meta.tex
index e848e048f8..e4a91fde5c 100644
--- a/source/meta.tex
+++ b/source/meta.tex
@@ -651,201 +651,206 @@
 \rSec2[const.wrap.class]{Class template \tcode{constant_wrapper}}
 
 \begin{codeblock}
-template<class T>
-struct @\exposidnc{cw-fixed-value}@ {                                                         // \expos
-  using @\exposidnc{type}@ = T;                                                               // \expos
-  constexpr @\exposidnc{cw-fixed-value}@(@\exposidnc{type}@ v) noexcept : @\exposidnc{data}@(v) {}
-  T @\exposidnc{data}@;                                                                       // \expos
-};
+namespace std {
+  template<class T>
+  struct @\exposidnc{cw-fixed-value}@ {                                                         // \expos
+    using @\exposidnc{type}@ = T;                                                               // \expos
+    constexpr @\exposidnc{cw-fixed-value}@(@\exposidnc{type}@ v) noexcept : @\exposidnc{data}@(v) {}
+    T @\exposidnc{data}@;                                                                       // \expos
+  };
 
-template<class T, size_t Extent>
-struct @\exposidnc{cw-fixed-value}@<T[Extent]> {                                              // \expos
-  using @\exposidnc{type}@ = T[Extent];                                                       // \expos
-  constexpr @\exposidnc{cw-fixed-value}@(T (&arr)[Extent]) noexcept;
-  T @\exposidnc{data}@[Extent];                                                               // \expos
-};
+  template<class T, size_t Extent>
+  struct @\exposidnc{cw-fixed-value}@<T[Extent]> {                                              // \expos
+    using @\exposidnc{type}@ = T[Extent];                                                       // \expos
+    constexpr @\exposidnc{cw-fixed-value}@(T (&arr)[Extent]) noexcept;
+    T @\exposidnc{data}@[Extent];                                                               // \expos
+  };
 
-template<class T, size_t Extent>
-  @\exposidnc{cw-fixed-value}@(T (&)[Extent]) -> @\exposidnc{cw-fixed-value}@<T[Extent]>;                   // \expos
-
-struct @\exposidnc{cw-operators}@ {                                                           // \expos
-  // unary operators
-  template<@\exposconcept{constexpr-param}@ T>
-    friend constexpr auto operator+(T) noexcept -> constant_wrapper<(+T::value)>
-      { return {}; }
-  template<@\exposconcept{constexpr-param}@ T>
-    friend constexpr auto operator-(T) noexcept -> constant_wrapper<(-T::value)>
-      { return {}; }
-  template<@\exposconcept{constexpr-param}@ T>
-    friend constexpr auto operator~(T) noexcept -> constant_wrapper<(~T::value)>
-      { return {}; }
-  template<@\exposconcept{constexpr-param}@ T>
-    friend constexpr auto operator!(T) noexcept -> constant_wrapper<(!T::value)>
-      { return {}; }
-  template<@\exposconcept{constexpr-param}@ T>
-    friend constexpr auto operator&(T) noexcept -> constant_wrapper<(&T::value)>
-      { return {}; }
-  template<@\exposconcept{constexpr-param}@ T>
-    friend constexpr auto operator*(T) noexcept -> constant_wrapper<(*T::value)>
-      { return {}; }
-
-  // binary operators
-  template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>
-    friend constexpr auto operator+(L, R) noexcept -> constant_wrapper<(L::value + R::value)>
-      { return {}; }
-  template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>
-    friend constexpr auto operator-(L, R) noexcept -> constant_wrapper<(L::value - R::value)>
-      { return {}; }
-  template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>
-    friend constexpr auto operator*(L, R) noexcept -> constant_wrapper<(L::value * R::value)>
-      { return {}; }
-  template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>
-    friend constexpr auto operator/(L, R) noexcept -> constant_wrapper<(L::value / R::value)>
-      { return {}; }
-  template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>
-    friend constexpr auto operator%(L, R) noexcept -> constant_wrapper<(L::value % R::value)>
-      { return {}; }
-
-  template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>
-    friend constexpr auto operator<<(L, R) noexcept -> constant_wrapper<(L::value << R::value)>
-      { return {}; }
-  template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>
-    friend constexpr auto operator>>(L, R) noexcept -> constant_wrapper<(L::value >> R::value)>
-      { return {}; }
-  template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>
-    friend constexpr auto operator&(L, R) noexcept -> constant_wrapper<(L::value & R::value)>
-      { return {}; }
-  template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>
-    friend constexpr auto operator|(L, R) noexcept -> constant_wrapper<(L::value | R::value)>
-      { return {}; }
-  template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>
-    friend constexpr auto operator^(L, R) noexcept -> constant_wrapper<(L::value ^ R::value)>
-      { return {}; }
-
-  template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>
-    requires (!is_constructible_v<bool, decltype(L::value)> ||
-              !is_constructible_v<bool, decltype(R::value)>)
-      friend constexpr auto operator&&(L, R) noexcept -> constant_wrapper<(L::value && R::value)>
+  template<class T, size_t Extent>
+    @\exposidnc{cw-fixed-value}@(T (&)[Extent]) -> @\exposidnc{cw-fixed-value}@<T[Extent]>;                   // \expos
+
+  struct @\exposidnc{cw-operators}@ {                                                           // \expos
+    // unary operators
+    template<@\exposconcept{constexpr-param}@ T>
+      friend constexpr auto operator+(T) noexcept -> constant_wrapper<(+T::value)>
+        { return {}; }
+    template<@\exposconcept{constexpr-param}@ T>
+      friend constexpr auto operator-(T) noexcept -> constant_wrapper<(-T::value)>
         { return {}; }
-  template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>
-    requires (!is_constructible_v<bool, decltype(L::value)> ||
-              !is_constructible_v<bool, decltype(R::value)>)
-      friend constexpr auto operator||(L, R) noexcept -> constant_wrapper<(L::value || R::value)>
+    template<@\exposconcept{constexpr-param}@ T>
+      friend constexpr auto operator~(T) noexcept -> constant_wrapper<(~T::value)>
+        { return {}; }
+    template<@\exposconcept{constexpr-param}@ T>
+      friend constexpr auto operator!(T) noexcept -> constant_wrapper<(!T::value)>
+        { return {}; }
+    template<@\exposconcept{constexpr-param}@ T>
+      friend constexpr auto operator&(T) noexcept -> constant_wrapper<(&T::value)>
+        { return {}; }
+    template<@\exposconcept{constexpr-param}@ T>
+      friend constexpr auto operator*(T) noexcept -> constant_wrapper<(*T::value)>
         { return {}; }
 
-  // comparisons
-  template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>
-    friend constexpr auto operator<=>(L, R) noexcept -> constant_wrapper<(L::value <=> R::value)>
-      { return {}; }
-  template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>
-    friend constexpr auto operator<(L, R) noexcept -> constant_wrapper<(L::value < R::value)>
-      { return {}; }
-  template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>
-    friend constexpr auto operator<=(L, R) noexcept -> constant_wrapper<(L::value <= R::value)>
-      { return {}; }
-  template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>
-    friend constexpr auto operator==(L, R) noexcept -> constant_wrapper<(L::value == R::value)>
-      { return {}; }
-  template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>
-    friend constexpr auto operator!=(L, R) noexcept -> constant_wrapper<(L::value != R::value)>
-      { return {}; }
-  template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>
-    friend constexpr auto operator>(L, R) noexcept -> constant_wrapper<(L::value > R::value)>
-      { return {}; }
-  template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>
-    friend constexpr auto operator>=(L, R) noexcept -> constant_wrapper<(L::value >= R::value)>
-      { return {}; }
-
-  template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>
-    friend constexpr auto operator,(L, R) noexcept = delete;
-  template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>
-    friend constexpr auto operator->*(L, R) noexcept -> constant_wrapper<L::value->*(R::value)>
-      { return {}; }
-
-  // call and index
-  template<@\exposconcept{constexpr-param}@ T, @\exposconcept{constexpr-param}@... Args>
-    constexpr auto operator()(this T, Args...) noexcept
-      requires requires(Args...) { constant_wrapper<T::value(Args::value...)>(); }
-        { return constant_wrapper<T::value(Args::value...)>{}; }
-  template<@\exposconcept{constexpr-param}@ T, @\exposconcept{constexpr-param}@... Args>
-    constexpr auto operator[](this T, Args...) noexcept
-      -> constant_wrapper<(T::value[Args::value...])>
+    // binary operators
+    template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>
+      friend constexpr auto operator+(L, R) noexcept -> constant_wrapper<(L::value + R::value)>
+        { return {}; }
+    template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>
+      friend constexpr auto operator-(L, R) noexcept -> constant_wrapper<(L::value - R::value)>
+        { return {}; }
+    template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>
+      friend constexpr auto operator*(L, R) noexcept -> constant_wrapper<(L::value * R::value)>
+        { return {}; }
+    template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>
+      friend constexpr auto operator/(L, R) noexcept -> constant_wrapper<(L::value / R::value)>
+        { return {}; }
+    template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>
+      friend constexpr auto operator%(L, R) noexcept -> constant_wrapper<(L::value % R::value)>
         { return {}; }
 
-  // pseudo-mutators
-  template<@\exposconcept{constexpr-param}@ T>
-    constexpr auto operator++(this T) noexcept
-      requires requires(T::value_type x) { ++x; }
-        { return constant_wrapper<[] { auto c = T::value; return ++c; }()>{}; }
-  template<@\exposconcept{constexpr-param}@ T>
-    constexpr auto operator++(this T, int) noexcept
-      requires requires(T::value_type x) { x++; }
-        { return constant_wrapper<[] { auto c = T::value; return c++; }()>{}; }
-
-  template<@\exposconcept{constexpr-param}@ T>
-    constexpr auto operator--(this T) noexcept
-      requires requires(T::value_type x) { --x; }
-        { return constant_wrapper<[] { auto c = T::value; return --c; }()>{}; }
-  template<@\exposconcept{constexpr-param}@ T>
-    constexpr auto operator--(this T, int) noexcept
-      requires requires(T::value_type x) { x--; }
-        { return constant_wrapper<[] { auto c = T::value; return c--; }()>{}; }
-
-  template<@\exposconcept{constexpr-param}@ T, @\exposconcept{constexpr-param}@ R>
-    constexpr auto operator+=(this T, R) noexcept
-      requires requires(T::value_type x) { x += R::value; }
-        { return constant_wrapper<[] { auto v = T::value; return v += R::value; }()>{}; }
-  template<@\exposconcept{constexpr-param}@ T, @\exposconcept{constexpr-param}@ R>
-    constexpr auto operator-=(this T, R) noexcept
-      requires requires(T::value_type x) { x -= R::value; }
-        { return constant_wrapper<[] { auto v = T::value; return v -= R::value; }()>{}; }
-  template<@\exposconcept{constexpr-param}@ T, @\exposconcept{constexpr-param}@ R>
-    constexpr auto operator*=(this T, R) noexcept
-      requires requires(T::value_type x) { x *= R::value; }
-        { return constant_wrapper<[] { auto v = T::value; return v *= R::value; }()>{}; }
-  template<@\exposconcept{constexpr-param}@ T, @\exposconcept{constexpr-param}@ R>
-    constexpr auto operator/=(this T, R) noexcept
-      requires requires(T::value_type x) { x /= R::value; }
-        { return constant_wrapper<[] { auto v = T::value; return v /= R::value; }()>{}; }
-  template<@\exposconcept{constexpr-param}@ T, @\exposconcept{constexpr-param}@ R>
-    constexpr auto operator%=(this T, R) noexcept
-      requires requires(T::value_type x) { x %= R::value; }
-        { return constant_wrapper<[] { auto v = T::value; return v %= R::value; }()>{}; }
-  template<@\exposconcept{constexpr-param}@ T, @\exposconcept{constexpr-param}@ R>
-    constexpr auto operator&=(this T, R) noexcept
-      requires requires(T::value_type x) { x &= R::value; }
-        { return constant_wrapper<[] { auto v = T::value; return v &= R::value; }()>{}; }
-  template<@\exposconcept{constexpr-param}@ T, @\exposconcept{constexpr-param}@ R>
-    constexpr auto operator|=(this T, R) noexcept
-      requires requires(T::value_type x) { x |= R::value; }
-        { return constant_wrapper<[] { auto v = T::value; return v |= R::value; }()>{}; }
-  template<@\exposconcept{constexpr-param}@ T, @\exposconcept{constexpr-param}@ R>
-    constexpr auto operator^=(this T, R) noexcept
-      requires requires(T::value_type x) { x ^= R::value; }
-        { return constant_wrapper<[] { auto v = T::value; return v ^= R::value; }()>{}; }
-  template<@\exposconcept{constexpr-param}@ T, @\exposconcept{constexpr-param}@ R>
-    constexpr auto operator<<=(this T, R) noexcept
-      requires requires(T::value_type x) { x <<= R::value; }
-        { return constant_wrapper<[] { auto v = T::value; return v <<= R::value; }()>{}; }
-  template<@\exposconcept{constexpr-param}@ T, @\exposconcept{constexpr-param}@ R>
-    constexpr auto operator>>=(this T, R) noexcept
-      requires requires(T::value_type x) { x >>= R::value; }
-        { return constant_wrapper<[] { auto v = T::value; return v >>= R::value; }()>{}; }
-};
+    template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>
+      friend constexpr auto operator<<(L, R) noexcept -> constant_wrapper<(L::value << R::value)>
+        { return {}; }
+    template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>
+      friend constexpr auto operator>>(L, R) noexcept -> constant_wrapper<(L::value >> R::value)>
+        { return {}; }
+    template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>
+      friend constexpr auto operator&(L, R) noexcept -> constant_wrapper<(L::value & R::value)>
+        { return {}; }
+    template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>
+      friend constexpr auto operator|(L, R) noexcept -> constant_wrapper<(L::value | R::value)>
+        { return {}; }
+    template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>
+      friend constexpr auto operator^(L, R) noexcept -> constant_wrapper<(L::value ^ R::value)>
+        { return {}; }
+
+    template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>
+      requires (!is_constructible_v<bool, decltype(L::value)> ||
+                !is_constructible_v<bool, decltype(R::value)>)
+        friend constexpr auto operator&&(L, R) noexcept
+          -> constant_wrapper<(L::value && R::value)>
+            { return {}; }
+    template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>
+      requires (!is_constructible_v<bool, decltype(L::value)> ||
+                !is_constructible_v<bool, decltype(R::value)>)
+        friend constexpr auto operator||(L, R) noexcept
+          -> constant_wrapper<(L::value || R::value)>
+            { return {}; }
+
+    // comparisons
+    template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>
+      friend constexpr auto operator<=>(L, R) noexcept
+        -> constant_wrapper<(L::value <=> R::value)>
+          { return {}; }
+    template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>
+      friend constexpr auto operator<(L, R) noexcept -> constant_wrapper<(L::value < R::value)>
+        { return {}; }
+    template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>
+      friend constexpr auto operator<=(L, R) noexcept -> constant_wrapper<(L::value <= R::value)>
+        { return {}; }
+    template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>
+      friend constexpr auto operator==(L, R) noexcept -> constant_wrapper<(L::value == R::value)>
+        { return {}; }
+    template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>
+      friend constexpr auto operator!=(L, R) noexcept -> constant_wrapper<(L::value != R::value)>
+        { return {}; }
+    template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>
+      friend constexpr auto operator>(L, R) noexcept -> constant_wrapper<(L::value > R::value)>
+        { return {}; }
+    template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>
+      friend constexpr auto operator>=(L, R) noexcept -> constant_wrapper<(L::value >= R::value)>
+        { return {}; }
 
-template<@\exposid{cw-fixed-value}@ X, class>
-struct constant_wrapper : cw-operators {
-  static constexpr const auto & value = X.@\exposid{data}@;
-  using type = constant_wrapper;
-  using value_type = typename decltype(X)::@\exposid{type}@;
+    template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>
+      friend constexpr auto operator,(L, R) noexcept = delete;
+    template<@\exposconcept{constexpr-param}@ L, @\exposconcept{constexpr-param}@ R>
+      friend constexpr auto operator->*(L, R) noexcept -> constant_wrapper<L::value->*(R::value)>
+        { return {}; }
 
-  template<@\exposconcept{constexpr-param}@ R>
-    constexpr auto operator=(R) const noexcept
-      requires requires(value_type x) { x = R::value; }
-        { return constant_wrapper<[] { auto v = value; return v = R::value; }()>{}; }
+    // call and index
+    template<@\exposconcept{constexpr-param}@ T, @\exposconcept{constexpr-param}@... Args>
+      constexpr auto operator()(this T, Args...) noexcept
+        requires requires(Args...) { constant_wrapper<T::value(Args::value...)>(); }
+          { return constant_wrapper<T::value(Args::value...)>{}; }
+    template<@\exposconcept{constexpr-param}@ T, @\exposconcept{constexpr-param}@... Args>
+      constexpr auto operator[](this T, Args...) noexcept
+        -> constant_wrapper<(T::value[Args::value...])>
+          { return {}; }
+
+    // pseudo-mutators
+    template<@\exposconcept{constexpr-param}@ T>
+      constexpr auto operator++(this T) noexcept
+        requires requires(T::value_type x) { ++x; }
+          { return constant_wrapper<[] { auto c = T::value; return ++c; }()>{}; }
+    template<@\exposconcept{constexpr-param}@ T>
+      constexpr auto operator++(this T, int) noexcept
+        requires requires(T::value_type x) { x++; }
+          { return constant_wrapper<[] { auto c = T::value; return c++; }()>{}; }
+
+    template<@\exposconcept{constexpr-param}@ T>
+      constexpr auto operator--(this T) noexcept
+        requires requires(T::value_type x) { --x; }
+          { return constant_wrapper<[] { auto c = T::value; return --c; }()>{}; }
+    template<@\exposconcept{constexpr-param}@ T>
+      constexpr auto operator--(this T, int) noexcept
+        requires requires(T::value_type x) { x--; }
+          { return constant_wrapper<[] { auto c = T::value; return c--; }()>{}; }
+
+    template<@\exposconcept{constexpr-param}@ T, @\exposconcept{constexpr-param}@ R>
+      constexpr auto operator+=(this T, R) noexcept
+        requires requires(T::value_type x) { x += R::value; }
+          { return constant_wrapper<[] { auto v = T::value; return v += R::value; }()>{}; }
+    template<@\exposconcept{constexpr-param}@ T, @\exposconcept{constexpr-param}@ R>
+      constexpr auto operator-=(this T, R) noexcept
+        requires requires(T::value_type x) { x -= R::value; }
+          { return constant_wrapper<[] { auto v = T::value; return v -= R::value; }()>{}; }
+    template<@\exposconcept{constexpr-param}@ T, @\exposconcept{constexpr-param}@ R>
+      constexpr auto operator*=(this T, R) noexcept
+        requires requires(T::value_type x) { x *= R::value; }
+          { return constant_wrapper<[] { auto v = T::value; return v *= R::value; }()>{}; }
+    template<@\exposconcept{constexpr-param}@ T, @\exposconcept{constexpr-param}@ R>
+      constexpr auto operator/=(this T, R) noexcept
+        requires requires(T::value_type x) { x /= R::value; }
+          { return constant_wrapper<[] { auto v = T::value; return v /= R::value; }()>{}; }
+    template<@\exposconcept{constexpr-param}@ T, @\exposconcept{constexpr-param}@ R>
+      constexpr auto operator%=(this T, R) noexcept
+        requires requires(T::value_type x) { x %= R::value; }
+          { return constant_wrapper<[] { auto v = T::value; return v %= R::value; }()>{}; }
+    template<@\exposconcept{constexpr-param}@ T, @\exposconcept{constexpr-param}@ R>
+      constexpr auto operator&=(this T, R) noexcept
+        requires requires(T::value_type x) { x &= R::value; }
+          { return constant_wrapper<[] { auto v = T::value; return v &= R::value; }()>{}; }
+    template<@\exposconcept{constexpr-param}@ T, @\exposconcept{constexpr-param}@ R>
+      constexpr auto operator|=(this T, R) noexcept
+        requires requires(T::value_type x) { x |= R::value; }
+          { return constant_wrapper<[] { auto v = T::value; return v |= R::value; }()>{}; }
+    template<@\exposconcept{constexpr-param}@ T, @\exposconcept{constexpr-param}@ R>
+      constexpr auto operator^=(this T, R) noexcept
+        requires requires(T::value_type x) { x ^= R::value; }
+          { return constant_wrapper<[] { auto v = T::value; return v ^= R::value; }()>{}; }
+    template<@\exposconcept{constexpr-param}@ T, @\exposconcept{constexpr-param}@ R>
+      constexpr auto operator<<=(this T, R) noexcept
+        requires requires(T::value_type x) { x <<= R::value; }
+          { return constant_wrapper<[] { auto v = T::value; return v <<= R::value; }()>{}; }
+    template<@\exposconcept{constexpr-param}@ T, @\exposconcept{constexpr-param}@ R>
+      constexpr auto operator>>=(this T, R) noexcept
+        requires requires(T::value_type x) { x >>= R::value; }
+          { return constant_wrapper<[] { auto v = T::value; return v >>= R::value; }()>{}; }
+  };
 
-  constexpr operator decltype(auto)() const noexcept { return value; }
-};
+  template<@\exposid{cw-fixed-value}@ X, class>
+  struct constant_wrapper : cw-operators {
+    static constexpr const auto & value = X.@\exposid{data}@;
+    using type = constant_wrapper;
+    using value_type = typename decltype(X)::@\exposid{type}@;
+
+    template<@\exposconcept{constexpr-param}@ R>
+      constexpr auto operator=(R) const noexcept
+        requires requires(value_type x) { x = R::value; }
+          { return constant_wrapper<[] { auto v = value; return v = R::value; }()>{}; }
+
+    constexpr operator decltype(auto)() const noexcept { return value; }
+  };
+}
 \end{codeblock}
 
 \pnum