From 4ed491f97faca05de19b6ae5fe1d68ecba226180 Mon Sep 17 00:00:00 2001
From: Barry Revzin <barry.revzin@gmail.com>
Date: Thu, 15 Feb 2024 08:20:14 -0600
Subject: [PATCH] Adding named tuple example

---
 2996_reflection/p2996r2.html  | 1769 +++++++++++++++++----------------
 2996_reflection/reflection.md |   46 +
 2 files changed, 950 insertions(+), 865 deletions(-)

diff --git a/2996_reflection/p2996r2.html b/2996_reflection/p2996r2.html
index 6ef6e2e7..da875a66 100644
--- a/2996_reflection/p2996r2.html
+++ b/2996_reflection/p2996r2.html
@@ -4,7 +4,7 @@
   <meta charset="utf-8" />
   <meta name="generator" content="mpark/wg21" />
   <meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes" />
-  <meta name="dcterms.date" content="2024-02-14" />
+  <meta name="dcterms.date" content="2024-02-15" />
   <title>Reflection for C++26</title>
   <style>
       code{white-space: pre-wrap;}
@@ -538,7 +538,7 @@ <h1 class="title" style="text-align:center">Reflection for C++26</h1>
   </tr>
   <tr>
     <td>Date:</td>
-    <td>2024-02-14</td>
+    <td>2024-02-15</td>
   </tr>
   <tr>
     <td style="vertical-align:top">Project:</td>
@@ -592,8 +592,9 @@ <h1 id="toctitle">Contents</h1>
 <li><a href="#a-universal-formatter"><span class="toc-section-number">3.12</span> A Universal Formatter<span></span></a></li>
 <li><a href="#implementing-member-wise-hash_append"><span class="toc-section-number">3.13</span> Implementing member-wise <code class="sourceCode cpp">hash_append</code><span></span></a></li>
 <li><a href="#converting-a-struct-to-a-tuple"><span class="toc-section-number">3.14</span> Converting a Struct to a Tuple<span></span></a></li>
-<li><a href="#compile-time-ticket-counter"><span class="toc-section-number">3.15</span> Compile-Time Ticket Counter<span></span></a></li>
-<li><a href="#emulating-typeful-reflection"><span class="toc-section-number">3.16</span> Emulating typeful reflection<span></span></a></li>
+<li><a href="#named-tuple"><span class="toc-section-number">3.15</span> Named Tuple<span></span></a></li>
+<li><a href="#compile-time-ticket-counter"><span class="toc-section-number">3.16</span> Compile-Time Ticket Counter<span></span></a></li>
+<li><a href="#emulating-typeful-reflection"><span class="toc-section-number">3.17</span> Emulating typeful reflection<span></span></a></li>
 </ul></li>
 <li><a href="#proposed-features"><span class="toc-section-number">4</span> Proposed Features<span></span></a>
 <ul>
@@ -1488,104 +1489,142 @@ <h2 data-number="3.14" id="converting-a-struct-to-a-tuple"><span class="header-s
 <p>Here, <code class="sourceCode cpp">struct_to_tuple_type</code> takes a reflection of a type like <code class="sourceCode cpp"><span class="kw">struct</span> <span class="op">{</span> T t; U <span class="kw">const</span><span class="op">&amp;</span> u; V v; <span class="op">}</span></code> and returns a reflection of the type <code class="sourceCode cpp">std<span class="op">::</span>tuple<span class="op">&lt;</span>T, U, V<span class="op">&gt;</span></code>. That gives us the return type. Then, <code class="sourceCode cpp">struct_to_tuple_helper</code> is a function template that does the actual conversion — which it can do by having all the reflections of the members as a non-type template parameter pack. This is a <code class="sourceCode cpp"><span class="kw">constexpr</span></code> function and not a <code class="sourceCode cpp"><span class="kw">consteval</span></code> function because in the general case the conversion is a run-time operation. However, determining the instance of <code class="sourceCode cpp">struct_to_tuple_helper</code> that is needed is a compile-time operation and has to be performed with a <code class="sourceCode cpp"><span class="kw">consteval</span></code> function (because the function invokes <code class="sourceCode cpp">nonstatic_data_members_of</code>), hence the separate function template <code class="sourceCode cpp">get_struct_to_tuple_helper<span class="op">()</span></code>.</p>
 <p>Everything is put together by using <code class="sourceCode cpp">substitute</code> to create the instantiation of <code class="sourceCode cpp">struct_to_tuple_helper</code> that we need, and a compile-time reference to that instance is obtained with <code class="sourceCode cpp">value_of</code>. Thus <code class="sourceCode cpp">f</code> is a function reference to the correct specialization of <code class="sourceCode cpp">struct_to_tuple_helper</code>, which we can simply invoke.</p>
 <p><a href="https://godbolt.org/z/Moqf84nc1">On Compiler Explorer</a>, with a different implementation than either of the above.</p>
-<h2 data-number="3.15" id="compile-time-ticket-counter"><span class="header-section-number">3.15</span> Compile-Time Ticket Counter<a href="#compile-time-ticket-counter" class="self-link"></a></h2>
+<h2 data-number="3.15" id="named-tuple"><span class="header-section-number">3.15</span> Named Tuple<a href="#named-tuple" class="self-link"></a></h2>
+<p>The tricky thing with implementing a named tuple is actually strings as non-type template parameters. Because you cannot just pass <code class="sourceCode cpp"><span class="st">&quot;x&quot;</span></code> into a non-type template parameter of the form <code class="sourceCode cpp"><span class="kw">auto</span> V</code>, that leaves us with two ways of specifying the constituents:</p>
+<ol type="1">
+<li>Can introduce a <code class="sourceCode cpp">pair</code> type so that we can write <code class="sourceCode cpp">make_named_tuple<span class="op">&lt;</span>pair<span class="op">&lt;</span><span class="dt">int</span>, <span class="st">&quot;x&quot;</span><span class="op">&gt;</span>, pair<span class="op">&lt;</span><span class="dt">double</span>, <span class="st">&quot;y&quot;</span><span class="op">&gt;&gt;()</span></code>, or</li>
+<li>Can just do reflections all the way down so that we can write <code class="sourceCode cpp">make_named_tuple<span class="op">&lt;^</span><span class="dt">int</span>, <span class="op">^</span><span class="st">&quot;x&quot;</span>, <span class="op">^</span><span class="dt">double</span>, <span class="op">^</span><span class="st">&quot;y&quot;</span><span class="op">&gt;()</span></code>.</li>
+</ol>
+<p>We do not currently support splicing string literals (although that may change in the next revision), and the <code class="sourceCode cpp">pair</code> approach follows the similar pattern already shown with <code class="sourceCode cpp">define_class</code> (given a suitable <code class="sourceCode cpp">fixed_string</code> type):</p>
+<blockquote>
+<div class="sourceCode" id="cb31"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb31-1"><a href="#cb31-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">class</span> T, fixed_string Name<span class="op">&gt;</span></span>
+<span id="cb31-2"><a href="#cb31-2"></a><span class="kw">struct</span> pair <span class="op">{</span></span>
+<span id="cb31-3"><a href="#cb31-3"></a>    <span class="kw">static</span> <span class="kw">constexpr</span> <span class="kw">auto</span> name<span class="op">()</span> <span class="op">-&gt;</span> std<span class="op">::</span>string_view <span class="op">{</span> <span class="cf">return</span> Name<span class="op">.</span>view<span class="op">()</span>; <span class="op">}</span></span>
+<span id="cb31-4"><a href="#cb31-4"></a>    <span class="kw">using</span> type <span class="op">=</span> T;</span>
+<span id="cb31-5"><a href="#cb31-5"></a><span class="op">}</span>;</span>
+<span id="cb31-6"><a href="#cb31-6"></a></span>
+<span id="cb31-7"><a href="#cb31-7"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">class</span><span class="op">...</span> Tags<span class="op">&gt;</span></span>
+<span id="cb31-8"><a href="#cb31-8"></a><span class="kw">consteval</span> <span class="kw">auto</span> make_named_tuple<span class="op">(</span>std<span class="op">::</span>meta<span class="op">::</span>info type, Tags<span class="op">...</span> tags<span class="op">)</span> <span class="op">{</span></span>
+<span id="cb31-9"><a href="#cb31-9"></a>    std<span class="op">::</span>vector<span class="op">&lt;</span>std<span class="op">::</span>meta<span class="op">::</span>nsdm_description<span class="op">&gt;</span> nsdms;</span>
+<span id="cb31-10"><a href="#cb31-10"></a>    <span class="kw">auto</span> f <span class="op">=</span> <span class="op">[&amp;]&lt;</span><span class="kw">class</span> Tag<span class="op">&gt;(</span>Tag tag<span class="op">){</span></span>
+<span id="cb31-11"><a href="#cb31-11"></a>        nsdms<span class="op">.</span>push_back<span class="op">(</span>std<span class="op">::</span>meta<span class="op">::</span>nsdm_description<span class="op">(</span></span>
+<span id="cb31-12"><a href="#cb31-12"></a>            dealias<span class="op">(^</span>Tag<span class="op">::</span>type<span class="op">)</span>,</span>
+<span id="cb31-13"><a href="#cb31-13"></a>            <span class="op">{.</span>name<span class="op">=</span>Tag<span class="op">::</span>name<span class="op">()}))</span>;</span>
+<span id="cb31-14"><a href="#cb31-14"></a></span>
+<span id="cb31-15"><a href="#cb31-15"></a>    <span class="op">}</span>;</span>
+<span id="cb31-16"><a href="#cb31-16"></a>    <span class="op">(</span>f<span class="op">(</span>tags<span class="op">)</span>, <span class="op">...)</span>;</span>
+<span id="cb31-17"><a href="#cb31-17"></a>    <span class="cf">return</span> define_class<span class="op">(</span>type, nsdms<span class="op">)</span>;</span>
+<span id="cb31-18"><a href="#cb31-18"></a><span class="op">}</span></span>
+<span id="cb31-19"><a href="#cb31-19"></a></span>
+<span id="cb31-20"><a href="#cb31-20"></a><span class="kw">struct</span> R;</span>
+<span id="cb31-21"><a href="#cb31-21"></a><span class="kw">static_assert</span><span class="op">(</span>is_type<span class="op">(</span>make_named_tuple<span class="op">(^</span>R, pair<span class="op">&lt;</span><span class="dt">int</span>, <span class="st">&quot;x&quot;</span><span class="op">&gt;{}</span>, pair<span class="op">&lt;</span><span class="dt">double</span>, <span class="st">&quot;y&quot;</span><span class="op">&gt;())))</span>;</span>
+<span id="cb31-22"><a href="#cb31-22"></a></span>
+<span id="cb31-23"><a href="#cb31-23"></a><span class="kw">static_assert</span><span class="op">(</span>type_of<span class="op">(</span>nonstatic_data_members_of<span class="op">(^</span>R<span class="op">)[</span><span class="dv">0</span><span class="op">])</span> <span class="op">==</span> <span class="op">^</span><span class="dt">int</span><span class="op">)</span>;</span>
+<span id="cb31-24"><a href="#cb31-24"></a><span class="kw">static_assert</span><span class="op">(</span>type_of<span class="op">(</span>nonstatic_data_members_of<span class="op">(^</span>R<span class="op">)[</span><span class="dv">1</span><span class="op">])</span> <span class="op">==</span> <span class="op">^</span><span class="dt">double</span><span class="op">)</span>;</span>
+<span id="cb31-25"><a href="#cb31-25"></a></span>
+<span id="cb31-26"><a href="#cb31-26"></a><span class="dt">int</span> main<span class="op">()</span> <span class="op">{</span></span>
+<span id="cb31-27"><a href="#cb31-27"></a>    <span class="op">[[</span><span class="at">maybe_unused</span><span class="op">]]</span> <span class="kw">auto</span> r <span class="op">=</span> R<span class="op">{.</span>x<span class="op">=</span><span class="dv">1</span>, <span class="op">.</span>y<span class="op">=</span><span class="fl">2.0</span><span class="op">}</span>;</span>
+<span id="cb31-28"><a href="#cb31-28"></a><span class="op">}</span></span></code></pre></div>
+</blockquote>
+<p><a href="https://godbolt.org/z/GKM4947fM">On Compiler Explorer</a>.</p>
+<h2 data-number="3.16" id="compile-time-ticket-counter"><span class="header-section-number">3.16</span> Compile-Time Ticket Counter<a href="#compile-time-ticket-counter" class="self-link"></a></h2>
 <p>The features proposed here make it a little easier to update a ticket counter at compile time. This is not an ideal implementation (we’d prefer direct support for compile-time —– i.e., <code class="sourceCode cpp"><span class="kw">consteval</span></code> — variables), but it shows how compile-time mutable state surfaces in new ways.</p>
 <blockquote>
-<div class="sourceCode" id="cb31"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb31-1"><a href="#cb31-1"></a><span class="kw">class</span> TU_Ticket <span class="op">{</span></span>
-<span id="cb31-2"><a href="#cb31-2"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="dt">int</span> N<span class="op">&gt;</span> <span class="kw">struct</span> Helper <span class="op">{</span></span>
-<span id="cb31-3"><a href="#cb31-3"></a>    <span class="kw">static</span> <span class="kw">constexpr</span> <span class="dt">int</span> value <span class="op">=</span> N;</span>
-<span id="cb31-4"><a href="#cb31-4"></a>  <span class="op">}</span>;</span>
-<span id="cb31-5"><a href="#cb31-5"></a><span class="kw">public</span><span class="op">:</span></span>
-<span id="cb31-6"><a href="#cb31-6"></a>  <span class="kw">static</span> <span class="kw">consteval</span> <span class="dt">int</span> next<span class="op">()</span> <span class="op">{</span></span>
-<span id="cb31-7"><a href="#cb31-7"></a>    <span class="co">// Search for the next incomplete Helper&lt;k&gt;.</span></span>
-<span id="cb31-8"><a href="#cb31-8"></a>    std<span class="op">::</span>meta<span class="op">::</span>info r;</span>
-<span id="cb31-9"><a href="#cb31-9"></a>    <span class="cf">for</span> <span class="op">(</span><span class="dt">int</span> k <span class="op">=</span> <span class="dv">0</span>;; <span class="op">++</span>k<span class="op">)</span> <span class="op">{</span></span>
-<span id="cb31-10"><a href="#cb31-10"></a>      r <span class="op">=</span> substitute<span class="op">(^</span>Helper, <span class="op">{</span> std<span class="op">::</span>meta<span class="op">::</span>reflect_value<span class="op">(</span>k<span class="op">)</span> <span class="op">})</span>;</span>
-<span id="cb31-11"><a href="#cb31-11"></a>      <span class="cf">if</span> <span class="op">(</span>is_incomplete_type<span class="op">(</span>r<span class="op">))</span> <span class="cf">break</span>;</span>
-<span id="cb31-12"><a href="#cb31-12"></a>    <span class="op">}</span></span>
-<span id="cb31-13"><a href="#cb31-13"></a>    <span class="co">// Return the value of its member.  Calling static_data_members_of</span></span>
-<span id="cb31-14"><a href="#cb31-14"></a>    <span class="co">// triggers the instantiation (i.e., completion) of Helper&lt;k&gt;.</span></span>
-<span id="cb31-15"><a href="#cb31-15"></a>    <span class="cf">return</span> value_of<span class="op">&lt;</span><span class="dt">int</span><span class="op">&gt;(</span>static_data_members_of<span class="op">(</span>r<span class="op">)[</span><span class="dv">0</span><span class="op">])</span>;</span>
-<span id="cb31-16"><a href="#cb31-16"></a>  <span class="op">}</span></span>
-<span id="cb31-17"><a href="#cb31-17"></a><span class="op">}</span>;</span>
-<span id="cb31-18"><a href="#cb31-18"></a></span>
-<span id="cb31-19"><a href="#cb31-19"></a><span class="dt">int</span> x <span class="op">=</span> TU_Ticket<span class="op">::</span>next<span class="op">()</span>;  <span class="co">// x initialized to 0.</span></span>
-<span id="cb31-20"><a href="#cb31-20"></a><span class="dt">int</span> y <span class="op">=</span> TU_Ticket<span class="op">::</span>next<span class="op">()</span>;  <span class="co">// y initialized to 1.</span></span>
-<span id="cb31-21"><a href="#cb31-21"></a><span class="dt">int</span> z <span class="op">=</span> TU_Ticket<span class="op">::</span>next<span class="op">()</span>;  <span class="co">// z initialized to 2.</span></span></code></pre></div>
+<div class="sourceCode" id="cb32"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb32-1"><a href="#cb32-1"></a><span class="kw">class</span> TU_Ticket <span class="op">{</span></span>
+<span id="cb32-2"><a href="#cb32-2"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="dt">int</span> N<span class="op">&gt;</span> <span class="kw">struct</span> Helper <span class="op">{</span></span>
+<span id="cb32-3"><a href="#cb32-3"></a>    <span class="kw">static</span> <span class="kw">constexpr</span> <span class="dt">int</span> value <span class="op">=</span> N;</span>
+<span id="cb32-4"><a href="#cb32-4"></a>  <span class="op">}</span>;</span>
+<span id="cb32-5"><a href="#cb32-5"></a><span class="kw">public</span><span class="op">:</span></span>
+<span id="cb32-6"><a href="#cb32-6"></a>  <span class="kw">static</span> <span class="kw">consteval</span> <span class="dt">int</span> next<span class="op">()</span> <span class="op">{</span></span>
+<span id="cb32-7"><a href="#cb32-7"></a>    <span class="co">// Search for the next incomplete Helper&lt;k&gt;.</span></span>
+<span id="cb32-8"><a href="#cb32-8"></a>    std<span class="op">::</span>meta<span class="op">::</span>info r;</span>
+<span id="cb32-9"><a href="#cb32-9"></a>    <span class="cf">for</span> <span class="op">(</span><span class="dt">int</span> k <span class="op">=</span> <span class="dv">0</span>;; <span class="op">++</span>k<span class="op">)</span> <span class="op">{</span></span>
+<span id="cb32-10"><a href="#cb32-10"></a>      r <span class="op">=</span> substitute<span class="op">(^</span>Helper, <span class="op">{</span> std<span class="op">::</span>meta<span class="op">::</span>reflect_value<span class="op">(</span>k<span class="op">)</span> <span class="op">})</span>;</span>
+<span id="cb32-11"><a href="#cb32-11"></a>      <span class="cf">if</span> <span class="op">(</span>is_incomplete_type<span class="op">(</span>r<span class="op">))</span> <span class="cf">break</span>;</span>
+<span id="cb32-12"><a href="#cb32-12"></a>    <span class="op">}</span></span>
+<span id="cb32-13"><a href="#cb32-13"></a>    <span class="co">// Return the value of its member.  Calling static_data_members_of</span></span>
+<span id="cb32-14"><a href="#cb32-14"></a>    <span class="co">// triggers the instantiation (i.e., completion) of Helper&lt;k&gt;.</span></span>
+<span id="cb32-15"><a href="#cb32-15"></a>    <span class="cf">return</span> value_of<span class="op">&lt;</span><span class="dt">int</span><span class="op">&gt;(</span>static_data_members_of<span class="op">(</span>r<span class="op">)[</span><span class="dv">0</span><span class="op">])</span>;</span>
+<span id="cb32-16"><a href="#cb32-16"></a>  <span class="op">}</span></span>
+<span id="cb32-17"><a href="#cb32-17"></a><span class="op">}</span>;</span>
+<span id="cb32-18"><a href="#cb32-18"></a></span>
+<span id="cb32-19"><a href="#cb32-19"></a><span class="dt">int</span> x <span class="op">=</span> TU_Ticket<span class="op">::</span>next<span class="op">()</span>;  <span class="co">// x initialized to 0.</span></span>
+<span id="cb32-20"><a href="#cb32-20"></a><span class="dt">int</span> y <span class="op">=</span> TU_Ticket<span class="op">::</span>next<span class="op">()</span>;  <span class="co">// y initialized to 1.</span></span>
+<span id="cb32-21"><a href="#cb32-21"></a><span class="dt">int</span> z <span class="op">=</span> TU_Ticket<span class="op">::</span>next<span class="op">()</span>;  <span class="co">// z initialized to 2.</span></span></code></pre></div>
 </blockquote>
 <p>Note that this relies on the fact that a call to <code class="sourceCode cpp">substitute</code> returns a specialization of a template, but doesn’t trigger the instantiation of that specialization. Thus, the only instantiations of <code class="sourceCode cpp">TU_Ticket<span class="op">::</span>Helper</code> occur because of the call to <code class="sourceCode cpp">nonstatic_data_members_of</code> (which is a singleton representing the lone <code class="sourceCode cpp">value</code> member).</p>
 <p><a href="https://godbolt.org/z/1vEjW4sTr">On Compiler Explorer</a>.</p>
-<h2 data-number="3.16" id="emulating-typeful-reflection"><span class="header-section-number">3.16</span> Emulating typeful reflection<a href="#emulating-typeful-reflection" class="self-link"></a></h2>
+<h2 data-number="3.17" id="emulating-typeful-reflection"><span class="header-section-number">3.17</span> Emulating typeful reflection<a href="#emulating-typeful-reflection" class="self-link"></a></h2>
 <p>Although we believe a single opaque <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span>info</code> type to be the best and most scalable foundation for reflection, we acknowledge the desire expressed by SG7 for future support for “typeful reflection”. The following demonstrates one possible means of assembling a typeful reflection library, in which different classes of reflections are represented by distinct types, on top of the facilities proposed here.</p>
 <blockquote>
-<div class="sourceCode" id="cb32"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb32-1"><a href="#cb32-1"></a><span class="co">// Represents a &#39;std::meta::info&#39; constrained by a predicate.</span></span>
-<span id="cb32-2"><a href="#cb32-2"></a><span class="kw">template</span> <span class="op">&lt;</span>std<span class="op">::</span>meta<span class="op">::</span>info Pred<span class="op">&gt;</span></span>
-<span id="cb32-3"><a href="#cb32-3"></a>  <span class="kw">requires</span> <span class="op">(</span>type_of<span class="op">(^([:</span>Pred<span class="op">:](^</span><span class="dt">int</span><span class="op">)))</span> <span class="op">==</span> <span class="op">^</span><span class="dt">bool</span><span class="op">)</span></span>
-<span id="cb32-4"><a href="#cb32-4"></a><span class="kw">struct</span> metatype <span class="op">{</span></span>
-<span id="cb32-5"><a href="#cb32-5"></a>  std<span class="op">::</span>meta<span class="op">::</span>info value;</span>
-<span id="cb32-6"><a href="#cb32-6"></a></span>
-<span id="cb32-7"><a href="#cb32-7"></a>  <span class="co">// Construction is ill-formed unless predicate is satisfied.</span></span>
-<span id="cb32-8"><a href="#cb32-8"></a>  <span class="kw">consteval</span> metatype<span class="op">(</span>std<span class="op">::</span>meta<span class="op">::</span>info r<span class="op">)</span> <span class="op">:</span> value<span class="op">(</span>r<span class="op">)</span> <span class="op">{</span></span>
-<span id="cb32-9"><a href="#cb32-9"></a>    <span class="cf">if</span> <span class="op">(![:</span>Pred<span class="op">:](</span>r<span class="op">))</span></span>
-<span id="cb32-10"><a href="#cb32-10"></a>      <span class="cf">throw</span> <span class="st">&quot;Reflection is not a member of this metatype&quot;</span>;</span>
-<span id="cb32-11"><a href="#cb32-11"></a>  <span class="op">}</span></span>
-<span id="cb32-12"><a href="#cb32-12"></a></span>
-<span id="cb32-13"><a href="#cb32-13"></a>  <span class="co">// Cast to &#39;std::meta::info&#39; allows values of this type to be spliced.</span></span>
-<span id="cb32-14"><a href="#cb32-14"></a>  <span class="kw">consteval</span> <span class="kw">operator</span> std<span class="op">::</span>meta<span class="op">::</span>info<span class="op">()</span> <span class="kw">const</span> <span class="op">{</span> <span class="cf">return</span> value; <span class="op">}</span></span>
-<span id="cb32-15"><a href="#cb32-15"></a></span>
-<span id="cb32-16"><a href="#cb32-16"></a>  <span class="kw">static</span> <span class="kw">consteval</span> <span class="dt">bool</span> check<span class="op">(</span>std<span class="op">::</span>meta<span class="op">::</span>info r<span class="op">)</span> <span class="op">{</span> <span class="cf">return</span> <span class="op">[:</span>Pred<span class="op">:](</span>r<span class="op">)</span>; <span class="op">}</span></span>
-<span id="cb32-17"><a href="#cb32-17"></a><span class="op">}</span>;</span>
-<span id="cb32-18"><a href="#cb32-18"></a></span>
-<span id="cb32-19"><a href="#cb32-19"></a><span class="co">// Type representing a &quot;failure to match&quot; any known metatypes.</span></span>
-<span id="cb32-20"><a href="#cb32-20"></a><span class="kw">struct</span> unmatched <span class="op">{</span></span>
-<span id="cb32-21"><a href="#cb32-21"></a>  <span class="kw">consteval</span> unmatched<span class="op">(</span>std<span class="op">::</span>meta<span class="op">::</span>info<span class="op">)</span> <span class="op">{}</span></span>
-<span id="cb32-22"><a href="#cb32-22"></a>  <span class="kw">static</span> <span class="kw">consteval</span> <span class="dt">bool</span> check<span class="op">(</span>std<span class="op">::</span>meta<span class="op">::</span>info<span class="op">)</span> <span class="op">{</span> <span class="cf">return</span> <span class="kw">true</span>; <span class="op">}</span></span>
-<span id="cb32-23"><a href="#cb32-23"></a><span class="op">}</span>;</span>
-<span id="cb32-24"><a href="#cb32-24"></a></span>
-<span id="cb32-25"><a href="#cb32-25"></a><span class="co">// Returns the given reflection &quot;enriched&quot; with a more descriptive type.</span></span>
-<span id="cb32-26"><a href="#cb32-26"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">typename</span><span class="op">...</span> Choices<span class="op">&gt;</span></span>
-<span id="cb32-27"><a href="#cb32-27"></a><span class="kw">consteval</span> std<span class="op">::</span>meta<span class="op">::</span>info enrich<span class="op">(</span>std<span class="op">::</span>meta<span class="op">::</span>info r<span class="op">)</span> <span class="op">{</span></span>
-<span id="cb32-28"><a href="#cb32-28"></a>  <span class="co">// Because we control the type, we know that the constructor taking info is</span></span>
-<span id="cb32-29"><a href="#cb32-29"></a>  <span class="co">// the first constructor. The copy/move constructors are added at the }, so</span></span>
-<span id="cb32-30"><a href="#cb32-30"></a>  <span class="co">// will be the last ones in the list.</span></span>
-<span id="cb32-31"><a href="#cb32-31"></a>  std<span class="op">::</span>array ctors <span class="op">=</span> <span class="op">{</span>members_of<span class="op">(^</span>Choices, std<span class="op">::</span>meta<span class="op">::</span>is_constructor<span class="op">)[</span><span class="dv">0</span><span class="op">]...</span>,</span>
-<span id="cb32-32"><a href="#cb32-32"></a>                      members_of<span class="op">(^</span>unmatched, std<span class="op">::</span>meta<span class="op">::</span>is_constructor<span class="op">)[</span><span class="dv">0</span><span class="op">]}</span>;</span>
-<span id="cb32-33"><a href="#cb32-33"></a>  std<span class="op">::</span>array checks <span class="op">=</span> <span class="op">{^</span>Choices<span class="op">::</span>check<span class="op">...</span>, <span class="op">^</span>unmatched<span class="op">::</span>check<span class="op">}</span>;</span>
-<span id="cb32-34"><a href="#cb32-34"></a></span>
-<span id="cb32-35"><a href="#cb32-35"></a>  std<span class="op">::</span>meta<span class="op">::</span>info choice;</span>
-<span id="cb32-36"><a href="#cb32-36"></a>  <span class="cf">for</span> <span class="op">(</span><span class="kw">auto</span> <span class="op">[</span>check, ctor<span class="op">]</span> <span class="op">:</span> std<span class="op">::</span>views<span class="op">::</span>zip<span class="op">(</span>checks, ctors<span class="op">))</span></span>
-<span id="cb32-37"><a href="#cb32-37"></a>    <span class="cf">if</span> <span class="op">(</span>value_of<span class="op">&lt;</span><span class="dt">bool</span><span class="op">&gt;(</span>reflect_invoke<span class="op">(</span>check, <span class="op">{</span>reflect_value<span class="op">(</span>r<span class="op">)})))</span></span>
-<span id="cb32-38"><a href="#cb32-38"></a>      <span class="cf">return</span> reflect_invoke<span class="op">(</span>ctor, <span class="op">{</span>reflect_value<span class="op">(</span>r<span class="op">)})</span>;</span>
-<span id="cb32-39"><a href="#cb32-39"></a></span>
-<span id="cb32-40"><a href="#cb32-40"></a>  std<span class="op">::</span>unreachable<span class="op">()</span>;</span>
-<span id="cb32-41"><a href="#cb32-41"></a><span class="op">}</span></span></code></pre></div>
+<div class="sourceCode" id="cb33"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb33-1"><a href="#cb33-1"></a><span class="co">// Represents a &#39;std::meta::info&#39; constrained by a predicate.</span></span>
+<span id="cb33-2"><a href="#cb33-2"></a><span class="kw">template</span> <span class="op">&lt;</span>std<span class="op">::</span>meta<span class="op">::</span>info Pred<span class="op">&gt;</span></span>
+<span id="cb33-3"><a href="#cb33-3"></a>  <span class="kw">requires</span> <span class="op">(</span>type_of<span class="op">(^([:</span>Pred<span class="op">:](^</span><span class="dt">int</span><span class="op">)))</span> <span class="op">==</span> <span class="op">^</span><span class="dt">bool</span><span class="op">)</span></span>
+<span id="cb33-4"><a href="#cb33-4"></a><span class="kw">struct</span> metatype <span class="op">{</span></span>
+<span id="cb33-5"><a href="#cb33-5"></a>  std<span class="op">::</span>meta<span class="op">::</span>info value;</span>
+<span id="cb33-6"><a href="#cb33-6"></a></span>
+<span id="cb33-7"><a href="#cb33-7"></a>  <span class="co">// Construction is ill-formed unless predicate is satisfied.</span></span>
+<span id="cb33-8"><a href="#cb33-8"></a>  <span class="kw">consteval</span> metatype<span class="op">(</span>std<span class="op">::</span>meta<span class="op">::</span>info r<span class="op">)</span> <span class="op">:</span> value<span class="op">(</span>r<span class="op">)</span> <span class="op">{</span></span>
+<span id="cb33-9"><a href="#cb33-9"></a>    <span class="cf">if</span> <span class="op">(![:</span>Pred<span class="op">:](</span>r<span class="op">))</span></span>
+<span id="cb33-10"><a href="#cb33-10"></a>      <span class="cf">throw</span> <span class="st">&quot;Reflection is not a member of this metatype&quot;</span>;</span>
+<span id="cb33-11"><a href="#cb33-11"></a>  <span class="op">}</span></span>
+<span id="cb33-12"><a href="#cb33-12"></a></span>
+<span id="cb33-13"><a href="#cb33-13"></a>  <span class="co">// Cast to &#39;std::meta::info&#39; allows values of this type to be spliced.</span></span>
+<span id="cb33-14"><a href="#cb33-14"></a>  <span class="kw">consteval</span> <span class="kw">operator</span> std<span class="op">::</span>meta<span class="op">::</span>info<span class="op">()</span> <span class="kw">const</span> <span class="op">{</span> <span class="cf">return</span> value; <span class="op">}</span></span>
+<span id="cb33-15"><a href="#cb33-15"></a></span>
+<span id="cb33-16"><a href="#cb33-16"></a>  <span class="kw">static</span> <span class="kw">consteval</span> <span class="dt">bool</span> check<span class="op">(</span>std<span class="op">::</span>meta<span class="op">::</span>info r<span class="op">)</span> <span class="op">{</span> <span class="cf">return</span> <span class="op">[:</span>Pred<span class="op">:](</span>r<span class="op">)</span>; <span class="op">}</span></span>
+<span id="cb33-17"><a href="#cb33-17"></a><span class="op">}</span>;</span>
+<span id="cb33-18"><a href="#cb33-18"></a></span>
+<span id="cb33-19"><a href="#cb33-19"></a><span class="co">// Type representing a &quot;failure to match&quot; any known metatypes.</span></span>
+<span id="cb33-20"><a href="#cb33-20"></a><span class="kw">struct</span> unmatched <span class="op">{</span></span>
+<span id="cb33-21"><a href="#cb33-21"></a>  <span class="kw">consteval</span> unmatched<span class="op">(</span>std<span class="op">::</span>meta<span class="op">::</span>info<span class="op">)</span> <span class="op">{}</span></span>
+<span id="cb33-22"><a href="#cb33-22"></a>  <span class="kw">static</span> <span class="kw">consteval</span> <span class="dt">bool</span> check<span class="op">(</span>std<span class="op">::</span>meta<span class="op">::</span>info<span class="op">)</span> <span class="op">{</span> <span class="cf">return</span> <span class="kw">true</span>; <span class="op">}</span></span>
+<span id="cb33-23"><a href="#cb33-23"></a><span class="op">}</span>;</span>
+<span id="cb33-24"><a href="#cb33-24"></a></span>
+<span id="cb33-25"><a href="#cb33-25"></a><span class="co">// Returns the given reflection &quot;enriched&quot; with a more descriptive type.</span></span>
+<span id="cb33-26"><a href="#cb33-26"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">typename</span><span class="op">...</span> Choices<span class="op">&gt;</span></span>
+<span id="cb33-27"><a href="#cb33-27"></a><span class="kw">consteval</span> std<span class="op">::</span>meta<span class="op">::</span>info enrich<span class="op">(</span>std<span class="op">::</span>meta<span class="op">::</span>info r<span class="op">)</span> <span class="op">{</span></span>
+<span id="cb33-28"><a href="#cb33-28"></a>  <span class="co">// Because we control the type, we know that the constructor taking info is</span></span>
+<span id="cb33-29"><a href="#cb33-29"></a>  <span class="co">// the first constructor. The copy/move constructors are added at the }, so</span></span>
+<span id="cb33-30"><a href="#cb33-30"></a>  <span class="co">// will be the last ones in the list.</span></span>
+<span id="cb33-31"><a href="#cb33-31"></a>  std<span class="op">::</span>array ctors <span class="op">=</span> <span class="op">{</span>members_of<span class="op">(^</span>Choices, std<span class="op">::</span>meta<span class="op">::</span>is_constructor<span class="op">)[</span><span class="dv">0</span><span class="op">]...</span>,</span>
+<span id="cb33-32"><a href="#cb33-32"></a>                      members_of<span class="op">(^</span>unmatched, std<span class="op">::</span>meta<span class="op">::</span>is_constructor<span class="op">)[</span><span class="dv">0</span><span class="op">]}</span>;</span>
+<span id="cb33-33"><a href="#cb33-33"></a>  std<span class="op">::</span>array checks <span class="op">=</span> <span class="op">{^</span>Choices<span class="op">::</span>check<span class="op">...</span>, <span class="op">^</span>unmatched<span class="op">::</span>check<span class="op">}</span>;</span>
+<span id="cb33-34"><a href="#cb33-34"></a></span>
+<span id="cb33-35"><a href="#cb33-35"></a>  std<span class="op">::</span>meta<span class="op">::</span>info choice;</span>
+<span id="cb33-36"><a href="#cb33-36"></a>  <span class="cf">for</span> <span class="op">(</span><span class="kw">auto</span> <span class="op">[</span>check, ctor<span class="op">]</span> <span class="op">:</span> std<span class="op">::</span>views<span class="op">::</span>zip<span class="op">(</span>checks, ctors<span class="op">))</span></span>
+<span id="cb33-37"><a href="#cb33-37"></a>    <span class="cf">if</span> <span class="op">(</span>value_of<span class="op">&lt;</span><span class="dt">bool</span><span class="op">&gt;(</span>reflect_invoke<span class="op">(</span>check, <span class="op">{</span>reflect_value<span class="op">(</span>r<span class="op">)})))</span></span>
+<span id="cb33-38"><a href="#cb33-38"></a>      <span class="cf">return</span> reflect_invoke<span class="op">(</span>ctor, <span class="op">{</span>reflect_value<span class="op">(</span>r<span class="op">)})</span>;</span>
+<span id="cb33-39"><a href="#cb33-39"></a></span>
+<span id="cb33-40"><a href="#cb33-40"></a>  std<span class="op">::</span>unreachable<span class="op">()</span>;</span>
+<span id="cb33-41"><a href="#cb33-41"></a><span class="op">}</span></span></code></pre></div>
 </blockquote>
 <p>We can leverage this machinery to select different function overloads based on the “type” of reflection provided as an argument.</p>
 <blockquote>
-<div class="sourceCode" id="cb33"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb33-1"><a href="#cb33-1"></a><span class="kw">using</span> type_t <span class="op">=</span> metatype<span class="op">&lt;^</span>std<span class="op">::</span>meta<span class="op">::</span>is_type<span class="op">&gt;</span>;</span>
-<span id="cb33-2"><a href="#cb33-2"></a><span class="kw">using</span> fn_t <span class="op">=</span> metatype<span class="op">&lt;^</span>std<span class="op">::</span>meta<span class="op">::</span>is_function<span class="op">&gt;</span>;</span>
-<span id="cb33-3"><a href="#cb33-3"></a></span>
-<span id="cb33-4"><a href="#cb33-4"></a><span class="co">// Example of a function overloaded for different &quot;types&quot; of reflections.</span></span>
-<span id="cb33-5"><a href="#cb33-5"></a><span class="dt">void</span> PrintKind<span class="op">(</span>type_t<span class="op">)</span> <span class="op">{</span> std<span class="op">::</span>println<span class="op">(</span><span class="st">&quot;type&quot;</span><span class="op">)</span>; <span class="op">}</span></span>
-<span id="cb33-6"><a href="#cb33-6"></a><span class="dt">void</span> PrintKind<span class="op">(</span>fn_t<span class="op">)</span> <span class="op">{</span> std<span class="op">::</span>println<span class="op">(</span><span class="st">&quot;function&quot;</span><span class="op">)</span>; <span class="op">}</span></span>
-<span id="cb33-7"><a href="#cb33-7"></a><span class="dt">void</span> PrintKind<span class="op">(</span>unmatched<span class="op">)</span> <span class="op">{</span> std<span class="op">::</span>println<span class="op">(</span><span class="st">&quot;unknown kind&quot;</span><span class="op">)</span>; <span class="op">}</span></span>
-<span id="cb33-8"><a href="#cb33-8"></a></span>
-<span id="cb33-9"><a href="#cb33-9"></a><span class="dt">int</span> main<span class="op">()</span> <span class="op">{</span></span>
-<span id="cb33-10"><a href="#cb33-10"></a>  <span class="co">// Classifies any reflection as one of: Type, Function, or Unmatched.</span></span>
-<span id="cb33-11"><a href="#cb33-11"></a>  <span class="kw">auto</span> enrich <span class="op">=</span> <span class="op">[](</span>std<span class="op">::</span>meta<span class="op">::</span>info r<span class="op">)</span> <span class="op">{</span> <span class="cf">return</span> <span class="op">::</span>enrich<span class="op">&lt;</span>type_t, fn_t<span class="op">&gt;(</span>r<span class="op">)</span>; <span class="op">}</span>;</span>
-<span id="cb33-12"><a href="#cb33-12"></a></span>
-<span id="cb33-13"><a href="#cb33-13"></a>  <span class="co">// Demonstration of using &#39;enrich&#39; to select an overload.</span></span>
-<span id="cb33-14"><a href="#cb33-14"></a>  PrintKind<span class="op">([:</span>enrich<span class="op">(^</span>main<span class="op">):])</span>;  <span class="co">// &quot;function&quot;</span></span>
-<span id="cb33-15"><a href="#cb33-15"></a>  PrintKind<span class="op">([:</span>enrich<span class="op">(^</span><span class="dt">int</span><span class="op">):])</span>;   <span class="co">// &quot;type&quot;</span></span>
-<span id="cb33-16"><a href="#cb33-16"></a>  PrintKind<span class="op">([:</span>enrich<span class="op">(^</span><span class="dv">3</span><span class="op">):])</span>;     <span class="co">// &quot;unknown kind&quot;</span></span>
-<span id="cb33-17"><a href="#cb33-17"></a><span class="op">}</span></span></code></pre></div>
+<div class="sourceCode" id="cb34"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb34-1"><a href="#cb34-1"></a><span class="kw">using</span> type_t <span class="op">=</span> metatype<span class="op">&lt;^</span>std<span class="op">::</span>meta<span class="op">::</span>is_type<span class="op">&gt;</span>;</span>
+<span id="cb34-2"><a href="#cb34-2"></a><span class="kw">using</span> fn_t <span class="op">=</span> metatype<span class="op">&lt;^</span>std<span class="op">::</span>meta<span class="op">::</span>is_function<span class="op">&gt;</span>;</span>
+<span id="cb34-3"><a href="#cb34-3"></a></span>
+<span id="cb34-4"><a href="#cb34-4"></a><span class="co">// Example of a function overloaded for different &quot;types&quot; of reflections.</span></span>
+<span id="cb34-5"><a href="#cb34-5"></a><span class="dt">void</span> PrintKind<span class="op">(</span>type_t<span class="op">)</span> <span class="op">{</span> std<span class="op">::</span>println<span class="op">(</span><span class="st">&quot;type&quot;</span><span class="op">)</span>; <span class="op">}</span></span>
+<span id="cb34-6"><a href="#cb34-6"></a><span class="dt">void</span> PrintKind<span class="op">(</span>fn_t<span class="op">)</span> <span class="op">{</span> std<span class="op">::</span>println<span class="op">(</span><span class="st">&quot;function&quot;</span><span class="op">)</span>; <span class="op">}</span></span>
+<span id="cb34-7"><a href="#cb34-7"></a><span class="dt">void</span> PrintKind<span class="op">(</span>unmatched<span class="op">)</span> <span class="op">{</span> std<span class="op">::</span>println<span class="op">(</span><span class="st">&quot;unknown kind&quot;</span><span class="op">)</span>; <span class="op">}</span></span>
+<span id="cb34-8"><a href="#cb34-8"></a></span>
+<span id="cb34-9"><a href="#cb34-9"></a><span class="dt">int</span> main<span class="op">()</span> <span class="op">{</span></span>
+<span id="cb34-10"><a href="#cb34-10"></a>  <span class="co">// Classifies any reflection as one of: Type, Function, or Unmatched.</span></span>
+<span id="cb34-11"><a href="#cb34-11"></a>  <span class="kw">auto</span> enrich <span class="op">=</span> <span class="op">[](</span>std<span class="op">::</span>meta<span class="op">::</span>info r<span class="op">)</span> <span class="op">{</span> <span class="cf">return</span> <span class="op">::</span>enrich<span class="op">&lt;</span>type_t, fn_t<span class="op">&gt;(</span>r<span class="op">)</span>; <span class="op">}</span>;</span>
+<span id="cb34-12"><a href="#cb34-12"></a></span>
+<span id="cb34-13"><a href="#cb34-13"></a>  <span class="co">// Demonstration of using &#39;enrich&#39; to select an overload.</span></span>
+<span id="cb34-14"><a href="#cb34-14"></a>  PrintKind<span class="op">([:</span>enrich<span class="op">(^</span>main<span class="op">):])</span>;  <span class="co">// &quot;function&quot;</span></span>
+<span id="cb34-15"><a href="#cb34-15"></a>  PrintKind<span class="op">([:</span>enrich<span class="op">(^</span><span class="dt">int</span><span class="op">):])</span>;   <span class="co">// &quot;type&quot;</span></span>
+<span id="cb34-16"><a href="#cb34-16"></a>  PrintKind<span class="op">([:</span>enrich<span class="op">(^</span><span class="dv">3</span><span class="op">):])</span>;     <span class="co">// &quot;unknown kind&quot;</span></span>
+<span id="cb34-17"><a href="#cb34-17"></a><span class="op">}</span></span></code></pre></div>
 </blockquote>
 <p>Note that the <code class="sourceCode cpp">metatype</code> class can be generalized to wrap values of any literal type, or to wrap multiple values of possibly different types. This has been used, for instance, to select compile-time overloads based on: whether two integers share the same parity, the presence or absence of a value in an <code class="sourceCode cpp">optional</code>, the type of the value held by a <code class="sourceCode cpp">variant</code> or an <code class="sourceCode cpp">any</code>, or the syntactic form of a compile-time string.</p>
 <p>Achieving the same in C++23, with the same generality, would require spelling the argument(s) twice: first to obtain a “classification tag” to use as a template argument, and again to call the function, i.e.,</p>
 <blockquote>
-<div class="sourceCode" id="cb34"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb34-1"><a href="#cb34-1"></a>Printer<span class="op">::</span>PrintKind<span class="op">&lt;</span>classify<span class="op">(^</span><span class="dt">int</span><span class="op">)&gt;(^</span><span class="dt">int</span><span class="op">).</span></span>
-<span id="cb34-2"><a href="#cb34-2"></a><span class="co">// or worse...</span></span>
-<span id="cb34-3"><a href="#cb34-3"></a>fn<span class="op">&lt;</span>classify<span class="op">(</span>Arg1, Arg2, Arg3<span class="op">)&gt;(</span>Arg1, Arg2, Arg3<span class="op">).</span></span></code></pre></div>
+<div class="sourceCode" id="cb35"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb35-1"><a href="#cb35-1"></a>Printer<span class="op">::</span>PrintKind<span class="op">&lt;</span>classify<span class="op">(^</span><span class="dt">int</span><span class="op">)&gt;(^</span><span class="dt">int</span><span class="op">).</span></span>
+<span id="cb35-2"><a href="#cb35-2"></a><span class="co">// or worse...</span></span>
+<span id="cb35-3"><a href="#cb35-3"></a>fn<span class="op">&lt;</span>classify<span class="op">(</span>Arg1, Arg2, Arg3<span class="op">)&gt;(</span>Arg1, Arg2, Arg3<span class="op">).</span></span></code></pre></div>
 </blockquote>
 <h1 data-number="4" style="border-bottom:1px solid #cccccc" id="proposed-features"><span class="header-section-number">4</span> Proposed Features<a href="#proposed-features" class="self-link"></a></h1>
 <h2 data-number="4.1" id="the-reflection-operator"><span class="header-section-number">4.1</span> The Reflection Operator (<code class="sourceCode cpp"><span class="op">^</span></code>)<a href="#the-reflection-operator" class="self-link"></a></h2>
@@ -1625,7 +1664,7 @@ <h2 data-number="4.2" id="splicers"><span class="header-section-number">4.2</spa
 <p>The operand of a splicer is implicitly converted to a <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span>info</code> prvalue (i.e., if the operand expression has a class type that with a conversion function to convert to <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span>info</code>, splicing can still work).</p>
 <p>Attempting to splice a reflection value that does not meet the requirement of the splice is ill-formed. For example:</p>
 <blockquote>
-<div class="sourceCode" id="cb35"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb35-1"><a href="#cb35-1"></a><span class="kw">typename</span><span class="op">[:</span> <span class="op">^::</span> <span class="op">:]</span> x <span class="op">=</span> <span class="dv">0</span>;  <span class="co">// Error.</span></span></code></pre></div>
+<div class="sourceCode" id="cb36"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb36-1"><a href="#cb36-1"></a><span class="kw">typename</span><span class="op">[:</span> <span class="op">^::</span> <span class="op">:]</span> x <span class="op">=</span> <span class="dv">0</span>;  <span class="co">// Error.</span></span></code></pre></div>
 </blockquote>
 <h3 data-number="4.2.1" id="range-splicers"><span class="header-section-number">4.2.1</span> Range Splicers<a href="#range-splicers" class="self-link"></a></h3>
 <p>The splicers described above all take a single object of type <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span>info</code> (described in more detail below). However, there are many cases where we don’t have a single reflection, we have a range of reflections - and we want to splice them all in one go. For that, we need a different form of splicer: a range splicer.</p>
@@ -1643,46 +1682,46 @@ <h3 data-number="4.2.1" id="range-splicers"><span class="header-section-number">
 </thead>
 <tbody>
 <tr class="odd">
-<td><div class="sourceCode" id="cb36"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb36-1"><a href="#cb36-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">typename</span> T<span class="op">&gt;</span></span>
-<span id="cb36-2"><a href="#cb36-2"></a><span class="kw">constexpr</span> <span class="kw">auto</span> struct_to_tuple<span class="op">(</span>T <span class="kw">const</span><span class="op">&amp;</span> t<span class="op">)</span> <span class="op">{</span></span>
-<span id="cb36-3"><a href="#cb36-3"></a>  <span class="kw">constexpr</span> <span class="kw">auto</span> members <span class="op">=</span> nonstatic_data_members_of<span class="op">(^</span>T<span class="op">)</span>;</span>
-<span id="cb36-4"><a href="#cb36-4"></a></span>
-<span id="cb36-5"><a href="#cb36-5"></a>  <span class="kw">constexpr</span> <span class="kw">auto</span> indices <span class="op">=</span> <span class="op">[]{</span></span>
-<span id="cb36-6"><a href="#cb36-6"></a>    std<span class="op">::</span>array<span class="op">&lt;</span><span class="dt">int</span>, members<span class="op">.</span>size<span class="op">()&gt;</span> indices;</span>
-<span id="cb36-7"><a href="#cb36-7"></a>    std<span class="op">::</span>ranges<span class="op">::</span>iota<span class="op">(</span>indices, <span class="dv">0</span><span class="op">)</span>;</span>
-<span id="cb36-8"><a href="#cb36-8"></a>    <span class="cf">return</span> indices;</span>
-<span id="cb36-9"><a href="#cb36-9"></a>  <span class="op">}()</span>;</span>
-<span id="cb36-10"><a href="#cb36-10"></a></span>
-<span id="cb36-11"><a href="#cb36-11"></a>  <span class="kw">constexpr</span> <span class="kw">auto</span> <span class="op">[...</span>Is<span class="op">]</span> <span class="op">=</span> indices;</span>
-<span id="cb36-12"><a href="#cb36-12"></a>  <span class="cf">return</span> std<span class="op">::</span>make_tuple<span class="op">(</span>t<span class="op">.[:</span> members<span class="op">[</span>Is<span class="op">]</span> <span class="op">:]...)</span>;</span>
-<span id="cb36-13"><a href="#cb36-13"></a><span class="op">}</span></span></code></pre></div></td>
 <td><div class="sourceCode" id="cb37"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb37-1"><a href="#cb37-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">typename</span> T<span class="op">&gt;</span></span>
 <span id="cb37-2"><a href="#cb37-2"></a><span class="kw">constexpr</span> <span class="kw">auto</span> struct_to_tuple<span class="op">(</span>T <span class="kw">const</span><span class="op">&amp;</span> t<span class="op">)</span> <span class="op">{</span></span>
 <span id="cb37-3"><a href="#cb37-3"></a>  <span class="kw">constexpr</span> <span class="kw">auto</span> members <span class="op">=</span> nonstatic_data_members_of<span class="op">(^</span>T<span class="op">)</span>;</span>
-<span id="cb37-4"><a href="#cb37-4"></a>  <span class="cf">return</span> std<span class="op">::</span>make_tuple<span class="op">(</span>t<span class="op">.[:</span> <span class="op">...</span>members <span class="op">:]...)</span>;</span>
-<span id="cb37-5"><a href="#cb37-5"></a><span class="op">}</span></span></code></pre></div></td>
+<span id="cb37-4"><a href="#cb37-4"></a></span>
+<span id="cb37-5"><a href="#cb37-5"></a>  <span class="kw">constexpr</span> <span class="kw">auto</span> indices <span class="op">=</span> <span class="op">[]{</span></span>
+<span id="cb37-6"><a href="#cb37-6"></a>    std<span class="op">::</span>array<span class="op">&lt;</span><span class="dt">int</span>, members<span class="op">.</span>size<span class="op">()&gt;</span> indices;</span>
+<span id="cb37-7"><a href="#cb37-7"></a>    std<span class="op">::</span>ranges<span class="op">::</span>iota<span class="op">(</span>indices, <span class="dv">0</span><span class="op">)</span>;</span>
+<span id="cb37-8"><a href="#cb37-8"></a>    <span class="cf">return</span> indices;</span>
+<span id="cb37-9"><a href="#cb37-9"></a>  <span class="op">}()</span>;</span>
+<span id="cb37-10"><a href="#cb37-10"></a></span>
+<span id="cb37-11"><a href="#cb37-11"></a>  <span class="kw">constexpr</span> <span class="kw">auto</span> <span class="op">[...</span>Is<span class="op">]</span> <span class="op">=</span> indices;</span>
+<span id="cb37-12"><a href="#cb37-12"></a>  <span class="cf">return</span> std<span class="op">::</span>make_tuple<span class="op">(</span>t<span class="op">.[:</span> members<span class="op">[</span>Is<span class="op">]</span> <span class="op">:]...)</span>;</span>
+<span id="cb37-13"><a href="#cb37-13"></a><span class="op">}</span></span></code></pre></div></td>
+<td><div class="sourceCode" id="cb38"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb38-1"><a href="#cb38-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">typename</span> T<span class="op">&gt;</span></span>
+<span id="cb38-2"><a href="#cb38-2"></a><span class="kw">constexpr</span> <span class="kw">auto</span> struct_to_tuple<span class="op">(</span>T <span class="kw">const</span><span class="op">&amp;</span> t<span class="op">)</span> <span class="op">{</span></span>
+<span id="cb38-3"><a href="#cb38-3"></a>  <span class="kw">constexpr</span> <span class="kw">auto</span> members <span class="op">=</span> nonstatic_data_members_of<span class="op">(^</span>T<span class="op">)</span>;</span>
+<span id="cb38-4"><a href="#cb38-4"></a>  <span class="cf">return</span> std<span class="op">::</span>make_tuple<span class="op">(</span>t<span class="op">.[:</span> <span class="op">...</span>members <span class="op">:]...)</span>;</span>
+<span id="cb38-5"><a href="#cb38-5"></a><span class="op">}</span></span></code></pre></div></td>
 </tr>
 </tbody>
 </table>
 <p>A range splice, <code class="sourceCode cpp"><span class="op">[:</span> <span class="op">...</span> r <span class="op">:]</span></code>, would accept as its argument a constant range of <code class="sourceCode cpp">meta<span class="op">::</span>info</code>, <code class="sourceCode cpp">r</code>, and would behave as an unexpanded pack of splices. So the above expression</p>
 <blockquote>
-<div class="sourceCode" id="cb38"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb38-1"><a href="#cb38-1"></a>make_tuple<span class="op">(</span>t<span class="op">.[:</span> <span class="op">...</span> members <span class="op">:]...)</span></span></code></pre></div>
+<div class="sourceCode" id="cb39"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb39-1"><a href="#cb39-1"></a>make_tuple<span class="op">(</span>t<span class="op">.[:</span> <span class="op">...</span> members <span class="op">:]...)</span></span></code></pre></div>
 </blockquote>
 <p>would evaluate as</p>
 <blockquote>
-<div class="sourceCode" id="cb39"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb39-1"><a href="#cb39-1"></a>make_tuple<span class="op">(</span>t<span class="op">.[:</span>members<span class="op">[</span><span class="dv">0</span><span class="op">]:]</span>, t<span class="op">.[:</span>members<span class="op">[</span><span class="dv">1</span><span class="op">]:]</span>, <span class="op">...</span>, t<span class="op">.[:</span>members<span class="op">[</span><em>N-1</em><span class="op">]:])</span></span></code></pre></div>
+<div class="sourceCode" id="cb40"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb40-1"><a href="#cb40-1"></a>make_tuple<span class="op">(</span>t<span class="op">.[:</span>members<span class="op">[</span><span class="dv">0</span><span class="op">]:]</span>, t<span class="op">.[:</span>members<span class="op">[</span><span class="dv">1</span><span class="op">]:]</span>, <span class="op">...</span>, t<span class="op">.[:</span>members<span class="op">[</span><em>N-1</em><span class="op">]:])</span></span></code></pre></div>
 </blockquote>
 <p>This is a very useful facility indeed!</p>
 <p>However, range splicing of dependent arguments is at least an order of magnitude harder to implement than ordinary splicing. We think that not including range splicing gives us a better chance of having reflection in C++26. Especially since, as this paper’s examples demonstrate, a lot can be done without them.</p>
 <p>Another way to work around a lack of range splicing would be to implement <code class="sourceCode cpp">with_size<span class="op">&lt;</span>N<span class="op">&gt;(</span>f<span class="op">)</span></code>, which would behave like <code class="sourceCode cpp">f<span class="op">(</span>integral_constant<span class="op">&lt;</span><span class="dt">size_t</span>, <span class="dv">0</span><span class="op">&gt;{}</span>, integral_constant<span class="op">&lt;</span><span class="dt">size_t</span>, <span class="dv">0</span><span class="op">&gt;{}</span>, <span class="op">...</span>, integral_constant<span class="op">&lt;</span><span class="dt">size_t</span>, N<span class="op">-</span><span class="dv">1</span><span class="op">&gt;{})</span></code>. Which is enough for a tolerable implementation:</p>
 <blockquote>
-<div class="sourceCode" id="cb40"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb40-1"><a href="#cb40-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">typename</span> T<span class="op">&gt;</span></span>
-<span id="cb40-2"><a href="#cb40-2"></a><span class="kw">constexpr</span> <span class="kw">auto</span> struct_to_tuple<span class="op">(</span>T <span class="kw">const</span><span class="op">&amp;</span> t<span class="op">)</span> <span class="op">{</span></span>
-<span id="cb40-3"><a href="#cb40-3"></a>  <span class="kw">constexpr</span> <span class="kw">auto</span> members <span class="op">=</span> nonstatic_data_members_of<span class="op">(^</span>T<span class="op">)</span>;</span>
-<span id="cb40-4"><a href="#cb40-4"></a>  <span class="cf">return</span> with_size<span class="op">&lt;</span>members<span class="op">.</span>size<span class="op">()&gt;([&amp;](</span><span class="kw">auto</span><span class="op">...</span> Is<span class="op">){</span></span>
-<span id="cb40-5"><a href="#cb40-5"></a>    <span class="cf">return</span> std<span class="op">::</span>make_tuple<span class="op">(</span>t<span class="op">.[:</span> members<span class="op">[</span>Is<span class="op">]</span> <span class="op">:]...)</span>;</span>
-<span id="cb40-6"><a href="#cb40-6"></a>  <span class="op">})</span>;</span>
-<span id="cb40-7"><a href="#cb40-7"></a><span class="op">}</span></span></code></pre></div>
+<div class="sourceCode" id="cb41"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb41-1"><a href="#cb41-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">typename</span> T<span class="op">&gt;</span></span>
+<span id="cb41-2"><a href="#cb41-2"></a><span class="kw">constexpr</span> <span class="kw">auto</span> struct_to_tuple<span class="op">(</span>T <span class="kw">const</span><span class="op">&amp;</span> t<span class="op">)</span> <span class="op">{</span></span>
+<span id="cb41-3"><a href="#cb41-3"></a>  <span class="kw">constexpr</span> <span class="kw">auto</span> members <span class="op">=</span> nonstatic_data_members_of<span class="op">(^</span>T<span class="op">)</span>;</span>
+<span id="cb41-4"><a href="#cb41-4"></a>  <span class="cf">return</span> with_size<span class="op">&lt;</span>members<span class="op">.</span>size<span class="op">()&gt;([&amp;](</span><span class="kw">auto</span><span class="op">...</span> Is<span class="op">){</span></span>
+<span id="cb41-5"><a href="#cb41-5"></a>    <span class="cf">return</span> std<span class="op">::</span>make_tuple<span class="op">(</span>t<span class="op">.[:</span> members<span class="op">[</span>Is<span class="op">]</span> <span class="op">:]...)</span>;</span>
+<span id="cb41-6"><a href="#cb41-6"></a>  <span class="op">})</span>;</span>
+<span id="cb41-7"><a href="#cb41-7"></a><span class="op">}</span></span></code></pre></div>
 </blockquote>
 <p>(P1240 did propose range splicers.)</p>
 <h3 data-number="4.2.2" id="syntax-discussion-1"><span class="header-section-number">4.2.2</span> Syntax discussion<a href="#syntax-discussion-1" class="self-link"></a></h3>
@@ -1690,17 +1729,17 @@ <h3 data-number="4.2.2" id="syntax-discussion-1"><span class="header-section-num
 <p>We propose <code class="sourceCode cpp"><span class="op">[:</span></code> and <code class="sourceCode cpp"><span class="op">:]</span></code> be single tokens rather than combinations of <code class="sourceCode cpp"><span class="op">[</span></code>, <code class="sourceCode cpp"><span class="op">]</span></code>, and <code class="sourceCode cpp"><span class="op">:</span></code>. Among others, it simplifies the handling of expressions like <code class="sourceCode cpp">arr<span class="op">[[:</span><span class="at">refl</span><span class="op">():]]</span></code>. On the flip side, it requires a special rule like the one that was made to handle <code class="sourceCode cpp"><span class="op">&lt;::</span></code> to leave the meaning of <code class="sourceCode cpp">arr<span class="op">[::</span>N<span class="op">]</span></code> unchanged and another one to avoid breaking a (somewhat useless) attribute specifier of the form <code class="sourceCode cpp"><span class="op">[[</span><span class="kw">using</span><span class="at"> ns</span><span class="op">:]]</span></code>.</p>
 <p>A syntax that is delimited on the left and right is useful here because spliced expressions may involve lower-precedence operators. However, there are other possibilities. For example, now that <code><span class="op">$</span></code> is available in the basic source character set, we might consider <code class="sourceCode cpp"><span class="op">$</span><span class="op">&lt;</span><em>expr</em><span class="op">&gt;</span></code>. This is somewhat natural to those of us that have used systems where <code><span class="op">$</span></code> is used to expand placeholders in document templates. For example:</p>
 <blockquote>
-<div class="sourceCode" id="cb41"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb41-1"><a href="#cb41-1"></a><span class="op">$</span>select_type<span class="op">(</span><span class="dv">3</span><span class="op">)</span> <span class="op">*</span>ptr <span class="op">=</span> <span class="kw">nullptr</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb42"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb42-1"><a href="#cb42-1"></a><span class="op">$</span>select_type<span class="op">(</span><span class="dv">3</span><span class="op">)</span> <span class="op">*</span>ptr <span class="op">=</span> <span class="kw">nullptr</span>;</span></code></pre></div>
 </blockquote>
 <p>The prefixes <code class="sourceCode cpp"><span class="kw">typename</span></code> and <code class="sourceCode cpp"><span class="kw">template</span></code> are only strictly needed in some cases where the operand of the splice is a dependent expression. In our proposal, however, we only make <code class="sourceCode cpp"><span class="kw">typename</span></code> optional in the same contexts where it would be optional for qualified names with dependent name qualifiers. That has the advantage to catch unfortunate errors while keeping a single rule and helping human readers parse the intended meaning of otherwise ambiguous constructs.</p>
 <h2 data-number="4.3" id="stdmetainfo"><span class="header-section-number">4.3</span> <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span>info</code><a href="#stdmetainfo" class="self-link"></a></h2>
 <p>The type <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span>info</code> can be defined as follows:</p>
 <blockquote>
-<div class="sourceCode" id="cb42"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb42-1"><a href="#cb42-1"></a><span class="kw">namespace</span> std <span class="op">{</span></span>
-<span id="cb42-2"><a href="#cb42-2"></a>  <span class="kw">namespace</span> meta <span class="op">{</span></span>
-<span id="cb42-3"><a href="#cb42-3"></a>    <span class="kw">using</span> info <span class="op">=</span> <span class="kw">decltype</span><span class="op">(^</span><span class="dt">int</span><span class="op">)</span>;</span>
-<span id="cb42-4"><a href="#cb42-4"></a>  <span class="op">}</span></span>
-<span id="cb42-5"><a href="#cb42-5"></a><span class="op">}</span></span></code></pre></div>
+<div class="sourceCode" id="cb43"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb43-1"><a href="#cb43-1"></a><span class="kw">namespace</span> std <span class="op">{</span></span>
+<span id="cb43-2"><a href="#cb43-2"></a>  <span class="kw">namespace</span> meta <span class="op">{</span></span>
+<span id="cb43-3"><a href="#cb43-3"></a>    <span class="kw">using</span> info <span class="op">=</span> <span class="kw">decltype</span><span class="op">(^</span><span class="dt">int</span><span class="op">)</span>;</span>
+<span id="cb43-4"><a href="#cb43-4"></a>  <span class="op">}</span></span>
+<span id="cb43-5"><a href="#cb43-5"></a><span class="op">}</span></span></code></pre></div>
 </blockquote>
 <p>In our initial proposal a value of type <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span>info</code> can represent:</p>
 <ul>
@@ -1714,31 +1753,31 @@ <h2 data-number="4.3" id="stdmetainfo"><span class="header-section-number">4.3</
 </ul>
 <p>Notably absent at this time are general non-constant expressions (that aren’t <em>expression-id</em>s referring to functions, variables or structured bindings). For example:</p>
 <blockquote>
-<div class="sourceCode" id="cb43"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb43-1"><a href="#cb43-1"></a><span class="dt">int</span> x <span class="op">=</span> <span class="dv">0</span>;</span>
-<span id="cb43-2"><a href="#cb43-2"></a><span class="dt">void</span> g<span class="op">()</span> <span class="op">{</span></span>
-<span id="cb43-3"><a href="#cb43-3"></a>  <span class="op">[:^</span>x<span class="op">:]</span> <span class="op">=</span> <span class="dv">42</span>;     <span class="co">// Okay.  Same as: x = 42;</span></span>
-<span id="cb43-4"><a href="#cb43-4"></a>  x <span class="op">=</span> <span class="op">[:^(</span><span class="dv">2</span><span class="op">*</span>x<span class="op">):]</span>;  <span class="co">// Error: &quot;2*x&quot; is a general non-constant expression.</span></span>
-<span id="cb43-5"><a href="#cb43-5"></a>  <span class="kw">constexpr</span> <span class="dt">int</span> N <span class="op">=</span> <span class="dv">42</span>;</span>
-<span id="cb43-6"><a href="#cb43-6"></a>  x <span class="op">=</span> <span class="op">[:^(</span><span class="dv">2</span><span class="op">*</span>N<span class="op">):]</span>;  <span class="co">// Okay: &quot;2*N&quot; is a constant-expression.</span></span>
-<span id="cb43-7"><a href="#cb43-7"></a><span class="op">}</span></span></code></pre></div>
+<div class="sourceCode" id="cb44"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb44-1"><a href="#cb44-1"></a><span class="dt">int</span> x <span class="op">=</span> <span class="dv">0</span>;</span>
+<span id="cb44-2"><a href="#cb44-2"></a><span class="dt">void</span> g<span class="op">()</span> <span class="op">{</span></span>
+<span id="cb44-3"><a href="#cb44-3"></a>  <span class="op">[:^</span>x<span class="op">:]</span> <span class="op">=</span> <span class="dv">42</span>;     <span class="co">// Okay.  Same as: x = 42;</span></span>
+<span id="cb44-4"><a href="#cb44-4"></a>  x <span class="op">=</span> <span class="op">[:^(</span><span class="dv">2</span><span class="op">*</span>x<span class="op">):]</span>;  <span class="co">// Error: &quot;2*x&quot; is a general non-constant expression.</span></span>
+<span id="cb44-5"><a href="#cb44-5"></a>  <span class="kw">constexpr</span> <span class="dt">int</span> N <span class="op">=</span> <span class="dv">42</span>;</span>
+<span id="cb44-6"><a href="#cb44-6"></a>  x <span class="op">=</span> <span class="op">[:^(</span><span class="dv">2</span><span class="op">*</span>N<span class="op">):]</span>;  <span class="co">// Okay: &quot;2*N&quot; is a constant-expression.</span></span>
+<span id="cb44-7"><a href="#cb44-7"></a><span class="op">}</span></span></code></pre></div>
 </blockquote>
 <p>Note that for <code class="sourceCode cpp"><span class="op">^(</span><span class="dv">2</span><span class="op">*</span>N<span class="op">)</span></code> an implementation only has to capture the constant value of <code class="sourceCode cpp"><span class="dv">2</span><span class="op">*</span>N</code> and not various other properties of the underlying expression (such as any temporaries it involves, etc.).</p>
 <p>The type <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span>info</code> is a <em>scalar</em> type. Nontype template arguments of type <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span>info</code> are permitted. The entity being reflected can affect the linkage of a template instance involving a reflection. For example:</p>
 <blockquote>
-<div class="sourceCode" id="cb44"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb44-1"><a href="#cb44-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">auto</span> R<span class="op">&gt;</span> <span class="kw">struct</span> S <span class="op">{}</span>;</span>
-<span id="cb44-2"><a href="#cb44-2"></a></span>
-<span id="cb44-3"><a href="#cb44-3"></a><span class="kw">extern</span> <span class="dt">int</span> x;</span>
-<span id="cb44-4"><a href="#cb44-4"></a><span class="kw">static</span> <span class="dt">int</span> y;</span>
-<span id="cb44-5"><a href="#cb44-5"></a></span>
-<span id="cb44-6"><a href="#cb44-6"></a>S<span class="op">&lt;^</span>x<span class="op">&gt;</span> sx;  <span class="co">// S&lt;^x&gt; has external name linkage.</span></span>
-<span id="cb44-7"><a href="#cb44-7"></a>S<span class="op">&lt;^</span>y<span class="op">&gt;</span> sy;  <span class="co">// S&lt;^y&gt; has internal name linkage.</span></span></code></pre></div>
+<div class="sourceCode" id="cb45"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb45-1"><a href="#cb45-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">auto</span> R<span class="op">&gt;</span> <span class="kw">struct</span> S <span class="op">{}</span>;</span>
+<span id="cb45-2"><a href="#cb45-2"></a></span>
+<span id="cb45-3"><a href="#cb45-3"></a><span class="kw">extern</span> <span class="dt">int</span> x;</span>
+<span id="cb45-4"><a href="#cb45-4"></a><span class="kw">static</span> <span class="dt">int</span> y;</span>
+<span id="cb45-5"><a href="#cb45-5"></a></span>
+<span id="cb45-6"><a href="#cb45-6"></a>S<span class="op">&lt;^</span>x<span class="op">&gt;</span> sx;  <span class="co">// S&lt;^x&gt; has external name linkage.</span></span>
+<span id="cb45-7"><a href="#cb45-7"></a>S<span class="op">&lt;^</span>y<span class="op">&gt;</span> sy;  <span class="co">// S&lt;^y&gt; has internal name linkage.</span></span></code></pre></div>
 </blockquote>
 <p>Namespace <code class="sourceCode cpp">std<span class="op">::</span>meta</code> is associated with type <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span>info</code>: That allows the core meta functions to be invoked without explicit qualification. For example:</p>
 <blockquote>
-<div class="sourceCode" id="cb45"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb45-1"><a href="#cb45-1"></a><span class="pp">#include </span><span class="im">&lt;meta&gt;</span></span>
-<span id="cb45-2"><a href="#cb45-2"></a><span class="kw">struct</span> S <span class="op">{}</span>;</span>
-<span id="cb45-3"><a href="#cb45-3"></a>std<span class="op">::</span>string name2 <span class="op">=</span> std<span class="op">::</span>meta<span class="op">::</span>name_of<span class="op">(^</span>S<span class="op">)</span>;  <span class="co">// Okay.</span></span>
-<span id="cb45-4"><a href="#cb45-4"></a>std<span class="op">::</span>string name1 <span class="op">=</span> name_of<span class="op">(^</span>S<span class="op">)</span>;             <span class="co">// Also okay.</span></span></code></pre></div>
+<div class="sourceCode" id="cb46"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb46-1"><a href="#cb46-1"></a><span class="pp">#include </span><span class="im">&lt;meta&gt;</span></span>
+<span id="cb46-2"><a href="#cb46-2"></a><span class="kw">struct</span> S <span class="op">{}</span>;</span>
+<span id="cb46-3"><a href="#cb46-3"></a>std<span class="op">::</span>string name2 <span class="op">=</span> std<span class="op">::</span>meta<span class="op">::</span>name_of<span class="op">(^</span>S<span class="op">)</span>;  <span class="co">// Okay.</span></span>
+<span id="cb46-4"><a href="#cb46-4"></a>std<span class="op">::</span>string name1 <span class="op">=</span> name_of<span class="op">(^</span>S<span class="op">)</span>;             <span class="co">// Also okay.</span></span></code></pre></div>
 </blockquote>
 <h2 data-number="4.4" id="metafunctions"><span class="header-section-number">4.4</span> Metafunctions<a href="#metafunctions" class="self-link"></a></h2>
 <p>We propose a number of metafunctions declared in namespace <code class="sourceCode cpp">std<span class="op">::</span>meta</code> to operator on reflection values. Adding metafunctions to an implementation is expected to be relatively “easy” compared to implementing the core language features described previously. However, despite offering a normal consteval C++ function interface, each on of these relies on “compiler magic” to a significant extent.</p>
@@ -1746,13 +1785,13 @@ <h3 data-number="4.4.1" id="constant-evaluation-order"><span class="header-secti
 <p>In C++23, “constant evaluation” produces pure values without observable side-effects and thus the order in which constant-evaluation occurs is immaterial. In fact, while the language is designed to permit constant evaluation to happen at compile time, an implementation is not strictly required to take advantage of that possibility.</p>
 <p>Some of the proposed metafunctions, however, have side-effects that have an effect of the remainder of the program. For example, we provide a <code class="sourceCode cpp">define_class</code> metafunction that provides a definition for a given class. Clearly, we want the effect of calling that metafunction to be “prompt” in a lexical-order sense. For example:</p>
 <blockquote>
-<div class="sourceCode" id="cb46"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb46-1"><a href="#cb46-1"></a><span class="pp">#include </span><span class="im">&lt;meta&gt;</span></span>
-<span id="cb46-2"><a href="#cb46-2"></a><span class="kw">struct</span> S;</span>
-<span id="cb46-3"><a href="#cb46-3"></a></span>
-<span id="cb46-4"><a href="#cb46-4"></a><span class="dt">void</span> g<span class="op">()</span> <span class="op">{</span></span>
-<span id="cb46-5"><a href="#cb46-5"></a>  <span class="kw">static_assert</span><span class="op">(</span>is_type<span class="op">(</span>define_class<span class="op">(^</span>S, <span class="op">{})))</span>;</span>
-<span id="cb46-6"><a href="#cb46-6"></a>  S s;  <span class="co">// S should be defined at this point.</span></span>
-<span id="cb46-7"><a href="#cb46-7"></a><span class="op">}</span></span></code></pre></div>
+<div class="sourceCode" id="cb47"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb47-1"><a href="#cb47-1"></a><span class="pp">#include </span><span class="im">&lt;meta&gt;</span></span>
+<span id="cb47-2"><a href="#cb47-2"></a><span class="kw">struct</span> S;</span>
+<span id="cb47-3"><a href="#cb47-3"></a></span>
+<span id="cb47-4"><a href="#cb47-4"></a><span class="dt">void</span> g<span class="op">()</span> <span class="op">{</span></span>
+<span id="cb47-5"><a href="#cb47-5"></a>  <span class="kw">static_assert</span><span class="op">(</span>is_type<span class="op">(</span>define_class<span class="op">(^</span>S, <span class="op">{})))</span>;</span>
+<span id="cb47-6"><a href="#cb47-6"></a>  S s;  <span class="co">// S should be defined at this point.</span></span>
+<span id="cb47-7"><a href="#cb47-7"></a><span class="op">}</span></span></code></pre></div>
 </blockquote>
 <p>Hence this proposal also introduces constraints on constant evaluation as follows…</p>
 <p>First, we identify a subset of manifestly constant-evaluated expressions and conversions characterized by the fact that their evaluation must occur and must succeed in a valid C++ program: We call these <em>plainly constant-evaluated</em>. We require that a programmer can count on those evaluations occurring exactly once and completing at translation time.</p>
@@ -1783,9 +1822,9 @@ <h3 data-number="4.4.2" id="error-handling-in-reflection"><span class="header-se
 </ul>
 <p>There is one interesting example to consider to decide between <code class="sourceCode cpp">std<span class="op">::</span>expected</code> and exceptions here:</p>
 <blockquote>
-<div class="sourceCode" id="cb47"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb47-1"><a href="#cb47-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">typename</span> T<span class="op">&gt;</span></span>
-<span id="cb47-2"><a href="#cb47-2"></a>  <span class="kw">requires</span> <span class="op">(</span>template_of<span class="op">(^</span>T<span class="op">)</span> <span class="op">==</span> <span class="op">^</span>std<span class="op">::</span>optional<span class="op">)</span></span>
-<span id="cb47-3"><a href="#cb47-3"></a><span class="dt">void</span> foo<span class="op">()</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb48"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb48-1"><a href="#cb48-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">typename</span> T<span class="op">&gt;</span></span>
+<span id="cb48-2"><a href="#cb48-2"></a>  <span class="kw">requires</span> <span class="op">(</span>template_of<span class="op">(^</span>T<span class="op">)</span> <span class="op">==</span> <span class="op">^</span>std<span class="op">::</span>optional<span class="op">)</span></span>
+<span id="cb48-3"><a href="#cb48-3"></a><span class="dt">void</span> foo<span class="op">()</span>;</span></code></pre></div>
 </blockquote>
 <p>If <code class="sourceCode cpp">template_of</code> returns an <code class="sourceCode cpp">excepted<span class="op">&lt;</span>info, E<span class="op">&gt;</span></code>, then <code class="sourceCode cpp">foo<span class="op">&lt;</span><span class="dt">int</span><span class="op">&gt;</span></code> is a substitution failure — <code class="sourceCode cpp">expected<span class="op">&lt;</span>T, E<span class="op">&gt;</span></code> is equality-comparable to <code class="sourceCode cpp">T</code>, that comparison would evaluate to <code class="sourceCode cpp"><span class="kw">false</span></code> but still be a constant expression.</p>
 <p>If <code class="sourceCode cpp">template_of</code> returns <code class="sourceCode cpp">info</code> but throws an exception, then <code class="sourceCode cpp">foo<span class="op">&lt;</span><span class="dt">int</span><span class="op">&gt;</span></code> would cause that exception to be uncaught, which would make the comparison not a constant expression. This actually makes the constraint ill-formed - not a substitution failure. In order to have <code class="sourceCode cpp">foo<span class="op">&lt;</span><span class="dt">int</span><span class="op">&gt;</span></code> be a substitution failure, either the constraint would have to first check that <code class="sourceCode cpp">T</code> is a template or we would have to change the language rule that requires constraints to be constant expressions (we would of course still keep the requirement that the constraint is a <code class="sourceCode cpp"><span class="dt">bool</span></code>).</p>
@@ -1794,14 +1833,14 @@ <h3 data-number="4.4.2" id="error-handling-in-reflection"><span class="header-se
 <h3 data-number="4.4.3" id="handling-aliases"><span class="header-section-number">4.4.3</span> Handling Aliases<a href="#handling-aliases" class="self-link"></a></h3>
 <p>Consider</p>
 <blockquote>
-<div class="sourceCode" id="cb48"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb48-1"><a href="#cb48-1"></a><span class="kw">using</span> A <span class="op">=</span> <span class="dt">int</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb49"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb49-1"><a href="#cb49-1"></a><span class="kw">using</span> A <span class="op">=</span> <span class="dt">int</span>;</span></code></pre></div>
 </blockquote>
 <p>In C++ today, <code class="sourceCode cpp">A</code> and <code class="sourceCode cpp"><span class="dt">int</span></code> can be used interchangeably and there is no distinction between the two types. With reflection as proposed in this paper, that will no longer be the case. <code class="sourceCode cpp"><span class="op">^</span>A</code> yields a reflection of an alias to <code class="sourceCode cpp"><span class="dt">int</span></code>, while <code class="sourceCode cpp"><span class="op">^</span><span class="dt">int</span></code> yields a reflection of <code class="sourceCode cpp"><span class="dt">int</span></code>. <code class="sourceCode cpp"><span class="op">^</span>A <span class="op">==</span> <span class="op">^</span><span class="dt">int</span></code> evaluates to <code class="sourceCode cpp"><span class="kw">false</span></code>, but there will be a way to strip aliases - so <code class="sourceCode cpp">dealias<span class="op">(^</span>A<span class="op">)</span> <span class="op">==</span> <span class="op">^</span><span class="dt">int</span></code> evaluates to <code class="sourceCode cpp"><span class="kw">true</span></code>.</p>
 <p>This opens up the question of how various other metafunctions handle aliases and it is worth going over a few examples:</p>
 <blockquote>
-<div class="sourceCode" id="cb49"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb49-1"><a href="#cb49-1"></a><span class="kw">using</span> A <span class="op">=</span> <span class="dt">int</span>;</span>
-<span id="cb49-2"><a href="#cb49-2"></a><span class="kw">using</span> B <span class="op">=</span> std<span class="op">::</span>unique_ptr<span class="op">&lt;</span><span class="dt">int</span><span class="op">&gt;</span>;</span>
-<span id="cb49-3"><a href="#cb49-3"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">class</span> T<span class="op">&gt;</span> <span class="kw">using</span> C <span class="op">=</span> std<span class="op">::</span>unique_ptr<span class="op">&lt;</span>T<span class="op">&gt;</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb50"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb50-1"><a href="#cb50-1"></a><span class="kw">using</span> A <span class="op">=</span> <span class="dt">int</span>;</span>
+<span id="cb50-2"><a href="#cb50-2"></a><span class="kw">using</span> B <span class="op">=</span> std<span class="op">::</span>unique_ptr<span class="op">&lt;</span><span class="dt">int</span><span class="op">&gt;</span>;</span>
+<span id="cb50-3"><a href="#cb50-3"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">class</span> T<span class="op">&gt;</span> <span class="kw">using</span> C <span class="op">=</span> std<span class="op">::</span>unique_ptr<span class="op">&lt;</span>T<span class="op">&gt;</span>;</span></code></pre></div>
 </blockquote>
 <p>This paper is proposing that:</p>
 <ul>
@@ -1814,216 +1853,216 @@ <h3 data-number="4.4.4" id="freestanding-implementations"><span class="header-se
 <h3 data-number="4.4.5" id="synopsis"><span class="header-section-number">4.4.5</span> Synopsis<a href="#synopsis" class="self-link"></a></h3>
 <p>Here is a synopsis for the proposed library API. The functions will be explained below.</p>
 <blockquote>
-<div class="sourceCode" id="cb50"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb50-1"><a href="#cb50-1"></a><span class="kw">namespace</span> std<span class="op">::</span>meta <span class="op">{</span></span>
-<span id="cb50-2"><a href="#cb50-2"></a>  <span class="co">// <a href="#name_of-display_name_of-source_location_of">name and location</a></span></span>
-<span id="cb50-3"><a href="#cb50-3"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> name_of<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> string_view;</span>
-<span id="cb50-4"><a href="#cb50-4"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> qualified_name_of<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> string_view;</span>
-<span id="cb50-5"><a href="#cb50-5"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> display_name_of<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> string_view;</span>
-<span id="cb50-6"><a href="#cb50-6"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> source_location_of<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> source_location;</span>
-<span id="cb50-7"><a href="#cb50-7"></a></span>
-<span id="cb50-8"><a href="#cb50-8"></a>  <span class="co">// <a href="#type_of-parent_of-dealias">type queries</a></span></span>
-<span id="cb50-9"><a href="#cb50-9"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> type_of<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> info;</span>
-<span id="cb50-10"><a href="#cb50-10"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> parent_of<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> info;</span>
-<span id="cb50-11"><a href="#cb50-11"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> dealias<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> info;</span>
-<span id="cb50-12"><a href="#cb50-12"></a></span>
-<span id="cb50-13"><a href="#cb50-13"></a>  <span class="co">// <a href="#template_of-template_arguments_of">template queries</a></span></span>
-<span id="cb50-14"><a href="#cb50-14"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> template_of<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> info;</span>
-<span id="cb50-15"><a href="#cb50-15"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> template_arguments_of<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span>;</span>
-<span id="cb50-16"><a href="#cb50-16"></a></span>
-<span id="cb50-17"><a href="#cb50-17"></a>  <span class="co">// <a href="#members_of-static_data_members_of-nonstatic_data_members_of-bases_of-enumerators_of-subobjects_of">member queries</a></span></span>
-<span id="cb50-18"><a href="#cb50-18"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="kw">typename</span> <span class="op">...</span>Fs<span class="op">&gt;</span></span>
-<span id="cb50-19"><a href="#cb50-19"></a>    <span class="kw">consteval</span> <span class="kw">auto</span> members_of<span class="op">(</span>info class_type, Fs <span class="op">...</span>filters<span class="op">)</span> <span class="op">-&gt;</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span>;</span>
-<span id="cb50-20"><a href="#cb50-20"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="kw">typename</span> <span class="op">...</span>Fs<span class="op">&gt;</span></span>
-<span id="cb50-21"><a href="#cb50-21"></a>    <span class="kw">consteval</span> <span class="kw">auto</span> bases_of<span class="op">(</span>info class_type, Fs <span class="op">...</span>filters<span class="op">)</span> <span class="op">-&gt;</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span>;</span>
-<span id="cb50-22"><a href="#cb50-22"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> static_data_members_of<span class="op">(</span>info class_type<span class="op">)</span> <span class="op">-&gt;</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span>;</span>
-<span id="cb50-23"><a href="#cb50-23"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> nonstatic_data_members_of<span class="op">(</span>info class_type<span class="op">)</span> <span class="op">-&gt;</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span>;</span>
-<span id="cb50-24"><a href="#cb50-24"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> subobjects_of<span class="op">(</span>info class_type<span class="op">)</span> <span class="op">-&gt;</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span>;</span>
-<span id="cb50-25"><a href="#cb50-25"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> enumerators_of<span class="op">(</span>info enum_type<span class="op">)</span> <span class="op">-&gt;</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span>;</span>
-<span id="cb50-26"><a href="#cb50-26"></a></span>
-<span id="cb50-27"><a href="#cb50-27"></a>  <span class="co">// <a href="#substitute">substitute</a></span></span>
-<span id="cb50-28"><a href="#cb50-28"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> substitute<span class="op">(</span>info templ, span<span class="op">&lt;</span>info <span class="kw">const</span><span class="op">&gt;</span> args<span class="op">)</span> <span class="op">-&gt;</span> info;</span>
-<span id="cb50-29"><a href="#cb50-29"></a></span>
-<span id="cb50-30"><a href="#cb50-30"></a>  <span class="co">// <a href="#reflect_invoke">reflect_invoke</a></span></span>
-<span id="cb50-31"><a href="#cb50-31"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> reflect_invoke<span class="op">(</span>info target, span<span class="op">&lt;</span>info <span class="kw">const</span><span class="op">&gt;</span> args<span class="op">)</span> <span class="op">-&gt;</span> info;</span>
-<span id="cb50-32"><a href="#cb50-32"></a></span>
-<span id="cb50-33"><a href="#cb50-33"></a>   <span class="co">// <a href="#value_oft">value_of<T></a></span></span>
-<span id="cb50-34"><a href="#cb50-34"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="kw">typename</span> T<span class="op">&gt;</span></span>
-<span id="cb50-35"><a href="#cb50-35"></a>    <span class="kw">consteval</span> <span class="kw">auto</span> value_of<span class="op">(</span>info<span class="op">)</span> <span class="op">-&gt;</span> T;</span>
-<span id="cb50-36"><a href="#cb50-36"></a></span>
-<span id="cb50-37"><a href="#cb50-37"></a>  <span class="co">// <a href="#test_type-test_types">test_type</a></span></span>
-<span id="cb50-38"><a href="#cb50-38"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> test_type<span class="op">(</span>info templ, info type<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
-<span id="cb50-39"><a href="#cb50-39"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> test_types<span class="op">(</span>info templ, span<span class="op">&lt;</span>info <span class="kw">const</span><span class="op">&gt;</span> types<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
-<span id="cb50-40"><a href="#cb50-40"></a></span>
-<span id="cb50-41"><a href="#cb50-41"></a>  <span class="co">// other type predicates (see <a href="#meta.reflection.queries-reflection-queries">the wording</a>)</span></span>
-<span id="cb50-42"><a href="#cb50-42"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_public<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
-<span id="cb50-43"><a href="#cb50-43"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_protected<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
-<span id="cb50-44"><a href="#cb50-44"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_private<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
-<span id="cb50-45"><a href="#cb50-45"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_accessible<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
-<span id="cb50-46"><a href="#cb50-46"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_virtual<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
-<span id="cb50-47"><a href="#cb50-47"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_pure_virtual<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
-<span id="cb50-48"><a href="#cb50-48"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_override<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
-<span id="cb50-49"><a href="#cb50-49"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_deleted<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
-<span id="cb50-50"><a href="#cb50-50"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_defaulted<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
-<span id="cb50-51"><a href="#cb50-51"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_explicit<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
-<span id="cb50-52"><a href="#cb50-52"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_bit_field<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
-<span id="cb50-53"><a href="#cb50-53"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> has_static_storage_duration<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
-<span id="cb50-54"><a href="#cb50-54"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> has_internal_linkage<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
-<span id="cb50-55"><a href="#cb50-55"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> has_external_linkage<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
-<span id="cb50-56"><a href="#cb50-56"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> has_linkage<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
-<span id="cb50-57"><a href="#cb50-57"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_class_member<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
-<span id="cb50-58"><a href="#cb50-58"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_namespace_member<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
-<span id="cb50-59"><a href="#cb50-59"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_nonstatic_data_member<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
-<span id="cb50-60"><a href="#cb50-60"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_static_member<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
-<span id="cb50-61"><a href="#cb50-61"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_base<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
-<span id="cb50-62"><a href="#cb50-62"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_namespace<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
-<span id="cb50-63"><a href="#cb50-63"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_function<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
-<span id="cb50-64"><a href="#cb50-64"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_variable<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
-<span id="cb50-65"><a href="#cb50-65"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_type<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
-<span id="cb50-66"><a href="#cb50-66"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_alias<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
-<span id="cb50-67"><a href="#cb50-67"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_incomplete_type<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
-<span id="cb50-68"><a href="#cb50-68"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_template<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
-<span id="cb50-69"><a href="#cb50-69"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_function_template<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
-<span id="cb50-70"><a href="#cb50-70"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_variable_template<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
-<span id="cb50-71"><a href="#cb50-71"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_class_template<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
-<span id="cb50-72"><a href="#cb50-72"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_alias_template<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
-<span id="cb50-73"><a href="#cb50-73"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_concept<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
-<span id="cb50-74"><a href="#cb50-74"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> has_template_arguments<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
-<span id="cb50-75"><a href="#cb50-75"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_constructor<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
-<span id="cb50-76"><a href="#cb50-76"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_destructor<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
-<span id="cb50-77"><a href="#cb50-77"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_special_member<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
-<span id="cb50-78"><a href="#cb50-78"></a></span>
-<span id="cb50-79"><a href="#cb50-79"></a>  <span class="co">// <a href="#reflect_value">reflect_value</a></span></span>
-<span id="cb50-80"><a href="#cb50-80"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="kw">typename</span> T<span class="op">&gt;</span></span>
-<span id="cb50-81"><a href="#cb50-81"></a>    <span class="kw">consteval</span> <span class="kw">auto</span> reflect_value<span class="op">(</span>T value<span class="op">)</span> <span class="op">-&gt;</span> info;</span>
-<span id="cb50-82"><a href="#cb50-82"></a></span>
-<span id="cb50-83"><a href="#cb50-83"></a>  <span class="co">// <a href="#data_member_spec-define_class">define_class</a></span></span>
-<span id="cb50-84"><a href="#cb50-84"></a>  <span class="kw">struct</span> data_member_options_t;</span>
-<span id="cb50-85"><a href="#cb50-85"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> data_member_spec<span class="op">(</span>info class_type,</span>
-<span id="cb50-86"><a href="#cb50-86"></a>                                  data_member_options_t options <span class="op">=</span> <span class="op">{})</span> <span class="op">-&gt;</span> info;</span>
-<span id="cb50-87"><a href="#cb50-87"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> define_class<span class="op">(</span>info class_type, span<span class="op">&lt;</span>info <span class="kw">const</span><span class="op">&gt;)</span> <span class="op">-&gt;</span> info;</span>
-<span id="cb50-88"><a href="#cb50-88"></a></span>
-<span id="cb50-89"><a href="#cb50-89"></a>  <span class="co">// <a href="#data-layout-reflection">data layout</a></span></span>
-<span id="cb50-90"><a href="#cb50-90"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> offset_of<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">size_t</span>;</span>
-<span id="cb50-91"><a href="#cb50-91"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> size_of<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">size_t</span>;</span>
-<span id="cb50-92"><a href="#cb50-92"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> bit_offset_of<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">size_t</span>;</span>
-<span id="cb50-93"><a href="#cb50-93"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> bit_size_of<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">size_t</span>;</span>
-<span id="cb50-94"><a href="#cb50-94"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> alignment_of<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">size_t</span>;</span>
-<span id="cb50-95"><a href="#cb50-95"></a><span class="op">}</span></span></code></pre></div>
+<div class="sourceCode" id="cb51"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb51-1"><a href="#cb51-1"></a><span class="kw">namespace</span> std<span class="op">::</span>meta <span class="op">{</span></span>
+<span id="cb51-2"><a href="#cb51-2"></a>  <span class="co">// <a href="#name_of-display_name_of-source_location_of">name and location</a></span></span>
+<span id="cb51-3"><a href="#cb51-3"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> name_of<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> string_view;</span>
+<span id="cb51-4"><a href="#cb51-4"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> qualified_name_of<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> string_view;</span>
+<span id="cb51-5"><a href="#cb51-5"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> display_name_of<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> string_view;</span>
+<span id="cb51-6"><a href="#cb51-6"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> source_location_of<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> source_location;</span>
+<span id="cb51-7"><a href="#cb51-7"></a></span>
+<span id="cb51-8"><a href="#cb51-8"></a>  <span class="co">// <a href="#type_of-parent_of-dealias">type queries</a></span></span>
+<span id="cb51-9"><a href="#cb51-9"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> type_of<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> info;</span>
+<span id="cb51-10"><a href="#cb51-10"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> parent_of<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> info;</span>
+<span id="cb51-11"><a href="#cb51-11"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> dealias<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> info;</span>
+<span id="cb51-12"><a href="#cb51-12"></a></span>
+<span id="cb51-13"><a href="#cb51-13"></a>  <span class="co">// <a href="#template_of-template_arguments_of">template queries</a></span></span>
+<span id="cb51-14"><a href="#cb51-14"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> template_of<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> info;</span>
+<span id="cb51-15"><a href="#cb51-15"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> template_arguments_of<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span>;</span>
+<span id="cb51-16"><a href="#cb51-16"></a></span>
+<span id="cb51-17"><a href="#cb51-17"></a>  <span class="co">// <a href="#members_of-static_data_members_of-nonstatic_data_members_of-bases_of-enumerators_of-subobjects_of">member queries</a></span></span>
+<span id="cb51-18"><a href="#cb51-18"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="kw">typename</span> <span class="op">...</span>Fs<span class="op">&gt;</span></span>
+<span id="cb51-19"><a href="#cb51-19"></a>    <span class="kw">consteval</span> <span class="kw">auto</span> members_of<span class="op">(</span>info class_type, Fs <span class="op">...</span>filters<span class="op">)</span> <span class="op">-&gt;</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span>;</span>
+<span id="cb51-20"><a href="#cb51-20"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="kw">typename</span> <span class="op">...</span>Fs<span class="op">&gt;</span></span>
+<span id="cb51-21"><a href="#cb51-21"></a>    <span class="kw">consteval</span> <span class="kw">auto</span> bases_of<span class="op">(</span>info class_type, Fs <span class="op">...</span>filters<span class="op">)</span> <span class="op">-&gt;</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span>;</span>
+<span id="cb51-22"><a href="#cb51-22"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> static_data_members_of<span class="op">(</span>info class_type<span class="op">)</span> <span class="op">-&gt;</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span>;</span>
+<span id="cb51-23"><a href="#cb51-23"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> nonstatic_data_members_of<span class="op">(</span>info class_type<span class="op">)</span> <span class="op">-&gt;</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span>;</span>
+<span id="cb51-24"><a href="#cb51-24"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> subobjects_of<span class="op">(</span>info class_type<span class="op">)</span> <span class="op">-&gt;</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span>;</span>
+<span id="cb51-25"><a href="#cb51-25"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> enumerators_of<span class="op">(</span>info enum_type<span class="op">)</span> <span class="op">-&gt;</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span>;</span>
+<span id="cb51-26"><a href="#cb51-26"></a></span>
+<span id="cb51-27"><a href="#cb51-27"></a>  <span class="co">// <a href="#substitute">substitute</a></span></span>
+<span id="cb51-28"><a href="#cb51-28"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> substitute<span class="op">(</span>info templ, span<span class="op">&lt;</span>info <span class="kw">const</span><span class="op">&gt;</span> args<span class="op">)</span> <span class="op">-&gt;</span> info;</span>
+<span id="cb51-29"><a href="#cb51-29"></a></span>
+<span id="cb51-30"><a href="#cb51-30"></a>  <span class="co">// <a href="#reflect_invoke">reflect_invoke</a></span></span>
+<span id="cb51-31"><a href="#cb51-31"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> reflect_invoke<span class="op">(</span>info target, span<span class="op">&lt;</span>info <span class="kw">const</span><span class="op">&gt;</span> args<span class="op">)</span> <span class="op">-&gt;</span> info;</span>
+<span id="cb51-32"><a href="#cb51-32"></a></span>
+<span id="cb51-33"><a href="#cb51-33"></a>   <span class="co">// <a href="#value_oft">value_of<T></a></span></span>
+<span id="cb51-34"><a href="#cb51-34"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="kw">typename</span> T<span class="op">&gt;</span></span>
+<span id="cb51-35"><a href="#cb51-35"></a>    <span class="kw">consteval</span> <span class="kw">auto</span> value_of<span class="op">(</span>info<span class="op">)</span> <span class="op">-&gt;</span> T;</span>
+<span id="cb51-36"><a href="#cb51-36"></a></span>
+<span id="cb51-37"><a href="#cb51-37"></a>  <span class="co">// <a href="#test_type-test_types">test_type</a></span></span>
+<span id="cb51-38"><a href="#cb51-38"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> test_type<span class="op">(</span>info templ, info type<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
+<span id="cb51-39"><a href="#cb51-39"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> test_types<span class="op">(</span>info templ, span<span class="op">&lt;</span>info <span class="kw">const</span><span class="op">&gt;</span> types<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
+<span id="cb51-40"><a href="#cb51-40"></a></span>
+<span id="cb51-41"><a href="#cb51-41"></a>  <span class="co">// other type predicates (see <a href="#meta.reflection.queries-reflection-queries">the wording</a>)</span></span>
+<span id="cb51-42"><a href="#cb51-42"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_public<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
+<span id="cb51-43"><a href="#cb51-43"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_protected<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
+<span id="cb51-44"><a href="#cb51-44"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_private<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
+<span id="cb51-45"><a href="#cb51-45"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_accessible<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
+<span id="cb51-46"><a href="#cb51-46"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_virtual<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
+<span id="cb51-47"><a href="#cb51-47"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_pure_virtual<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
+<span id="cb51-48"><a href="#cb51-48"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_override<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
+<span id="cb51-49"><a href="#cb51-49"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_deleted<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
+<span id="cb51-50"><a href="#cb51-50"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_defaulted<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
+<span id="cb51-51"><a href="#cb51-51"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_explicit<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
+<span id="cb51-52"><a href="#cb51-52"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_bit_field<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
+<span id="cb51-53"><a href="#cb51-53"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> has_static_storage_duration<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
+<span id="cb51-54"><a href="#cb51-54"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> has_internal_linkage<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
+<span id="cb51-55"><a href="#cb51-55"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> has_external_linkage<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
+<span id="cb51-56"><a href="#cb51-56"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> has_linkage<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
+<span id="cb51-57"><a href="#cb51-57"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_class_member<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
+<span id="cb51-58"><a href="#cb51-58"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_namespace_member<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
+<span id="cb51-59"><a href="#cb51-59"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_nonstatic_data_member<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
+<span id="cb51-60"><a href="#cb51-60"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_static_member<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
+<span id="cb51-61"><a href="#cb51-61"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_base<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
+<span id="cb51-62"><a href="#cb51-62"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_namespace<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
+<span id="cb51-63"><a href="#cb51-63"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_function<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
+<span id="cb51-64"><a href="#cb51-64"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_variable<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
+<span id="cb51-65"><a href="#cb51-65"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_type<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
+<span id="cb51-66"><a href="#cb51-66"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_alias<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
+<span id="cb51-67"><a href="#cb51-67"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_incomplete_type<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
+<span id="cb51-68"><a href="#cb51-68"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_template<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
+<span id="cb51-69"><a href="#cb51-69"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_function_template<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
+<span id="cb51-70"><a href="#cb51-70"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_variable_template<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
+<span id="cb51-71"><a href="#cb51-71"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_class_template<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
+<span id="cb51-72"><a href="#cb51-72"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_alias_template<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
+<span id="cb51-73"><a href="#cb51-73"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_concept<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
+<span id="cb51-74"><a href="#cb51-74"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> has_template_arguments<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
+<span id="cb51-75"><a href="#cb51-75"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_constructor<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
+<span id="cb51-76"><a href="#cb51-76"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_destructor<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
+<span id="cb51-77"><a href="#cb51-77"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> is_special_member<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
+<span id="cb51-78"><a href="#cb51-78"></a></span>
+<span id="cb51-79"><a href="#cb51-79"></a>  <span class="co">// <a href="#reflect_value">reflect_value</a></span></span>
+<span id="cb51-80"><a href="#cb51-80"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="kw">typename</span> T<span class="op">&gt;</span></span>
+<span id="cb51-81"><a href="#cb51-81"></a>    <span class="kw">consteval</span> <span class="kw">auto</span> reflect_value<span class="op">(</span>T value<span class="op">)</span> <span class="op">-&gt;</span> info;</span>
+<span id="cb51-82"><a href="#cb51-82"></a></span>
+<span id="cb51-83"><a href="#cb51-83"></a>  <span class="co">// <a href="#data_member_spec-define_class">define_class</a></span></span>
+<span id="cb51-84"><a href="#cb51-84"></a>  <span class="kw">struct</span> data_member_options_t;</span>
+<span id="cb51-85"><a href="#cb51-85"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> data_member_spec<span class="op">(</span>info class_type,</span>
+<span id="cb51-86"><a href="#cb51-86"></a>                                  data_member_options_t options <span class="op">=</span> <span class="op">{})</span> <span class="op">-&gt;</span> info;</span>
+<span id="cb51-87"><a href="#cb51-87"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> define_class<span class="op">(</span>info class_type, span<span class="op">&lt;</span>info <span class="kw">const</span><span class="op">&gt;)</span> <span class="op">-&gt;</span> info;</span>
+<span id="cb51-88"><a href="#cb51-88"></a></span>
+<span id="cb51-89"><a href="#cb51-89"></a>  <span class="co">// <a href="#data-layout-reflection">data layout</a></span></span>
+<span id="cb51-90"><a href="#cb51-90"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> offset_of<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">size_t</span>;</span>
+<span id="cb51-91"><a href="#cb51-91"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> size_of<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">size_t</span>;</span>
+<span id="cb51-92"><a href="#cb51-92"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> bit_offset_of<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">size_t</span>;</span>
+<span id="cb51-93"><a href="#cb51-93"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> bit_size_of<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">size_t</span>;</span>
+<span id="cb51-94"><a href="#cb51-94"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> alignment_of<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">size_t</span>;</span>
+<span id="cb51-95"><a href="#cb51-95"></a><span class="op">}</span></span></code></pre></div>
 </blockquote>
 <h3 data-number="4.4.6" id="name_of-display_name_of-source_location_of"><span class="header-section-number">4.4.6</span> <code class="sourceCode cpp">name_of</code>, <code class="sourceCode cpp">display_name_of</code>, <code class="sourceCode cpp">source_location_of</code><a href="#name_of-display_name_of-source_location_of" class="self-link"></a></h3>
 <blockquote>
-<div class="sourceCode" id="cb51"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb51-1"><a href="#cb51-1"></a><span class="kw">namespace</span> std<span class="op">::</span>meta <span class="op">{</span></span>
-<span id="cb51-2"><a href="#cb51-2"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> name_of<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> string_view;</span>
-<span id="cb51-3"><a href="#cb51-3"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> qualified_name_of<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> string_view;</span>
-<span id="cb51-4"><a href="#cb51-4"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> display_name_of<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> string_view;</span>
-<span id="cb51-5"><a href="#cb51-5"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> source_location_of<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> source_location;</span>
-<span id="cb51-6"><a href="#cb51-6"></a><span class="op">}</span></span></code></pre></div>
+<div class="sourceCode" id="cb52"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb52-1"><a href="#cb52-1"></a><span class="kw">namespace</span> std<span class="op">::</span>meta <span class="op">{</span></span>
+<span id="cb52-2"><a href="#cb52-2"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> name_of<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> string_view;</span>
+<span id="cb52-3"><a href="#cb52-3"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> qualified_name_of<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> string_view;</span>
+<span id="cb52-4"><a href="#cb52-4"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> display_name_of<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> string_view;</span>
+<span id="cb52-5"><a href="#cb52-5"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> source_location_of<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> source_location;</span>
+<span id="cb52-6"><a href="#cb52-6"></a><span class="op">}</span></span></code></pre></div>
 </blockquote>
 <p>Given a reflection <code class="sourceCode cpp">r</code> that designates a declared entity <code class="sourceCode cpp">X</code>, <code class="sourceCode cpp">name_of<span class="op">(</span>r<span class="op">)</span></code> and <code class="sourceCode cpp">qualified_name_of<span class="op">(</span>r<span class="op">)</span></code> return a <code class="sourceCode cpp">string_view</code> holding the unqualified and qualified name of <code class="sourceCode cpp">X</code>, respectively. For all other reflections, an empty <code class="sourceCode cpp">string_view</code> is produced. For template instances, the name does not include the template argument list. The contents of the <code class="sourceCode cpp">string_view</code> consist of characters of the basic source character set only (an implementation can map other characters using universal character names).</p>
 <p>Given a reflection <code class="sourceCode cpp">r</code>, <code class="sourceCode cpp">display_name_of<span class="op">(</span>r<span class="op">)</span></code> returns a unspecified non-empty <code class="sourceCode cpp">string_view</code>. Implementations are encouraged to produce text that is helpful in identifying the reflected construct.</p>
 <p>Given a reflection <code class="sourceCode cpp">r</code>, <code class="sourceCode cpp">source_location_of<span class="op">(</span>r<span class="op">)</span></code> returns an unspecified <code class="sourceCode cpp">source_location</code>. Implementations are encouraged to produce the correct source location of the item designated by the reflection.</p>
 <h3 data-number="4.4.7" id="type_of-parent_of-dealias"><span class="header-section-number">4.4.7</span> <code class="sourceCode cpp">type_of</code>, <code class="sourceCode cpp">parent_of</code>, <code class="sourceCode cpp">dealias</code><a href="#type_of-parent_of-dealias" class="self-link"></a></h3>
 <blockquote>
-<div class="sourceCode" id="cb52"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb52-1"><a href="#cb52-1"></a><span class="kw">namespace</span> std<span class="op">::</span>meta <span class="op">{</span></span>
-<span id="cb52-2"><a href="#cb52-2"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> type_of<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> info;</span>
-<span id="cb52-3"><a href="#cb52-3"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> parent_of<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> info;</span>
-<span id="cb52-4"><a href="#cb52-4"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> dealias<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> info;</span>
-<span id="cb52-5"><a href="#cb52-5"></a><span class="op">}</span></span></code></pre></div>
+<div class="sourceCode" id="cb53"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb53-1"><a href="#cb53-1"></a><span class="kw">namespace</span> std<span class="op">::</span>meta <span class="op">{</span></span>
+<span id="cb53-2"><a href="#cb53-2"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> type_of<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> info;</span>
+<span id="cb53-3"><a href="#cb53-3"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> parent_of<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> info;</span>
+<span id="cb53-4"><a href="#cb53-4"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> dealias<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> info;</span>
+<span id="cb53-5"><a href="#cb53-5"></a><span class="op">}</span></span></code></pre></div>
 </blockquote>
 <p>If <code class="sourceCode cpp">r</code> is a reflection designating a typed entity, <code class="sourceCode cpp">type_of<span class="op">(</span>r<span class="op">)</span></code> is a reflection designating its type. If <code class="sourceCode cpp">r</code> is already a type, <code class="sourceCode cpp">type_of<span class="op">(</span>r<span class="op">)</span></code> is not a constant expression. This can be used to implement the C <code class="sourceCode cpp"><span class="ex">typeof</span></code> feature (which works on both types and expressions and strips qualifiers):</p>
 <blockquote>
-<div class="sourceCode" id="cb53"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb53-1"><a href="#cb53-1"></a><span class="kw">consteval</span> <span class="kw">auto</span> do_typeof<span class="op">(</span>std<span class="op">::</span>meta<span class="op">::</span>info r<span class="op">)</span> <span class="op">-&gt;</span> std<span class="op">::</span>meta<span class="op">::</span>info <span class="op">{</span></span>
-<span id="cb53-2"><a href="#cb53-2"></a>  <span class="cf">return</span> remove_cvref<span class="op">(</span>is_type<span class="op">(</span>r<span class="op">)</span> <span class="op">?</span> r <span class="op">:</span> type_of<span class="op">(</span>r<span class="op">))</span>;</span>
-<span id="cb53-3"><a href="#cb53-3"></a><span class="op">}</span></span>
-<span id="cb53-4"><a href="#cb53-4"></a></span>
-<span id="cb53-5"><a href="#cb53-5"></a><span class="pp">#define typeof</span><span class="op">(</span>e<span class="op">)</span><span class="pp"> </span><span class="op">[:</span><span class="pp"> </span>do_typeof<span class="op">(^</span>e<span class="op">)</span><span class="pp"> </span><span class="op">:]</span></span></code></pre></div>
+<div class="sourceCode" id="cb54"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb54-1"><a href="#cb54-1"></a><span class="kw">consteval</span> <span class="kw">auto</span> do_typeof<span class="op">(</span>std<span class="op">::</span>meta<span class="op">::</span>info r<span class="op">)</span> <span class="op">-&gt;</span> std<span class="op">::</span>meta<span class="op">::</span>info <span class="op">{</span></span>
+<span id="cb54-2"><a href="#cb54-2"></a>  <span class="cf">return</span> remove_cvref<span class="op">(</span>is_type<span class="op">(</span>r<span class="op">)</span> <span class="op">?</span> r <span class="op">:</span> type_of<span class="op">(</span>r<span class="op">))</span>;</span>
+<span id="cb54-3"><a href="#cb54-3"></a><span class="op">}</span></span>
+<span id="cb54-4"><a href="#cb54-4"></a></span>
+<span id="cb54-5"><a href="#cb54-5"></a><span class="pp">#define typeof</span><span class="op">(</span>e<span class="op">)</span><span class="pp"> </span><span class="op">[:</span><span class="pp"> </span>do_typeof<span class="op">(^</span>e<span class="op">)</span><span class="pp"> </span><span class="op">:]</span></span></code></pre></div>
 </blockquote>
 <p>If <code class="sourceCode cpp">r</code> designates a member of a class or namespace, <code class="sourceCode cpp">parent_of<span class="op">(</span>r<span class="op">)</span></code> is a reflection designating its immediately enclosing class or namespace.</p>
 <p>If <code class="sourceCode cpp">r</code> designates an alias, <code class="sourceCode cpp">dealias<span class="op">(</span>r<span class="op">)</span></code> designates the underlying entity. Otherwise, <code class="sourceCode cpp">dealias<span class="op">(</span>r<span class="op">)</span></code> produces <code class="sourceCode cpp">r</code>. <code class="sourceCode cpp">dealias</code> is recursive - it strips all aliases:</p>
 <blockquote>
-<div class="sourceCode" id="cb54"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb54-1"><a href="#cb54-1"></a><span class="kw">using</span> X <span class="op">=</span> <span class="dt">int</span>;</span>
-<span id="cb54-2"><a href="#cb54-2"></a><span class="kw">using</span> Y <span class="op">=</span> X;</span>
-<span id="cb54-3"><a href="#cb54-3"></a><span class="kw">static_assert</span><span class="op">(</span>dealias<span class="op">(^</span><span class="dt">int</span><span class="op">)</span> <span class="op">==</span> <span class="op">^</span><span class="dt">int</span><span class="op">)</span>;</span>
-<span id="cb54-4"><a href="#cb54-4"></a><span class="kw">static_assert</span><span class="op">(</span>dealias<span class="op">(^</span>X<span class="op">)</span> <span class="op">==</span> <span class="op">^</span><span class="dt">int</span><span class="op">)</span>;</span>
-<span id="cb54-5"><a href="#cb54-5"></a><span class="kw">static_assert</span><span class="op">(</span>dealias<span class="op">(^</span>Y<span class="op">)</span> <span class="op">==</span> <span class="op">^</span><span class="dt">int</span><span class="op">)</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb55"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb55-1"><a href="#cb55-1"></a><span class="kw">using</span> X <span class="op">=</span> <span class="dt">int</span>;</span>
+<span id="cb55-2"><a href="#cb55-2"></a><span class="kw">using</span> Y <span class="op">=</span> X;</span>
+<span id="cb55-3"><a href="#cb55-3"></a><span class="kw">static_assert</span><span class="op">(</span>dealias<span class="op">(^</span><span class="dt">int</span><span class="op">)</span> <span class="op">==</span> <span class="op">^</span><span class="dt">int</span><span class="op">)</span>;</span>
+<span id="cb55-4"><a href="#cb55-4"></a><span class="kw">static_assert</span><span class="op">(</span>dealias<span class="op">(^</span>X<span class="op">)</span> <span class="op">==</span> <span class="op">^</span><span class="dt">int</span><span class="op">)</span>;</span>
+<span id="cb55-5"><a href="#cb55-5"></a><span class="kw">static_assert</span><span class="op">(</span>dealias<span class="op">(^</span>Y<span class="op">)</span> <span class="op">==</span> <span class="op">^</span><span class="dt">int</span><span class="op">)</span>;</span></code></pre></div>
 </blockquote>
 <h3 data-number="4.4.8" id="template_of-template_arguments_of"><span class="header-section-number">4.4.8</span> <code class="sourceCode cpp">template_of</code>, <code class="sourceCode cpp">template_arguments_of</code><a href="#template_of-template_arguments_of" class="self-link"></a></h3>
 <blockquote>
-<div class="sourceCode" id="cb55"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb55-1"><a href="#cb55-1"></a><span class="kw">namespace</span> std<span class="op">::</span>meta <span class="op">{</span></span>
-<span id="cb55-2"><a href="#cb55-2"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> template_of<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> info;</span>
-<span id="cb55-3"><a href="#cb55-3"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> template_arguments_of<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span>;</span>
-<span id="cb55-4"><a href="#cb55-4"></a><span class="op">}</span></span></code></pre></div>
+<div class="sourceCode" id="cb56"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb56-1"><a href="#cb56-1"></a><span class="kw">namespace</span> std<span class="op">::</span>meta <span class="op">{</span></span>
+<span id="cb56-2"><a href="#cb56-2"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> template_of<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> info;</span>
+<span id="cb56-3"><a href="#cb56-3"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> template_arguments_of<span class="op">(</span>info r<span class="op">)</span> <span class="op">-&gt;</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span>;</span>
+<span id="cb56-4"><a href="#cb56-4"></a><span class="op">}</span></span></code></pre></div>
 </blockquote>
 <p>If <code class="sourceCode cpp">r</code> is a reflection designated a type that is a specialization of some template, then <code class="sourceCode cpp">template_of<span class="op">(</span>r<span class="op">)</span></code> is a reflection of that template and <code class="sourceCode cpp">template_arguments_of<span class="op">(</span>r<span class="op">)</span></code> is a vector of the reflections of the template arguments. In other words, the preconditions on both is that <code class="sourceCode cpp">has_template_arguments<span class="op">(</span>r<span class="op">)</span></code> is <code class="sourceCode cpp"><span class="kw">true</span></code>.</p>
 <p>For example:</p>
 <blockquote>
-<div class="sourceCode" id="cb56"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb56-1"><a href="#cb56-1"></a>std<span class="op">::</span>vector<span class="op">&lt;</span><span class="dt">int</span><span class="op">&gt;</span> v <span class="op">=</span> <span class="op">{</span><span class="dv">1</span>, <span class="dv">2</span>, <span class="dv">3</span><span class="op">}</span>;</span>
-<span id="cb56-2"><a href="#cb56-2"></a><span class="kw">static_assert</span><span class="op">(</span>template_of<span class="op">(</span>type_of<span class="op">(^</span>v<span class="op">))</span> <span class="op">==</span> <span class="op">^</span>std<span class="op">::</span>vector<span class="op">)</span>;</span>
-<span id="cb56-3"><a href="#cb56-3"></a><span class="kw">static_assert</span><span class="op">(</span>template_arguments_of<span class="op">(</span>type_of<span class="op">(^</span>v<span class="op">))[</span><span class="dv">0</span><span class="op">]</span> <span class="op">==</span> <span class="op">^</span><span class="dt">int</span><span class="op">)</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb57"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb57-1"><a href="#cb57-1"></a>std<span class="op">::</span>vector<span class="op">&lt;</span><span class="dt">int</span><span class="op">&gt;</span> v <span class="op">=</span> <span class="op">{</span><span class="dv">1</span>, <span class="dv">2</span>, <span class="dv">3</span><span class="op">}</span>;</span>
+<span id="cb57-2"><a href="#cb57-2"></a><span class="kw">static_assert</span><span class="op">(</span>template_of<span class="op">(</span>type_of<span class="op">(^</span>v<span class="op">))</span> <span class="op">==</span> <span class="op">^</span>std<span class="op">::</span>vector<span class="op">)</span>;</span>
+<span id="cb57-3"><a href="#cb57-3"></a><span class="kw">static_assert</span><span class="op">(</span>template_arguments_of<span class="op">(</span>type_of<span class="op">(^</span>v<span class="op">))[</span><span class="dv">0</span><span class="op">]</span> <span class="op">==</span> <span class="op">^</span><span class="dt">int</span><span class="op">)</span>;</span></code></pre></div>
 </blockquote>
 <h3 data-number="4.4.9" id="members_of-static_data_members_of-nonstatic_data_members_of-bases_of-enumerators_of-subobjects_of"><span class="header-section-number">4.4.9</span> <code class="sourceCode cpp">members_of</code>, <code class="sourceCode cpp">static_data_members_of</code>, <code class="sourceCode cpp">nonstatic_data_members_of</code>, <code class="sourceCode cpp">bases_of</code>, <code class="sourceCode cpp">enumerators_of</code>, <code class="sourceCode cpp">subobjects_of</code><a href="#members_of-static_data_members_of-nonstatic_data_members_of-bases_of-enumerators_of-subobjects_of" class="self-link"></a></h3>
 <blockquote>
-<div class="sourceCode" id="cb57"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb57-1"><a href="#cb57-1"></a><span class="kw">namespace</span> std<span class="op">::</span>meta <span class="op">{</span></span>
-<span id="cb57-2"><a href="#cb57-2"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="kw">typename</span> <span class="op">...</span>Fs<span class="op">&gt;</span></span>
-<span id="cb57-3"><a href="#cb57-3"></a>    <span class="kw">consteval</span> <span class="kw">auto</span> members_of<span class="op">(</span>info class_type, Fs <span class="op">...</span>filters<span class="op">)</span> <span class="op">-&gt;</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span>;</span>
-<span id="cb57-4"><a href="#cb57-4"></a></span>
-<span id="cb57-5"><a href="#cb57-5"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="kw">typename</span> <span class="op">...</span>Fs<span class="op">&gt;</span></span>
-<span id="cb57-6"><a href="#cb57-6"></a>    <span class="kw">consteval</span> <span class="kw">auto</span> bases_of<span class="op">(</span>info class_type, Fs <span class="op">...</span>filters<span class="op">)</span> <span class="op">-&gt;</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span>;</span>
-<span id="cb57-7"><a href="#cb57-7"></a></span>
-<span id="cb57-8"><a href="#cb57-8"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> static_data_members_of<span class="op">(</span>info class_type<span class="op">)</span> <span class="op">-&gt;</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span> <span class="op">{</span></span>
-<span id="cb57-9"><a href="#cb57-9"></a>    <span class="cf">return</span> members_of<span class="op">(</span>class_type, is_variable<span class="op">)</span>;</span>
-<span id="cb57-10"><a href="#cb57-10"></a>  <span class="op">}</span></span>
-<span id="cb57-11"><a href="#cb57-11"></a></span>
-<span id="cb57-12"><a href="#cb57-12"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> nonstatic_data_members_of<span class="op">(</span>info class_type<span class="op">)</span> <span class="op">-&gt;</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span> <span class="op">{</span></span>
-<span id="cb57-13"><a href="#cb57-13"></a>    <span class="cf">return</span> members_of<span class="op">(</span>class_type, is_nonstatic_data_member<span class="op">)</span>;</span>
-<span id="cb57-14"><a href="#cb57-14"></a>  <span class="op">}</span></span>
-<span id="cb57-15"><a href="#cb57-15"></a></span>
-<span id="cb57-16"><a href="#cb57-16"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> subobjects_of<span class="op">(</span>info class_type<span class="op">)</span> <span class="op">-&gt;</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span> <span class="op">{</span></span>
-<span id="cb57-17"><a href="#cb57-17"></a>    <span class="kw">auto</span> subobjects <span class="op">=</span> bases_of<span class="op">(</span>class_type<span class="op">)</span>;</span>
-<span id="cb57-18"><a href="#cb57-18"></a>    subobjects<span class="op">.</span>append_range<span class="op">(</span>nonstatic_data_members_of<span class="op">(</span>class_type<span class="op">))</span>;</span>
-<span id="cb57-19"><a href="#cb57-19"></a>    <span class="cf">return</span> subobjects;</span>
-<span id="cb57-20"><a href="#cb57-20"></a>  <span class="op">}</span></span>
-<span id="cb57-21"><a href="#cb57-21"></a></span>
-<span id="cb57-22"><a href="#cb57-22"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> enumerators_of<span class="op">(</span>info enum_type<span class="op">)</span> <span class="op">-&gt;</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span>;</span>
-<span id="cb57-23"><a href="#cb57-23"></a><span class="op">}</span></span></code></pre></div>
+<div class="sourceCode" id="cb58"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb58-1"><a href="#cb58-1"></a><span class="kw">namespace</span> std<span class="op">::</span>meta <span class="op">{</span></span>
+<span id="cb58-2"><a href="#cb58-2"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="kw">typename</span> <span class="op">...</span>Fs<span class="op">&gt;</span></span>
+<span id="cb58-3"><a href="#cb58-3"></a>    <span class="kw">consteval</span> <span class="kw">auto</span> members_of<span class="op">(</span>info class_type, Fs <span class="op">...</span>filters<span class="op">)</span> <span class="op">-&gt;</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span>;</span>
+<span id="cb58-4"><a href="#cb58-4"></a></span>
+<span id="cb58-5"><a href="#cb58-5"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="kw">typename</span> <span class="op">...</span>Fs<span class="op">&gt;</span></span>
+<span id="cb58-6"><a href="#cb58-6"></a>    <span class="kw">consteval</span> <span class="kw">auto</span> bases_of<span class="op">(</span>info class_type, Fs <span class="op">...</span>filters<span class="op">)</span> <span class="op">-&gt;</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span>;</span>
+<span id="cb58-7"><a href="#cb58-7"></a></span>
+<span id="cb58-8"><a href="#cb58-8"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> static_data_members_of<span class="op">(</span>info class_type<span class="op">)</span> <span class="op">-&gt;</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span> <span class="op">{</span></span>
+<span id="cb58-9"><a href="#cb58-9"></a>    <span class="cf">return</span> members_of<span class="op">(</span>class_type, is_variable<span class="op">)</span>;</span>
+<span id="cb58-10"><a href="#cb58-10"></a>  <span class="op">}</span></span>
+<span id="cb58-11"><a href="#cb58-11"></a></span>
+<span id="cb58-12"><a href="#cb58-12"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> nonstatic_data_members_of<span class="op">(</span>info class_type<span class="op">)</span> <span class="op">-&gt;</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span> <span class="op">{</span></span>
+<span id="cb58-13"><a href="#cb58-13"></a>    <span class="cf">return</span> members_of<span class="op">(</span>class_type, is_nonstatic_data_member<span class="op">)</span>;</span>
+<span id="cb58-14"><a href="#cb58-14"></a>  <span class="op">}</span></span>
+<span id="cb58-15"><a href="#cb58-15"></a></span>
+<span id="cb58-16"><a href="#cb58-16"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> subobjects_of<span class="op">(</span>info class_type<span class="op">)</span> <span class="op">-&gt;</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span> <span class="op">{</span></span>
+<span id="cb58-17"><a href="#cb58-17"></a>    <span class="kw">auto</span> subobjects <span class="op">=</span> bases_of<span class="op">(</span>class_type<span class="op">)</span>;</span>
+<span id="cb58-18"><a href="#cb58-18"></a>    subobjects<span class="op">.</span>append_range<span class="op">(</span>nonstatic_data_members_of<span class="op">(</span>class_type<span class="op">))</span>;</span>
+<span id="cb58-19"><a href="#cb58-19"></a>    <span class="cf">return</span> subobjects;</span>
+<span id="cb58-20"><a href="#cb58-20"></a>  <span class="op">}</span></span>
+<span id="cb58-21"><a href="#cb58-21"></a></span>
+<span id="cb58-22"><a href="#cb58-22"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> enumerators_of<span class="op">(</span>info enum_type<span class="op">)</span> <span class="op">-&gt;</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span>;</span>
+<span id="cb58-23"><a href="#cb58-23"></a><span class="op">}</span></span></code></pre></div>
 </blockquote>
 <p>The template <code class="sourceCode cpp">members_of</code> returns a vector of reflections representing the direct members of the class type represented by its first argument. Any nonstatic data members appear in declaration order within that vector. Anonymous unions appear as a nonstatic data member of corresponding union type. If any <code class="sourceCode cpp">Filters<span class="op">...</span></code> argument is specified, a member is dropped from the result if any filter applied to that members reflection returns <code class="sourceCode cpp"><span class="kw">false</span></code>. E.g., <code class="sourceCode cpp">members_of<span class="op">(^</span>C, std<span class="op">::</span>meta<span class="op">::</span>is_type<span class="op">)</span></code> will only return types nested in the definition of <code class="sourceCode cpp">C</code> and <code class="sourceCode cpp">members_of<span class="op">(^</span>C, std<span class="op">::</span>meta<span class="op">::</span>is_type, std<span class="op">::</span>meta<span class="op">::</span>is_variable<span class="op">)</span></code> will return an empty vector since a member cannot be both a type and a variable.</p>
 <p>The template <code class="sourceCode cpp">bases_of</code> returns the direct base classes of the class type represented by its first argument, in declaration order.</p>
 <p><code class="sourceCode cpp">enumerators_of</code> returns the enumerator constants of the indicated enumeration type in declaration order.</p>
 <h3 data-number="4.4.10" id="substitute"><span class="header-section-number">4.4.10</span> <code class="sourceCode cpp">substitute</code><a href="#substitute" class="self-link"></a></h3>
 <blockquote>
-<div class="sourceCode" id="cb58"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb58-1"><a href="#cb58-1"></a><span class="kw">namespace</span> std<span class="op">::</span>meta <span class="op">{</span></span>
-<span id="cb58-2"><a href="#cb58-2"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> substitute<span class="op">(</span>info templ, span<span class="op">&lt;</span>info <span class="kw">const</span><span class="op">&gt;</span> args<span class="op">)</span> <span class="op">-&gt;</span> info;</span>
-<span id="cb58-3"><a href="#cb58-3"></a><span class="op">}</span></span></code></pre></div>
+<div class="sourceCode" id="cb59"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb59-1"><a href="#cb59-1"></a><span class="kw">namespace</span> std<span class="op">::</span>meta <span class="op">{</span></span>
+<span id="cb59-2"><a href="#cb59-2"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> substitute<span class="op">(</span>info templ, span<span class="op">&lt;</span>info <span class="kw">const</span><span class="op">&gt;</span> args<span class="op">)</span> <span class="op">-&gt;</span> info;</span>
+<span id="cb59-3"><a href="#cb59-3"></a><span class="op">}</span></span></code></pre></div>
 </blockquote>
 <p>Given a reflection for a template and reflections for template arguments that match that template, <code class="sourceCode cpp">substitute</code> returns a reflection for the entity obtained by substituting the given arguments in the template. If the template is a concept template, the result is a reflection of a constant of type <code class="sourceCode cpp"><span class="dt">bool</span></code>.</p>
 <p>For example:</p>
 <blockquote>
-<div class="sourceCode" id="cb59"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb59-1"><a href="#cb59-1"></a><span class="kw">constexpr</span> <span class="kw">auto</span> r <span class="op">=</span> substitute<span class="op">(^</span>std<span class="op">::</span>vector, std<span class="op">::</span>vector<span class="op">{^</span><span class="dt">int</span><span class="op">})</span>;</span>
-<span id="cb59-2"><a href="#cb59-2"></a><span class="kw">using</span> T <span class="op">=</span> <span class="op">[:</span>r<span class="op">:]</span>; <span class="co">// Ok, T is std::vector&lt;int&gt;</span></span></code></pre></div>
+<div class="sourceCode" id="cb60"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb60-1"><a href="#cb60-1"></a><span class="kw">constexpr</span> <span class="kw">auto</span> r <span class="op">=</span> substitute<span class="op">(^</span>std<span class="op">::</span>vector, std<span class="op">::</span>vector<span class="op">{^</span><span class="dt">int</span><span class="op">})</span>;</span>
+<span id="cb60-2"><a href="#cb60-2"></a><span class="kw">using</span> T <span class="op">=</span> <span class="op">[:</span>r<span class="op">:]</span>; <span class="co">// Ok, T is std::vector&lt;int&gt;</span></span></code></pre></div>
 </blockquote>
 <p>This process might kick off instantiations outside the immediate context, which can lead to the program being ill-formed.</p>
 <p>Note that the template is only substituted, not instantiated. For example:</p>
 <blockquote>
-<div class="sourceCode" id="cb60"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb60-1"><a href="#cb60-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">typename</span> T<span class="op">&gt;</span> <span class="kw">struct</span> S <span class="op">{</span> <span class="kw">typename</span> T<span class="op">::</span>X x; <span class="op">}</span>;</span>
-<span id="cb60-2"><a href="#cb60-2"></a></span>
-<span id="cb60-3"><a href="#cb60-3"></a><span class="kw">constexpr</span> <span class="kw">auto</span> r <span class="op">=</span> substitute<span class="op">(^</span>S, std<span class="op">::</span>vector<span class="op">{^</span><span class="dt">int</span><span class="op">})</span>;  <span class="co">// Okay.</span></span>
-<span id="cb60-4"><a href="#cb60-4"></a><span class="kw">typename</span><span class="op">[:</span>r<span class="op">:]</span> si;  <span class="co">// Error: T::X is invalid for T = int.</span></span></code></pre></div>
+<div class="sourceCode" id="cb61"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb61-1"><a href="#cb61-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">typename</span> T<span class="op">&gt;</span> <span class="kw">struct</span> S <span class="op">{</span> <span class="kw">typename</span> T<span class="op">::</span>X x; <span class="op">}</span>;</span>
+<span id="cb61-2"><a href="#cb61-2"></a></span>
+<span id="cb61-3"><a href="#cb61-3"></a><span class="kw">constexpr</span> <span class="kw">auto</span> r <span class="op">=</span> substitute<span class="op">(^</span>S, std<span class="op">::</span>vector<span class="op">{^</span><span class="dt">int</span><span class="op">})</span>;  <span class="co">// Okay.</span></span>
+<span id="cb61-4"><a href="#cb61-4"></a><span class="kw">typename</span><span class="op">[:</span>r<span class="op">:]</span> si;  <span class="co">// Error: T::X is invalid for T = int.</span></span></code></pre></div>
 </blockquote>
 <h3 data-number="4.4.11" id="reflect_invoke"><span class="header-section-number">4.4.11</span> <code class="sourceCode cpp">reflect_invoke</code><a href="#reflect_invoke" class="self-link"></a></h3>
 <blockquote>
-<div class="sourceCode" id="cb61"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb61-1"><a href="#cb61-1"></a><span class="kw">namespace</span> std<span class="op">::</span>meta <span class="op">{</span></span>
-<span id="cb61-2"><a href="#cb61-2"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> reflect_invoke<span class="op">(</span>info target, span<span class="op">&lt;</span>info <span class="kw">const</span><span class="op">&gt;</span> args<span class="op">)</span> <span class="op">-&gt;</span> info;</span>
-<span id="cb61-3"><a href="#cb61-3"></a><span class="op">}</span></span></code></pre></div>
+<div class="sourceCode" id="cb62"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb62-1"><a href="#cb62-1"></a><span class="kw">namespace</span> std<span class="op">::</span>meta <span class="op">{</span></span>
+<span id="cb62-2"><a href="#cb62-2"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> reflect_invoke<span class="op">(</span>info target, span<span class="op">&lt;</span>info <span class="kw">const</span><span class="op">&gt;</span> args<span class="op">)</span> <span class="op">-&gt;</span> info;</span>
+<span id="cb62-3"><a href="#cb62-3"></a><span class="op">}</span></span></code></pre></div>
 </blockquote>
 <p>This metafunction produces a reflection of the value returned by a call expression.</p>
 <p>Letting <code class="sourceCode cpp">F</code> be the entity reflected by <code class="sourceCode cpp">target</code>, and <code class="sourceCode cpp">A_0, <span class="op">...</span>, A_n</code> be the sequence of entities reflected by the values held by <code class="sourceCode cpp">args</code>: if the expression <code class="sourceCode cpp">F<span class="op">(</span>A_0, <span class="op">...</span>, A_N<span class="op">)</span></code> is a well-formed constant expression evaluating to a type that is not <code class="sourceCode cpp"><span class="dt">void</span></code>, and if every value in <code class="sourceCode cpp">args</code> is a reflection of a constant value, then <code class="sourceCode cpp">reflect_invoke<span class="op">(</span>target, args<span class="op">)</span></code> evaluates to a reflection of the constant value <code class="sourceCode cpp">F<span class="op">(</span>A_0, <span class="op">...</span>, A_N<span class="op">)</span></code>.</p>
 <p>For all other invocations, <code class="sourceCode cpp">reflect_invoke<span class="op">(</span>target, args<span class="op">)</span></code> is ill-formed.</p>
 <h3 data-number="4.4.12" id="value_oft"><span class="header-section-number">4.4.12</span> <code class="sourceCode cpp">value_of<span class="op">&lt;</span>T<span class="op">&gt;</span></code><a href="#value_oft" class="self-link"></a></h3>
 <blockquote>
-<div class="sourceCode" id="cb62"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb62-1"><a href="#cb62-1"></a><span class="kw">namespace</span> std<span class="op">::</span>meta <span class="op">{</span></span>
-<span id="cb62-2"><a href="#cb62-2"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="kw">typename</span> T<span class="op">&gt;</span> <span class="kw">consteval</span> <span class="kw">auto</span> value_of<span class="op">(</span>info<span class="op">)</span> <span class="op">-&gt;</span> T;</span>
-<span id="cb62-3"><a href="#cb62-3"></a><span class="op">}</span></span></code></pre></div>
+<div class="sourceCode" id="cb63"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb63-1"><a href="#cb63-1"></a><span class="kw">namespace</span> std<span class="op">::</span>meta <span class="op">{</span></span>
+<span id="cb63-2"><a href="#cb63-2"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="kw">typename</span> T<span class="op">&gt;</span> <span class="kw">consteval</span> <span class="kw">auto</span> value_of<span class="op">(</span>info<span class="op">)</span> <span class="op">-&gt;</span> T;</span>
+<span id="cb63-3"><a href="#cb63-3"></a><span class="op">}</span></span></code></pre></div>
 </blockquote>
 <p>If <code class="sourceCode cpp">r</code> is a reflection for a constant-expression or a constant-valued entity of type <code class="sourceCode cpp">T</code>, <code class="sourceCode cpp">value_of<span class="op">&lt;</span>T<span class="op">&gt;(</span>r<span class="op">)</span></code> evaluates to that constant value.</p>
 <p>If <code class="sourceCode cpp">r</code> is a reflection for a variable of non-reference type <code class="sourceCode cpp">T</code>, <code class="sourceCode cpp">value_of<span class="op">&lt;</span>T<span class="op">&amp;&gt;(</span>r<span class="op">)</span></code> and <code class="sourceCode cpp">value_of<span class="op">&lt;</span>T <span class="kw">const</span><span class="op">&amp;&gt;(</span>r<span class="op">)</span></code> are lvalues referring to that variable. If the variable is usable in constant expressions [expr.const], <code class="sourceCode cpp">value_of<span class="op">&lt;</span>T<span class="op">&gt;(</span>r<span class="op">)</span></code> evaluates to its value.</p>
@@ -2034,85 +2073,85 @@ <h3 data-number="4.4.12" id="value_oft"><span class="header-section-number">4.4.
 <p>The function template <code class="sourceCode cpp">value_of</code> may feel similar to splicers, but unlike splicers it does not require its operand to be a constant-expression itself. Also unlike splicers, it requires knowledge of the type associated with the entity reflected by its operand.</p>
 <h3 data-number="4.4.13" id="test_type-test_types"><span class="header-section-number">4.4.13</span> <code class="sourceCode cpp">test_type</code>, <code class="sourceCode cpp">test_types</code><a href="#test_type-test_types" class="self-link"></a></h3>
 <blockquote>
-<div class="sourceCode" id="cb63"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb63-1"><a href="#cb63-1"></a><span class="kw">namespace</span> std<span class="op">::</span>meta <span class="op">{</span></span>
-<span id="cb63-2"><a href="#cb63-2"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> test_type<span class="op">(</span>info templ, info type<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span> <span class="op">{</span></span>
-<span id="cb63-3"><a href="#cb63-3"></a>    <span class="cf">return</span> test_types<span class="op">(</span>templ, <span class="op">{</span>type<span class="op">})</span>;</span>
-<span id="cb63-4"><a href="#cb63-4"></a>  <span class="op">}</span></span>
-<span id="cb63-5"><a href="#cb63-5"></a></span>
-<span id="cb63-6"><a href="#cb63-6"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> test_types<span class="op">(</span>info templ, span<span class="op">&lt;</span>info <span class="kw">const</span><span class="op">&gt;</span> types<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span> <span class="op">{</span></span>
-<span id="cb63-7"><a href="#cb63-7"></a>    <span class="cf">return</span> value_of<span class="op">&lt;</span><span class="dt">bool</span><span class="op">&gt;(</span>substitute<span class="op">(</span>templ, types<span class="op">))</span>;</span>
-<span id="cb63-8"><a href="#cb63-8"></a>  <span class="op">}</span></span>
-<span id="cb63-9"><a href="#cb63-9"></a><span class="op">}</span></span></code></pre></div>
+<div class="sourceCode" id="cb64"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb64-1"><a href="#cb64-1"></a><span class="kw">namespace</span> std<span class="op">::</span>meta <span class="op">{</span></span>
+<span id="cb64-2"><a href="#cb64-2"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> test_type<span class="op">(</span>info templ, info type<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span> <span class="op">{</span></span>
+<span id="cb64-3"><a href="#cb64-3"></a>    <span class="cf">return</span> test_types<span class="op">(</span>templ, <span class="op">{</span>type<span class="op">})</span>;</span>
+<span id="cb64-4"><a href="#cb64-4"></a>  <span class="op">}</span></span>
+<span id="cb64-5"><a href="#cb64-5"></a></span>
+<span id="cb64-6"><a href="#cb64-6"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> test_types<span class="op">(</span>info templ, span<span class="op">&lt;</span>info <span class="kw">const</span><span class="op">&gt;</span> types<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span> <span class="op">{</span></span>
+<span id="cb64-7"><a href="#cb64-7"></a>    <span class="cf">return</span> value_of<span class="op">&lt;</span><span class="dt">bool</span><span class="op">&gt;(</span>substitute<span class="op">(</span>templ, types<span class="op">))</span>;</span>
+<span id="cb64-8"><a href="#cb64-8"></a>  <span class="op">}</span></span>
+<span id="cb64-9"><a href="#cb64-9"></a><span class="op">}</span></span></code></pre></div>
 </blockquote>
 <p>This utility translates existing metaprogramming predicates (expressed as constexpr variable templates or concept templates) to the reflection domain. For example:</p>
 <blockquote>
-<div class="sourceCode" id="cb64"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb64-1"><a href="#cb64-1"></a><span class="kw">struct</span> S <span class="op">{}</span>;</span>
-<span id="cb64-2"><a href="#cb64-2"></a><span class="kw">static_assert</span><span class="op">(</span>test_type<span class="op">(^</span>std<span class="op">::</span>is_class_v, <span class="op">^</span>S<span class="op">))</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb65"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb65-1"><a href="#cb65-1"></a><span class="kw">struct</span> S <span class="op">{}</span>;</span>
+<span id="cb65-2"><a href="#cb65-2"></a><span class="kw">static_assert</span><span class="op">(</span>test_type<span class="op">(^</span>std<span class="op">::</span>is_class_v, <span class="op">^</span>S<span class="op">))</span>;</span></code></pre></div>
 </blockquote>
 <p>An implementation is permitted to recognize standard predicate templates and implement <code class="sourceCode cpp">test_type</code> without actually instantiating the predicate template. In fact, that is recommended practice.</p>
 <h3 data-number="4.4.14" id="reflect_value"><span class="header-section-number">4.4.14</span> <code class="sourceCode cpp">reflect_value</code><a href="#reflect_value" class="self-link"></a></h3>
 <blockquote>
-<div class="sourceCode" id="cb65"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb65-1"><a href="#cb65-1"></a><span class="kw">namespace</span> std<span class="op">::</span>meta <span class="op">{</span></span>
-<span id="cb65-2"><a href="#cb65-2"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="kw">typename</span> T<span class="op">&gt;</span> <span class="kw">consteval</span> <span class="kw">auto</span> reflect_value<span class="op">(</span>T value<span class="op">)</span> <span class="op">-&gt;</span> info;</span>
-<span id="cb65-3"><a href="#cb65-3"></a><span class="op">}</span></span></code></pre></div>
+<div class="sourceCode" id="cb66"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb66-1"><a href="#cb66-1"></a><span class="kw">namespace</span> std<span class="op">::</span>meta <span class="op">{</span></span>
+<span id="cb66-2"><a href="#cb66-2"></a>  <span class="kw">template</span><span class="op">&lt;</span><span class="kw">typename</span> T<span class="op">&gt;</span> <span class="kw">consteval</span> <span class="kw">auto</span> reflect_value<span class="op">(</span>T value<span class="op">)</span> <span class="op">-&gt;</span> info;</span>
+<span id="cb66-3"><a href="#cb66-3"></a><span class="op">}</span></span></code></pre></div>
 </blockquote>
 <p>This metafunction produces a reflection representing the constant value of the operand.</p>
 <h3 data-number="4.4.15" id="data_member_spec-define_class"><span class="header-section-number">4.4.15</span> <code class="sourceCode cpp">data_member_spec</code>, <code class="sourceCode cpp">define_class</code><a href="#data_member_spec-define_class" class="self-link"></a></h3>
 <blockquote>
-<div class="sourceCode" id="cb66"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb66-1"><a href="#cb66-1"></a><span class="kw">namespace</span> std<span class="op">::</span>meta <span class="op">{</span></span>
-<span id="cb66-2"><a href="#cb66-2"></a>  <span class="kw">struct</span> data_member_options_t <span class="op">{</span></span>
-<span id="cb66-3"><a href="#cb66-3"></a>    optional<span class="op">&lt;</span>string_view<span class="op">&gt;</span> name;</span>
-<span id="cb66-4"><a href="#cb66-4"></a>    <span class="dt">bool</span> is_static <span class="op">=</span> <span class="kw">false</span>;</span>
-<span id="cb66-5"><a href="#cb66-5"></a>    optional<span class="op">&lt;</span><span class="dt">int</span><span class="op">&gt;</span> alignment;</span>
-<span id="cb66-6"><a href="#cb66-6"></a>    optional<span class="op">&lt;</span><span class="dt">int</span><span class="op">&gt;</span> width;</span>
-<span id="cb66-7"><a href="#cb66-7"></a>  <span class="op">}</span>;</span>
-<span id="cb66-8"><a href="#cb66-8"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> data_member_spec<span class="op">(</span>info type,</span>
-<span id="cb66-9"><a href="#cb66-9"></a>                                  data_member_options_t options <span class="op">=</span> <span class="op">{})</span> <span class="op">-&gt;</span> info;</span>
-<span id="cb66-10"><a href="#cb66-10"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> define_class<span class="op">(</span>info class_type, span<span class="op">&lt;</span>info <span class="kw">const</span><span class="op">&gt;)</span> <span class="op">-&gt;</span> info;</span>
-<span id="cb66-11"><a href="#cb66-11"></a><span class="op">}</span></span></code></pre></div>
+<div class="sourceCode" id="cb67"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb67-1"><a href="#cb67-1"></a><span class="kw">namespace</span> std<span class="op">::</span>meta <span class="op">{</span></span>
+<span id="cb67-2"><a href="#cb67-2"></a>  <span class="kw">struct</span> data_member_options_t <span class="op">{</span></span>
+<span id="cb67-3"><a href="#cb67-3"></a>    optional<span class="op">&lt;</span>string_view<span class="op">&gt;</span> name;</span>
+<span id="cb67-4"><a href="#cb67-4"></a>    <span class="dt">bool</span> is_static <span class="op">=</span> <span class="kw">false</span>;</span>
+<span id="cb67-5"><a href="#cb67-5"></a>    optional<span class="op">&lt;</span><span class="dt">int</span><span class="op">&gt;</span> alignment;</span>
+<span id="cb67-6"><a href="#cb67-6"></a>    optional<span class="op">&lt;</span><span class="dt">int</span><span class="op">&gt;</span> width;</span>
+<span id="cb67-7"><a href="#cb67-7"></a>  <span class="op">}</span>;</span>
+<span id="cb67-8"><a href="#cb67-8"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> data_member_spec<span class="op">(</span>info type,</span>
+<span id="cb67-9"><a href="#cb67-9"></a>                                  data_member_options_t options <span class="op">=</span> <span class="op">{})</span> <span class="op">-&gt;</span> info;</span>
+<span id="cb67-10"><a href="#cb67-10"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> define_class<span class="op">(</span>info class_type, span<span class="op">&lt;</span>info <span class="kw">const</span><span class="op">&gt;)</span> <span class="op">-&gt;</span> info;</span>
+<span id="cb67-11"><a href="#cb67-11"></a><span class="op">}</span></span></code></pre></div>
 </blockquote>
 <p><code class="sourceCode cpp">data_member_spec</code> returns a reflection of a description of a data member of given type. Optional alignment, bit-field-width, static-ness, and name can be provided as well. If no <code class="sourceCode cpp">name</code> is provided, the name of the data member is unspecified. If <code class="sourceCode cpp">is_static</code> is <code class="sourceCode cpp"><span class="kw">true</span></code>, the data member is declared <code class="sourceCode cpp"><span class="kw">static</span></code>.</p>
 <p><code class="sourceCode cpp">define_class</code> takes the reflection of an incomplete class/struct/union type and a range of reflections of data member descriptions and it completes the given class type with data members as described (in the given order). The given reflection is returned. For now, only data member reflections are supported (via <code class="sourceCode cpp">data_member_spec</code>) but the API takes in a range of <code class="sourceCode cpp">info</code> anticipating expanding this in the near future.</p>
 <p>For example:</p>
 <blockquote>
-<div class="sourceCode" id="cb67"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb67-1"><a href="#cb67-1"></a><span class="kw">union</span> U;</span>
-<span id="cb67-2"><a href="#cb67-2"></a><span class="kw">static_assert</span><span class="op">(</span>is_type<span class="op">(</span>define_class<span class="op">(^</span>U, <span class="op">{</span></span>
-<span id="cb67-3"><a href="#cb67-3"></a>  data_member_spec<span class="op">(^</span><span class="dt">int</span><span class="op">)</span>,</span>
-<span id="cb67-4"><a href="#cb67-4"></a>  data_member_spec<span class="op">(^</span><span class="dt">char</span><span class="op">)</span>,</span>
-<span id="cb67-5"><a href="#cb67-5"></a>  data_member_spec<span class="op">(^</span><span class="dt">double</span><span class="op">)</span>,</span>
-<span id="cb67-6"><a href="#cb67-6"></a><span class="op">})))</span>;</span>
-<span id="cb67-7"><a href="#cb67-7"></a></span>
-<span id="cb67-8"><a href="#cb67-8"></a><span class="co">// U is now defined to the equivalent of</span></span>
-<span id="cb67-9"><a href="#cb67-9"></a><span class="co">// union U {</span></span>
-<span id="cb67-10"><a href="#cb67-10"></a><span class="co">//   int <em>_0</em>;</span></span>
-<span id="cb67-11"><a href="#cb67-11"></a><span class="co">//   char <em>_1</em>;</span></span>
-<span id="cb67-12"><a href="#cb67-12"></a><span class="co">//   double <em>_2</em>;</span></span>
-<span id="cb67-13"><a href="#cb67-13"></a><span class="co">// };</span></span>
-<span id="cb67-14"><a href="#cb67-14"></a></span>
-<span id="cb67-15"><a href="#cb67-15"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">typename</span> T<span class="op">&gt;</span> <span class="kw">struct</span> S;</span>
-<span id="cb67-16"><a href="#cb67-16"></a><span class="kw">constexpr</span> <span class="kw">auto</span> U <span class="op">=</span> define_class<span class="op">(^</span>S<span class="op">&lt;</span><span class="dt">int</span><span class="op">&gt;</span>, <span class="op">{</span></span>
-<span id="cb67-17"><a href="#cb67-17"></a>  data_member_spec<span class="op">(^</span><span class="dt">int</span>, <span class="op">{.</span>name<span class="op">=</span><span class="st">&quot;i&quot;</span>, <span class="op">.</span>align<span class="op">=</span><span class="dv">64</span><span class="op">})</span>,</span>
-<span id="cb67-18"><a href="#cb67-18"></a>  data_member_spec<span class="op">(^</span><span class="dt">int</span>, <span class="op">{.</span>name<span class="op">=</span><span class="st">&quot;j&quot;</span>, <span class="op">.</span>align<span class="op">=</span><span class="dv">64</span><span class="op">})</span>,</span>
-<span id="cb67-19"><a href="#cb67-19"></a><span class="op">})</span>;</span>
-<span id="cb67-20"><a href="#cb67-20"></a></span>
-<span id="cb67-21"><a href="#cb67-21"></a><span class="co">// S&lt;int&gt; is now defined to the equivalent of</span></span>
-<span id="cb67-22"><a href="#cb67-22"></a><span class="co">// template&lt;&gt; struct S&lt;int&gt; {</span></span>
-<span id="cb67-23"><a href="#cb67-23"></a><span class="co">//   alignas(64) int i;</span></span>
-<span id="cb67-24"><a href="#cb67-24"></a><span class="co">//   alignas(64) int j;</span></span>
-<span id="cb67-25"><a href="#cb67-25"></a><span class="co">// };</span></span></code></pre></div>
+<div class="sourceCode" id="cb68"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb68-1"><a href="#cb68-1"></a><span class="kw">union</span> U;</span>
+<span id="cb68-2"><a href="#cb68-2"></a><span class="kw">static_assert</span><span class="op">(</span>is_type<span class="op">(</span>define_class<span class="op">(^</span>U, <span class="op">{</span></span>
+<span id="cb68-3"><a href="#cb68-3"></a>  data_member_spec<span class="op">(^</span><span class="dt">int</span><span class="op">)</span>,</span>
+<span id="cb68-4"><a href="#cb68-4"></a>  data_member_spec<span class="op">(^</span><span class="dt">char</span><span class="op">)</span>,</span>
+<span id="cb68-5"><a href="#cb68-5"></a>  data_member_spec<span class="op">(^</span><span class="dt">double</span><span class="op">)</span>,</span>
+<span id="cb68-6"><a href="#cb68-6"></a><span class="op">})))</span>;</span>
+<span id="cb68-7"><a href="#cb68-7"></a></span>
+<span id="cb68-8"><a href="#cb68-8"></a><span class="co">// U is now defined to the equivalent of</span></span>
+<span id="cb68-9"><a href="#cb68-9"></a><span class="co">// union U {</span></span>
+<span id="cb68-10"><a href="#cb68-10"></a><span class="co">//   int <em>_0</em>;</span></span>
+<span id="cb68-11"><a href="#cb68-11"></a><span class="co">//   char <em>_1</em>;</span></span>
+<span id="cb68-12"><a href="#cb68-12"></a><span class="co">//   double <em>_2</em>;</span></span>
+<span id="cb68-13"><a href="#cb68-13"></a><span class="co">// };</span></span>
+<span id="cb68-14"><a href="#cb68-14"></a></span>
+<span id="cb68-15"><a href="#cb68-15"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">typename</span> T<span class="op">&gt;</span> <span class="kw">struct</span> S;</span>
+<span id="cb68-16"><a href="#cb68-16"></a><span class="kw">constexpr</span> <span class="kw">auto</span> U <span class="op">=</span> define_class<span class="op">(^</span>S<span class="op">&lt;</span><span class="dt">int</span><span class="op">&gt;</span>, <span class="op">{</span></span>
+<span id="cb68-17"><a href="#cb68-17"></a>  data_member_spec<span class="op">(^</span><span class="dt">int</span>, <span class="op">{.</span>name<span class="op">=</span><span class="st">&quot;i&quot;</span>, <span class="op">.</span>align<span class="op">=</span><span class="dv">64</span><span class="op">})</span>,</span>
+<span id="cb68-18"><a href="#cb68-18"></a>  data_member_spec<span class="op">(^</span><span class="dt">int</span>, <span class="op">{.</span>name<span class="op">=</span><span class="st">&quot;j&quot;</span>, <span class="op">.</span>align<span class="op">=</span><span class="dv">64</span><span class="op">})</span>,</span>
+<span id="cb68-19"><a href="#cb68-19"></a><span class="op">})</span>;</span>
+<span id="cb68-20"><a href="#cb68-20"></a></span>
+<span id="cb68-21"><a href="#cb68-21"></a><span class="co">// S&lt;int&gt; is now defined to the equivalent of</span></span>
+<span id="cb68-22"><a href="#cb68-22"></a><span class="co">// template&lt;&gt; struct S&lt;int&gt; {</span></span>
+<span id="cb68-23"><a href="#cb68-23"></a><span class="co">//   alignas(64) int i;</span></span>
+<span id="cb68-24"><a href="#cb68-24"></a><span class="co">//   alignas(64) int j;</span></span>
+<span id="cb68-25"><a href="#cb68-25"></a><span class="co">// };</span></span></code></pre></div>
 </blockquote>
 <p>When defining a <code class="sourceCode cpp"><span class="kw">union</span></code>, if one of the alternatives has a non-trivial destructor, the defined union will <em>still</em> have a destructor provided - that simply does nothing. This allows implementing <a href="#a-simple-variant-type">variant</a> without having to further extend support in <code class="sourceCode cpp">define_class</code> for member functions.</p>
 <h3 data-number="4.4.16" id="data-layout-reflection"><span class="header-section-number">4.4.16</span> Data Layout Reflection<a href="#data-layout-reflection" class="self-link"></a></h3>
 <blockquote>
-<div class="sourceCode" id="cb68"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb68-1"><a href="#cb68-1"></a><span class="kw">namespace</span> std<span class="op">::</span>meta <span class="op">{</span></span>
-<span id="cb68-2"><a href="#cb68-2"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> offset_of<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">size_t</span>;</span>
-<span id="cb68-3"><a href="#cb68-3"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> size_of<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">size_t</span>;</span>
-<span id="cb68-4"><a href="#cb68-4"></a></span>
-<span id="cb68-5"><a href="#cb68-5"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> bit_offset_of<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">size_t</span>;</span>
-<span id="cb68-6"><a href="#cb68-6"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> bit_size_of<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">size_t</span>;</span>
-<span id="cb68-7"><a href="#cb68-7"></a></span>
-<span id="cb68-8"><a href="#cb68-8"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> alignment_of<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">size_t</span>;</span>
-<span id="cb68-9"><a href="#cb68-9"></a><span class="op">}</span></span></code></pre></div>
+<div class="sourceCode" id="cb69"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb69-1"><a href="#cb69-1"></a><span class="kw">namespace</span> std<span class="op">::</span>meta <span class="op">{</span></span>
+<span id="cb69-2"><a href="#cb69-2"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> offset_of<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">size_t</span>;</span>
+<span id="cb69-3"><a href="#cb69-3"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> size_of<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">size_t</span>;</span>
+<span id="cb69-4"><a href="#cb69-4"></a></span>
+<span id="cb69-5"><a href="#cb69-5"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> bit_offset_of<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">size_t</span>;</span>
+<span id="cb69-6"><a href="#cb69-6"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> bit_size_of<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">size_t</span>;</span>
+<span id="cb69-7"><a href="#cb69-7"></a></span>
+<span id="cb69-8"><a href="#cb69-8"></a>  <span class="kw">consteval</span> <span class="kw">auto</span> alignment_of<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">size_t</span>;</span>
+<span id="cb69-9"><a href="#cb69-9"></a><span class="op">}</span></span></code></pre></div>
 </blockquote>
 <h3 data-number="4.4.17" id="other-type-traits"><span class="header-section-number">4.4.17</span> Other Type Traits<a href="#other-type-traits" class="self-link"></a></h3>
 <p>There is a question of whether all the type traits should be provided in <code class="sourceCode cpp">std<span class="op">::</span>meta</code>. For instance, a few examples in this paper use <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span>remove_cvref<span class="op">(</span>t<span class="op">)</span></code> as if that exists. Technically, the functionality isn’t strictly necessary - since it can be provided indirectly:</p>
@@ -2129,13 +2168,13 @@ <h3 data-number="4.4.17" id="other-type-traits"><span class="header-section-numb
 </thead>
 <tbody>
 <tr class="odd">
-<td><div class="sourceCode" id="cb69"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb69-1"><a href="#cb69-1"></a>std<span class="op">::</span>meta<span class="op">::</span>remove_cvref<span class="op">(</span>type<span class="op">)</span></span></code></pre></div></td>
-<td><div class="sourceCode" id="cb70"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb70-1"><a href="#cb70-1"></a>std<span class="op">::</span>meta<span class="op">::</span>substitute<span class="op">(^</span>std<span class="op">::</span>remove_cvref_t, <span class="op">{</span>type<span class="op">})</span></span></code></pre></div></td>
+<td><div class="sourceCode" id="cb70"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb70-1"><a href="#cb70-1"></a>std<span class="op">::</span>meta<span class="op">::</span>remove_cvref<span class="op">(</span>type<span class="op">)</span></span></code></pre></div></td>
+<td><div class="sourceCode" id="cb71"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb71-1"><a href="#cb71-1"></a>std<span class="op">::</span>meta<span class="op">::</span>substitute<span class="op">(^</span>std<span class="op">::</span>remove_cvref_t, <span class="op">{</span>type<span class="op">})</span></span></code></pre></div></td>
 </tr>
 <tr class="even">
-<td><div class="sourceCode" id="cb71"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb71-1"><a href="#cb71-1"></a>std<span class="op">::</span>meta<span class="op">::</span>is_const<span class="op">(</span>type<span class="op">)</span></span></code></pre></div></td>
-<td><div class="sourceCode" id="cb72"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb72-1"><a href="#cb72-1"></a>std<span class="op">::</span>meta<span class="op">::</span>value_of<span class="op">&lt;</span><span class="dt">bool</span><span class="op">&gt;(</span>std<span class="op">::</span>meta<span class="op">::</span>substitute<span class="op">(^</span>std<span class="op">::</span>is_const_v, <span class="op">{</span>type<span class="op">}))</span></span>
-<span id="cb72-2"><a href="#cb72-2"></a>std<span class="op">::</span>meta<span class="op">::</span>test_type<span class="op">(^</span>std<span class="op">::</span>is_const_v, type<span class="op">)</span></span></code></pre></div></td>
+<td><div class="sourceCode" id="cb72"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb72-1"><a href="#cb72-1"></a>std<span class="op">::</span>meta<span class="op">::</span>is_const<span class="op">(</span>type<span class="op">)</span></span></code></pre></div></td>
+<td><div class="sourceCode" id="cb73"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb73-1"><a href="#cb73-1"></a>std<span class="op">::</span>meta<span class="op">::</span>value_of<span class="op">&lt;</span><span class="dt">bool</span><span class="op">&gt;(</span>std<span class="op">::</span>meta<span class="op">::</span>substitute<span class="op">(^</span>std<span class="op">::</span>is_const_v, <span class="op">{</span>type<span class="op">}))</span></span>
+<span id="cb73-2"><a href="#cb73-2"></a>std<span class="op">::</span>meta<span class="op">::</span>test_type<span class="op">(^</span>std<span class="op">::</span>is_const_v, type<span class="op">)</span></span></code></pre></div></td>
 </tr>
 </tbody>
 </table>
@@ -2161,16 +2200,16 @@ <h3 data-number="5.1.2" id="lex.pptoken-preprocessing-tokens"><span class="heade
 <h3 data-number="5.1.3" id="lex.operators-operators-and-punctuators"><span class="header-section-number">5.1.3</span> [lex.operators] Operators and punctuators<a href="#lex.operators-operators-and-punctuators" class="self-link"></a></h3>
 <p>Change the grammar for <code class="sourceCode cpp"><em>operator-or-punctuator</em></code> in paragraph 1 of <span>5.12 <a href="https://wg21.link/lex.operators">[lex.operators]</a></span> to include splicer delimiters:</p>
 <blockquote>
-<div class="sourceCode" id="cb73"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb73-1"><a href="#cb73-1"></a>  <em>operator-or-punctuator</em>: <em>one of</em></span>
-<span id="cb73-2"><a href="#cb73-2"></a>         {        }        [        ]        (        )        <span class="addu"><code class="sourceCode cpp"><span class="op">[:</span>        <span class="op">:]</span></code></span></span>
-<span id="cb73-3"><a href="#cb73-3"></a>         &lt;:       :&gt;       &lt;%       %&gt;       ;        :        ...</span>
-<span id="cb73-4"><a href="#cb73-4"></a>         ?        ::       .       .*        -&gt;       -&gt;*      ~</span>
-<span id="cb73-5"><a href="#cb73-5"></a>         !        +        -        *        /        %        ^        &amp;        |</span>
-<span id="cb73-6"><a href="#cb73-6"></a>         =        +=       -=       *=       /=       %=       ^=       &amp;=       |=</span>
-<span id="cb73-7"><a href="#cb73-7"></a>         ==       !=       &lt;        &gt;        &lt;=       &gt;=       &lt;=&gt;      &amp;&amp;       ||</span>
-<span id="cb73-8"><a href="#cb73-8"></a>         &lt;&lt;       &gt;&gt;       &lt;&lt;=      &gt;&gt;=      ++       --       ,</span>
-<span id="cb73-9"><a href="#cb73-9"></a>         and      or       xor      not      bitand   bitor    compl</span>
-<span id="cb73-10"><a href="#cb73-10"></a>         and_eq   or_eq    xor_eq   not_eq</span></code></pre></div>
+<div class="sourceCode" id="cb74"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb74-1"><a href="#cb74-1"></a>  <em>operator-or-punctuator</em>: <em>one of</em></span>
+<span id="cb74-2"><a href="#cb74-2"></a>         {        }        [        ]        (        )        <span class="addu"><code class="sourceCode cpp"><span class="op">[:</span>        <span class="op">:]</span></code></span></span>
+<span id="cb74-3"><a href="#cb74-3"></a>         &lt;:       :&gt;       &lt;%       %&gt;       ;        :        ...</span>
+<span id="cb74-4"><a href="#cb74-4"></a>         ?        ::       .       .*        -&gt;       -&gt;*      ~</span>
+<span id="cb74-5"><a href="#cb74-5"></a>         !        +        -        *        /        %        ^        &amp;        |</span>
+<span id="cb74-6"><a href="#cb74-6"></a>         =        +=       -=       *=       /=       %=       ^=       &amp;=       |=</span>
+<span id="cb74-7"><a href="#cb74-7"></a>         ==       !=       &lt;        &gt;        &lt;=       &gt;=       &lt;=&gt;      &amp;&amp;       ||</span>
+<span id="cb74-8"><a href="#cb74-8"></a>         &lt;&lt;       &gt;&gt;       &lt;&lt;=      &gt;&gt;=      ++       --       ,</span>
+<span id="cb74-9"><a href="#cb74-9"></a>         and      or       xor      not      bitand   bitor    compl</span>
+<span id="cb74-10"><a href="#cb74-10"></a>         and_eq   or_eq    xor_eq   not_eq</span></code></pre></div>
 </blockquote>
 <h3 data-number="5.1.4" id="basic.types.general"><span class="header-section-number">5.1.4</span> [basic.types.general]<a href="#basic.types.general" class="self-link"></a></h3>
 <p>Change the first sentence in paragraph 9 of <span>6.8.1 <a href="https://wg21.link/basic.types.general">[basic.types.general]</a></span> as follows:</p>
@@ -2230,33 +2269,33 @@ <h3 data-number="5.1.8" id="expr.prim-primary-expressions"><span class="header-s
 <p>Change the grammar for <code class="sourceCode cpp"><em>primary-expression</em></code> in <span>7.5 <a href="https://wg21.link/expr.prim">[expr.prim]</a></span> as follows:</p>
 <blockquote>
 <div>
-<div class="sourceCode" id="cb74"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb74-1"><a href="#cb74-1"></a>  <em>primary-expression</em>:</span>
-<span id="cb74-2"><a href="#cb74-2"></a>     <em>literal</em></span>
-<span id="cb74-3"><a href="#cb74-3"></a>     this</span>
-<span id="cb74-4"><a href="#cb74-4"></a>     ( <em>expression</em> )</span>
-<span id="cb74-5"><a href="#cb74-5"></a>     <em>id-expression</em></span>
-<span id="cb74-6"><a href="#cb74-6"></a>     <em>lambda-expression</em></span>
-<span id="cb74-7"><a href="#cb74-7"></a>     <em>fold-expression</em></span>
-<span id="cb74-8"><a href="#cb74-8"></a>     <em>requires-expression</em></span>
-<span id="cb74-9"><a href="#cb74-9"></a><span class="va">+    [: <em>constant-expression</em> :]</span></span>
-<span id="cb74-10"><a href="#cb74-10"></a><span class="va">+    template[: <em>constant-expression</em> :] &lt; <em>template-argument-list</em><sub><em>opt</em></sub> &gt;</span></span></code></pre></div>
+<div class="sourceCode" id="cb75"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb75-1"><a href="#cb75-1"></a>  <em>primary-expression</em>:</span>
+<span id="cb75-2"><a href="#cb75-2"></a>     <em>literal</em></span>
+<span id="cb75-3"><a href="#cb75-3"></a>     this</span>
+<span id="cb75-4"><a href="#cb75-4"></a>     ( <em>expression</em> )</span>
+<span id="cb75-5"><a href="#cb75-5"></a>     <em>id-expression</em></span>
+<span id="cb75-6"><a href="#cb75-6"></a>     <em>lambda-expression</em></span>
+<span id="cb75-7"><a href="#cb75-7"></a>     <em>fold-expression</em></span>
+<span id="cb75-8"><a href="#cb75-8"></a>     <em>requires-expression</em></span>
+<span id="cb75-9"><a href="#cb75-9"></a><span class="va">+    [: <em>constant-expression</em> :]</span></span>
+<span id="cb75-10"><a href="#cb75-10"></a><span class="va">+    template[: <em>constant-expression</em> :] &lt; <em>template-argument-list</em><sub><em>opt</em></sub> &gt;</span></span></code></pre></div>
 </div>
 </blockquote>
 <h3 data-number="5.1.9" id="expr.prim.id.qual-qualified-names"><span class="header-section-number">5.1.9</span> [expr.prim.id.qual] Qualified names<a href="#expr.prim.id.qual-qualified-names" class="self-link"></a></h3>
 <p>Add a production to the grammar for <code class="sourceCode cpp"><em>nested-name-specifier</em></code> as follows:</p>
 <blockquote>
 <div>
-<div class="sourceCode" id="cb75"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb75-1"><a href="#cb75-1"></a>  <em>nested-name-specifier</em>:</span>
-<span id="cb75-2"><a href="#cb75-2"></a>      ::</span>
-<span id="cb75-3"><a href="#cb75-3"></a>      <em>type-name</em> ::</span>
-<span id="cb75-4"><a href="#cb75-4"></a>      <em>namespace-name</em> ::</span>
-<span id="cb75-5"><a href="#cb75-5"></a>      <em>computed-type-specifier</em> ::</span>
-<span id="cb75-6"><a href="#cb75-6"></a><span class="va">+     <em>splice-name-qualifier</em> ::</span></span>
-<span id="cb75-7"><a href="#cb75-7"></a>      <em>nested-name-specifier</em> <em>identifier</em> ::</span>
-<span id="cb75-8"><a href="#cb75-8"></a>      <em>nested-name-specifier</em> template<sub><em>opt</em></sub> <em>simple-template-id</em> ::</span>
-<span id="cb75-9"><a href="#cb75-9"></a><span class="va">+</span></span>
-<span id="cb75-10"><a href="#cb75-10"></a><span class="va">+ <em>splice-name-qualifier</em>:</span></span>
-<span id="cb75-11"><a href="#cb75-11"></a><span class="va">+     [: <em>constant-expression</em> :]</span></span></code></pre></div>
+<div class="sourceCode" id="cb76"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb76-1"><a href="#cb76-1"></a>  <em>nested-name-specifier</em>:</span>
+<span id="cb76-2"><a href="#cb76-2"></a>      ::</span>
+<span id="cb76-3"><a href="#cb76-3"></a>      <em>type-name</em> ::</span>
+<span id="cb76-4"><a href="#cb76-4"></a>      <em>namespace-name</em> ::</span>
+<span id="cb76-5"><a href="#cb76-5"></a>      <em>computed-type-specifier</em> ::</span>
+<span id="cb76-6"><a href="#cb76-6"></a><span class="va">+     <em>splice-name-qualifier</em> ::</span></span>
+<span id="cb76-7"><a href="#cb76-7"></a>      <em>nested-name-specifier</em> <em>identifier</em> ::</span>
+<span id="cb76-8"><a href="#cb76-8"></a>      <em>nested-name-specifier</em> template<sub><em>opt</em></sub> <em>simple-template-id</em> ::</span>
+<span id="cb76-9"><a href="#cb76-9"></a><span class="va">+</span></span>
+<span id="cb76-10"><a href="#cb76-10"></a><span class="va">+ <em>splice-name-qualifier</em>:</span></span>
+<span id="cb76-11"><a href="#cb76-11"></a><span class="va">+     [: <em>constant-expression</em> :]</span></span></code></pre></div>
 </div>
 </blockquote>
 <p>Extend <span>7.5.4.3 <a href="https://wg21.link/expr.prim.id.qual">[expr.prim.id.qual]</a></span>/1 to also cover splices:</p>
@@ -2284,15 +2323,15 @@ <h3 data-number="5.1.11" id="expr.unary.general"><span class="header-section-num
 <blockquote>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_20" id="pnum_20">1</a></span> Expressions with unary operators group right-to-left.</p>
 <div>
-<div class="sourceCode" id="cb76"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb76-1"><a href="#cb76-1"></a>  <em>unary-expression</em>:</span>
-<span id="cb76-2"><a href="#cb76-2"></a>     ...</span>
-<span id="cb76-3"><a href="#cb76-3"></a>     <em>delete-expression</em></span>
-<span id="cb76-4"><a href="#cb76-4"></a><span class="va">+    ^ ::</span></span>
-<span id="cb76-5"><a href="#cb76-5"></a><span class="va">+    ^ <em>namespace-name</em></span></span>
-<span id="cb76-6"><a href="#cb76-6"></a><span class="va">+    ^ <em>nested-name-specifier</em><sub><em>opt</em></sub> <em>template-name</em></span></span>
-<span id="cb76-7"><a href="#cb76-7"></a><span class="va">+    ^ <em>nested-name-specifier</em><sub><em>opt</em></sub> <em>concept-name</em></span></span>
-<span id="cb76-8"><a href="#cb76-8"></a><span class="va">+    ^ <em>type-id</em></span></span>
-<span id="cb76-9"><a href="#cb76-9"></a><span class="va">+    ^ <em>cast-expression</em></span></span></code></pre></div>
+<div class="sourceCode" id="cb77"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb77-1"><a href="#cb77-1"></a>  <em>unary-expression</em>:</span>
+<span id="cb77-2"><a href="#cb77-2"></a>     ...</span>
+<span id="cb77-3"><a href="#cb77-3"></a>     <em>delete-expression</em></span>
+<span id="cb77-4"><a href="#cb77-4"></a><span class="va">+    ^ ::</span></span>
+<span id="cb77-5"><a href="#cb77-5"></a><span class="va">+    ^ <em>namespace-name</em></span></span>
+<span id="cb77-6"><a href="#cb77-6"></a><span class="va">+    ^ <em>nested-name-specifier</em><sub><em>opt</em></sub> <em>template-name</em></span></span>
+<span id="cb77-7"><a href="#cb77-7"></a><span class="va">+    ^ <em>nested-name-specifier</em><sub><em>opt</em></sub> <em>concept-name</em></span></span>
+<span id="cb77-8"><a href="#cb77-8"></a><span class="va">+    ^ <em>type-id</em></span></span>
+<span id="cb77-9"><a href="#cb77-9"></a><span class="va">+    ^ <em>cast-expression</em></span></span></code></pre></div>
 </div>
 </blockquote>
 <h3 data-number="5.1.12" id="expr.reflect-the-reflection-operator"><span class="header-section-number">5.1.12</span> [expr.reflect] The reflection operator<a href="#expr.reflect-the-reflection-operator" class="self-link"></a></h3>
@@ -2303,17 +2342,17 @@ <h3 data-number="5.1.12" id="expr.reflect-the-reflection-operator"><span class="
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_21" id="pnum_21">1</a></span> The unary <code class="sourceCode cpp"><span class="op">^</span></code> operator (called <em>the reflection operator</em>) produces a prvalue — called <em>reflection</em> — whose type is the reflection type (i.e., <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span>info</code>). That reflection represents its operand.</p>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_22" id="pnum_22">2</a></span> An ambiguity can arise between the interpretation of the operand of the reflection operator as a <code class="sourceCode cpp"><em>type-id</em></code> or a <code class="sourceCode cpp"><em>cast-expression</em></code>; in such cases, the <code class="sourceCode cpp"><em>type-id</em></code> treatment is chosen. Parentheses can be introduced to force the <code class="sourceCode cpp"><em>cast-expression</em></code> interpretation.</p>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_23" id="pnum_23">3</a></span> [<em>Example</em></p>
-<div class="sourceCode" id="cb77"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb77-1"><a href="#cb77-1"></a>static_assert(is_type(^int()));    // ^ applies to the type-id &quot;int()&quot;; not the cast &quot;int()&quot;</span>
-<span id="cb77-2"><a href="#cb77-2"></a>static_assert(!is_type(^(int()))); // ^ applies to the the cast-expression &quot;(int())&quot;</span>
-<span id="cb77-3"><a href="#cb77-3"></a></span>
-<span id="cb77-4"><a href="#cb77-4"></a>template&lt;bool&gt; struct X;</span>
-<span id="cb77-5"><a href="#cb77-5"></a>consteval void g(std::meta::info r) {</span>
-<span id="cb77-6"><a href="#cb77-6"></a>  if (r == ^int &amp;&amp; true);    // error: ^ applies to the type-id &quot;int&amp;&amp;&quot;</span>
-<span id="cb77-7"><a href="#cb77-7"></a>  if (r == (^int) &amp;&amp; true);  // OK</span>
-<span id="cb77-8"><a href="#cb77-8"></a>  if (r == ^X &lt; true);       // error: &quot;&lt;&quot; is an angle bracket</span>
-<span id="cb77-9"><a href="#cb77-9"></a>  if (r == (^X) &lt; true);     // OK</span>
-<span id="cb77-10"><a href="#cb77-10"></a>}</span>
-<span id="cb77-11"><a href="#cb77-11"></a></span></code></pre></div>
+<div class="sourceCode" id="cb78"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb78-1"><a href="#cb78-1"></a>static_assert(is_type(^int()));    // ^ applies to the type-id &quot;int()&quot;; not the cast &quot;int()&quot;</span>
+<span id="cb78-2"><a href="#cb78-2"></a>static_assert(!is_type(^(int()))); // ^ applies to the the cast-expression &quot;(int())&quot;</span>
+<span id="cb78-3"><a href="#cb78-3"></a></span>
+<span id="cb78-4"><a href="#cb78-4"></a>template&lt;bool&gt; struct X;</span>
+<span id="cb78-5"><a href="#cb78-5"></a>consteval void g(std::meta::info r) {</span>
+<span id="cb78-6"><a href="#cb78-6"></a>  if (r == ^int &amp;&amp; true);    // error: ^ applies to the type-id &quot;int&amp;&amp;&quot;</span>
+<span id="cb78-7"><a href="#cb78-7"></a>  if (r == (^int) &amp;&amp; true);  // OK</span>
+<span id="cb78-8"><a href="#cb78-8"></a>  if (r == ^X &lt; true);       // error: &quot;&lt;&quot; is an angle bracket</span>
+<span id="cb78-9"><a href="#cb78-9"></a>  if (r == (^X) &lt; true);     // OK</span>
+<span id="cb78-10"><a href="#cb78-10"></a>}</span>
+<span id="cb78-11"><a href="#cb78-11"></a></span></code></pre></div>
 <p>-<em>end example</em>]</p>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_24" id="pnum_24">4</a></span> When applied to <code class="sourceCode cpp"><span class="op">::</span></code>, the reflection operator produces a reflection for the global namespace. When applied to a <code class="sourceCode cpp"><em>namespace-name</em></code>, the reflection produces a reflection for the indicated namespace or namespace alias.</p>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_25" id="pnum_25">5</a></span> When applied to a <code class="sourceCode cpp"><em>template-name</em></code>, the reflection produces a reflection for the indicated template.</p>
@@ -2329,14 +2368,14 @@ <h3 data-number="5.1.12" id="expr.reflect-the-reflection-operator"><span class="
 <li><p><span class="marginalizedparent"><a class="marginalized" href="#pnum_32" id="pnum_32">(8.3)</a></span> If the operand is both an <code class="sourceCode cpp"><em>id-expression</em></code> and a constant expression, the result is a reflection for both the indicated entity and the expression’s (constant) value.</p></li>
 </ul>
 <p>[ <em>Example</em>:</p>
-<div class="sourceCode" id="cb78"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb78-1"><a href="#cb78-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">typename</span> T<span class="op">&gt;</span> <span class="dt">void</span> fn<span class="op">()</span> <span class="kw">requires</span> <span class="op">(^</span>T <span class="op">!=</span> <span class="op">^</span><span class="dt">int</span><span class="op">)</span>;</span>
-<span id="cb78-2"><a href="#cb78-2"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">typename</span> T<span class="op">&gt;</span> <span class="dt">void</span> fn<span class="op">()</span> <span class="kw">requires</span> <span class="op">(^</span>T <span class="op">==</span> <span class="op">^</span><span class="dt">int</span><span class="op">)</span>;</span>
-<span id="cb78-3"><a href="#cb78-3"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">typename</span> T<span class="op">&gt;</span> <span class="dt">void</span> fn<span class="op">()</span> <span class="kw">requires</span> <span class="op">(</span><span class="kw">sizeof</span><span class="op">(</span>T<span class="op">)</span> <span class="op">==</span> <span class="kw">sizeof</span><span class="op">(</span><span class="dt">int</span><span class="op">)</span>;</span>
-<span id="cb78-4"><a href="#cb78-4"></a></span>
-<span id="cb78-5"><a href="#cb78-5"></a><span class="kw">constexpr</span> <span class="kw">auto</span> R <span class="op">=</span> <span class="op">^</span>fn<span class="op">&lt;</span><span class="dt">char</span><span class="op">&gt;</span>;     <span class="co">// OK</span></span>
-<span id="cb78-6"><a href="#cb78-6"></a><span class="kw">constexpr</span> <span class="kw">auto</span> S <span class="op">=</span> <span class="op">^</span>fn<span class="op">&lt;</span><span class="dt">int</span><span class="op">&gt;</span>;      <span class="co">// error: cannot reflect an overload set</span></span>
-<span id="cb78-7"><a href="#cb78-7"></a></span>
-<span id="cb78-8"><a href="#cb78-8"></a><span class="kw">constexpr</span> <span class="kw">auto</span> r <span class="op">=</span> <span class="op">^</span>std<span class="op">::</span>vector;  <span class="co">// OK</span></span></code></pre></div>
+<div class="sourceCode" id="cb79"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb79-1"><a href="#cb79-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">typename</span> T<span class="op">&gt;</span> <span class="dt">void</span> fn<span class="op">()</span> <span class="kw">requires</span> <span class="op">(^</span>T <span class="op">!=</span> <span class="op">^</span><span class="dt">int</span><span class="op">)</span>;</span>
+<span id="cb79-2"><a href="#cb79-2"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">typename</span> T<span class="op">&gt;</span> <span class="dt">void</span> fn<span class="op">()</span> <span class="kw">requires</span> <span class="op">(^</span>T <span class="op">==</span> <span class="op">^</span><span class="dt">int</span><span class="op">)</span>;</span>
+<span id="cb79-3"><a href="#cb79-3"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">typename</span> T<span class="op">&gt;</span> <span class="dt">void</span> fn<span class="op">()</span> <span class="kw">requires</span> <span class="op">(</span><span class="kw">sizeof</span><span class="op">(</span>T<span class="op">)</span> <span class="op">==</span> <span class="kw">sizeof</span><span class="op">(</span><span class="dt">int</span><span class="op">)</span>;</span>
+<span id="cb79-4"><a href="#cb79-4"></a></span>
+<span id="cb79-5"><a href="#cb79-5"></a><span class="kw">constexpr</span> <span class="kw">auto</span> R <span class="op">=</span> <span class="op">^</span>fn<span class="op">&lt;</span><span class="dt">char</span><span class="op">&gt;</span>;     <span class="co">// OK</span></span>
+<span id="cb79-6"><a href="#cb79-6"></a><span class="kw">constexpr</span> <span class="kw">auto</span> S <span class="op">=</span> <span class="op">^</span>fn<span class="op">&lt;</span><span class="dt">int</span><span class="op">&gt;</span>;      <span class="co">// error: cannot reflect an overload set</span></span>
+<span id="cb79-7"><a href="#cb79-7"></a></span>
+<span id="cb79-8"><a href="#cb79-8"></a><span class="kw">constexpr</span> <span class="kw">auto</span> r <span class="op">=</span> <span class="op">^</span>std<span class="op">::</span>vector;  <span class="co">// OK</span></span></code></pre></div>
 <p>— <em>end example</em> ]</p>
 </div>
 </blockquote>
@@ -2395,22 +2434,22 @@ <h3 data-number="5.1.16" id="dcl.attr.grammar-attribute-syntax-and-semantics"><s
 <p>Add a production to the grammar for <code class="sourceCode cpp"><em>attribute-specifier</em></code> as follows:</p>
 <blockquote>
 <div>
-<div class="sourceCode" id="cb79"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb79-1"><a href="#cb79-1"></a>  <em>attribute-specifier</em>:</span>
-<span id="cb79-2"><a href="#cb79-2"></a>     [ [ <em>attribute-using-prefix</em><sub><em>opt</em></sub> <em>attribute-list</em> ] ]</span>
-<span id="cb79-3"><a href="#cb79-3"></a><span class="va">+    [ [ using <em>attribute-namespace</em> :] ]</span></span>
-<span id="cb79-4"><a href="#cb79-4"></a>     <em>alignment-specifier</em></span></code></pre></div>
+<div class="sourceCode" id="cb80"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb80-1"><a href="#cb80-1"></a>  <em>attribute-specifier</em>:</span>
+<span id="cb80-2"><a href="#cb80-2"></a>     [ [ <em>attribute-using-prefix</em><sub><em>opt</em></sub> <em>attribute-list</em> ] ]</span>
+<span id="cb80-3"><a href="#cb80-3"></a><span class="va">+    [ [ using <em>attribute-namespace</em> :] ]</span></span>
+<span id="cb80-4"><a href="#cb80-4"></a>     <em>alignment-specifier</em></span></code></pre></div>
 </div>
 </blockquote>
 <p>and update the grammar for balanced token as follows:</p>
 <blockquote>
 <div>
-<div class="sourceCode" id="cb80"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb80-1"><a href="#cb80-1"></a>  <em>balanced-token</em> :</span>
-<span id="cb80-2"><a href="#cb80-2"></a>      ( <em>balanced-token-seq</em><sub><em>opt</em></sub> )</span>
-<span id="cb80-3"><a href="#cb80-3"></a>      [ <em>balanced-token-seq</em><sub><em>opt</em></sub> ]</span>
-<span id="cb80-4"><a href="#cb80-4"></a>      { <em>balanced-token-seq</em><sub><em>opt</em></sub> }</span>
-<span id="cb80-5"><a href="#cb80-5"></a><span class="st">-     any token other than a parenthesis, a bracket, or a brace</span></span>
-<span id="cb80-6"><a href="#cb80-6"></a><span class="va">+     [: <em>balanced-token-seq</em><sub><em>opt</em></sub> :]</span></span>
-<span id="cb80-7"><a href="#cb80-7"></a><span class="va">+     any token other than (, ), [, ], {, }, [:, or :]</span></span></code></pre></div>
+<div class="sourceCode" id="cb81"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb81-1"><a href="#cb81-1"></a>  <em>balanced-token</em> :</span>
+<span id="cb81-2"><a href="#cb81-2"></a>      ( <em>balanced-token-seq</em><sub><em>opt</em></sub> )</span>
+<span id="cb81-3"><a href="#cb81-3"></a>      [ <em>balanced-token-seq</em><sub><em>opt</em></sub> ]</span>
+<span id="cb81-4"><a href="#cb81-4"></a>      { <em>balanced-token-seq</em><sub><em>opt</em></sub> }</span>
+<span id="cb81-5"><a href="#cb81-5"></a><span class="st">-     any token other than a parenthesis, a bracket, or a brace</span></span>
+<span id="cb81-6"><a href="#cb81-6"></a><span class="va">+     [: <em>balanced-token-seq</em><sub><em>opt</em></sub> :]</span></span>
+<span id="cb81-7"><a href="#cb81-7"></a><span class="va">+     any token other than (, ), [, ], {, }, [:, or :]</span></span></code></pre></div>
 </div>
 </blockquote>
 <p>Change a sentence in paragraph 4 of <span>9.12.1 <a href="https://wg21.link/dcl.attr.grammar">[dcl.attr.grammar]</a></span> as follows:</p>
@@ -2421,15 +2460,15 @@ <h3 data-number="5.1.17" id="temp.names-names-of-template-specializations"><span
 <p>Modify the grammar for <code class="sourceCode cpp"><em>template-argument</em></code> as follows:</p>
 <blockquote>
 <div>
-<div class="sourceCode" id="cb81"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb81-1"><a href="#cb81-1"></a><span class="va">+ <em>splice-template-argument</em>:</span></span>
-<span id="cb81-2"><a href="#cb81-2"></a><span class="va">+     [: constant-expression :]</span></span>
-<span id="cb81-3"><a href="#cb81-3"></a><span class="va">+</span></span>
-<span id="cb81-4"><a href="#cb81-4"></a>  <em>template-argument</em>:</span>
-<span id="cb81-5"><a href="#cb81-5"></a>      <em>constant-expression</em></span>
-<span id="cb81-6"><a href="#cb81-6"></a>      <em>type-id</em></span>
-<span id="cb81-7"><a href="#cb81-7"></a>      <em>id-expression</em></span>
-<span id="cb81-8"><a href="#cb81-8"></a>      <em>braced-init-list</em></span>
-<span id="cb81-9"><a href="#cb81-9"></a><span class="va">+     <em>splice-template-argument</em></span></span></code></pre></div>
+<div class="sourceCode" id="cb82"><pre class="sourceCode diff"><code class="sourceCode diff"><span id="cb82-1"><a href="#cb82-1"></a><span class="va">+ <em>splice-template-argument</em>:</span></span>
+<span id="cb82-2"><a href="#cb82-2"></a><span class="va">+     [: constant-expression :]</span></span>
+<span id="cb82-3"><a href="#cb82-3"></a><span class="va">+</span></span>
+<span id="cb82-4"><a href="#cb82-4"></a>  <em>template-argument</em>:</span>
+<span id="cb82-5"><a href="#cb82-5"></a>      <em>constant-expression</em></span>
+<span id="cb82-6"><a href="#cb82-6"></a>      <em>type-id</em></span>
+<span id="cb82-7"><a href="#cb82-7"></a>      <em>id-expression</em></span>
+<span id="cb82-8"><a href="#cb82-8"></a>      <em>braced-init-list</em></span>
+<span id="cb82-9"><a href="#cb82-9"></a><span class="va">+     <em>splice-template-argument</em></span></span></code></pre></div>
 </div>
 </blockquote>
 <h3 data-number="5.1.18" id="temp.arg.general-general"><span class="header-section-number">5.1.18</span> [temp.arg.general] General<a href="#temp.arg.general-general" class="self-link"></a></h3>
@@ -2457,347 +2496,347 @@ <h3 data-number="5.2.1" id="over.built-built-in-operators"><span class="header-s
 <p>Add built-in operator candidates for <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span>info</code> to <span>12.5 <a href="https://wg21.link/over.built">[over.built]</a></span>:</p>
 <blockquote>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_60" id="pnum_60">16</a></span> For every <code class="sourceCode cpp">T</code>, where <code class="sourceCode cpp">T</code> is a pointer-to-member type<span class="addu">, <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span>info</code>,</span> or <code class="sourceCode cpp">std​<span class="op">::</span>​nullptr_t</code>, there exist candidate operator functions of the form</p>
-<div class="sourceCode" id="cb82"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb82-1"><a href="#cb82-1"></a><span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span>T, T<span class="op">)</span>;</span>
-<span id="cb82-2"><a href="#cb82-2"></a><span class="dt">bool</span> <span class="kw">operator</span><span class="op">!=(</span>T, T<span class="op">)</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb83"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb83-1"><a href="#cb83-1"></a><span class="dt">bool</span> <span class="kw">operator</span><span class="op">==(</span>T, T<span class="op">)</span>;</span>
+<span id="cb83-2"><a href="#cb83-2"></a><span class="dt">bool</span> <span class="kw">operator</span><span class="op">!=(</span>T, T<span class="op">)</span>;</span></code></pre></div>
 </blockquote>
 <h3 data-number="5.2.2" id="header-meta-synopsis"><span class="header-section-number">5.2.2</span> Header <code class="sourceCode cpp"><span class="op">&lt;</span>meta<span class="op">&gt;</span></code> synopsis<a href="#header-meta-synopsis" class="self-link"></a></h3>
 <p>Add a new subsection in <span>21 <a href="https://wg21.link/meta">[meta]</a></span> after <span>21.3 <a href="https://wg21.link/type.traits">[type.traits]</a></span>:</p>
 <blockquote>
 <div class="addu">
 <p><strong>Header <code class="sourceCode cpp"><span class="op">&lt;</span>meta<span class="op">&gt;</span></code> synopsis</strong></p>
-<div class="sourceCode" id="cb83"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb83-1"><a href="#cb83-1"></a>namespace std::meta {</span>
-<span id="cb83-2"><a href="#cb83-2"></a>  using info = decltype(^::);</span>
-<span id="cb83-3"><a href="#cb83-3"></a></span>
-<span id="cb83-4"><a href="#cb83-4"></a>  // [meta.reflection.names], reflection names and locations</span>
-<span id="cb83-5"><a href="#cb83-5"></a>  consteval string_view name_of(info r);</span>
-<span id="cb83-6"><a href="#cb83-6"></a>  consteval string_view qualified_name_of(info r);</span>
-<span id="cb83-7"><a href="#cb83-7"></a>  consteval string_view display_name_of(info r);</span>
-<span id="cb83-8"><a href="#cb83-8"></a>  consteval source_location source_location_of(info r);</span>
-<span id="cb83-9"><a href="#cb83-9"></a></span>
-<span id="cb83-10"><a href="#cb83-10"></a>  // [meta.reflection.queries], reflection queries</span>
-<span id="cb83-11"><a href="#cb83-11"></a>  consteval bool is_public(info r);</span>
-<span id="cb83-12"><a href="#cb83-12"></a>  consteval bool is_protected(info r);</span>
-<span id="cb83-13"><a href="#cb83-13"></a>  consteval bool is_private(info r);</span>
-<span id="cb83-14"><a href="#cb83-14"></a>  consteval bool is_accessible(info r);</span>
-<span id="cb83-15"><a href="#cb83-15"></a>  consteval bool is_virtual(info r);</span>
-<span id="cb83-16"><a href="#cb83-16"></a>  consteval bool is_pure_virtual(info r);</span>
-<span id="cb83-17"><a href="#cb83-17"></a>  consteval bool is_override(info r);</span>
-<span id="cb83-18"><a href="#cb83-18"></a>  consteval bool is_deleted(info r);</span>
-<span id="cb83-19"><a href="#cb83-19"></a>  consteval bool is_defaulted(info r);</span>
-<span id="cb83-20"><a href="#cb83-20"></a>  consteval bool is_explicit(info r);</span>
-<span id="cb83-21"><a href="#cb83-21"></a>  consteval bool is_bit_field(info r);</span>
-<span id="cb83-22"><a href="#cb83-22"></a>  consteval bool has_static_storage_duration(info r);</span>
-<span id="cb83-23"><a href="#cb83-23"></a>  consteval bool has_internal_linkage(info r);</span>
-<span id="cb83-24"><a href="#cb83-24"></a>  consteval bool has_external_linkage(info r);</span>
-<span id="cb83-25"><a href="#cb83-25"></a>  consteval bool has_linkage(info r);</span>
-<span id="cb83-26"><a href="#cb83-26"></a></span>
-<span id="cb83-27"><a href="#cb83-27"></a>  consteval bool is_namespace(info r);</span>
-<span id="cb83-28"><a href="#cb83-28"></a>  consteval bool is_function(info r);</span>
-<span id="cb83-29"><a href="#cb83-29"></a>  consteval bool is_variable(info r);</span>
-<span id="cb83-30"><a href="#cb83-30"></a>  consteval bool is_type(info r);</span>
-<span id="cb83-31"><a href="#cb83-31"></a>  consteval bool is_alias(info r);</span>
-<span id="cb83-32"><a href="#cb83-32"></a>  consteval bool is_incomplete_type(info r);</span>
-<span id="cb83-33"><a href="#cb83-33"></a>  consteval bool is_template(info r);</span>
-<span id="cb83-34"><a href="#cb83-34"></a>  consteval bool is_function_template(info r);</span>
-<span id="cb83-35"><a href="#cb83-35"></a>  consteval bool is_variable_template(info r);</span>
-<span id="cb83-36"><a href="#cb83-36"></a>  consteval bool is_class_template(info r);</span>
-<span id="cb83-37"><a href="#cb83-37"></a>  consteval bool is_alias_template(info r);</span>
-<span id="cb83-38"><a href="#cb83-38"></a>  consteval bool is_concept(info r);</span>
-<span id="cb83-39"><a href="#cb83-39"></a>  consteval bool has_template_arguments(info r);</span>
-<span id="cb83-40"><a href="#cb83-40"></a>  consteval auto is_class_member(info entity) -&gt; bool;</span>
-<span id="cb83-41"><a href="#cb83-41"></a>  consteval auto is_namespace_member(info entity) -&gt; bool;</span>
-<span id="cb83-42"><a href="#cb83-42"></a>  consteval bool is_nonstatic_data_member(info r);</span>
-<span id="cb83-43"><a href="#cb83-43"></a>  consteval bool is_static_member(info r);</span>
-<span id="cb83-44"><a href="#cb83-44"></a>  consteval bool is_base(info r);</span>
-<span id="cb83-45"><a href="#cb83-45"></a>  consteval bool is_constructor(info r);</span>
-<span id="cb83-46"><a href="#cb83-46"></a>  consteval bool is_destructor(info r);</span>
-<span id="cb83-47"><a href="#cb83-47"></a>  consteval bool is_special_member(info r);</span>
-<span id="cb83-48"><a href="#cb83-48"></a></span>
-<span id="cb83-49"><a href="#cb83-49"></a>  consteval info type_of(info r);</span>
-<span id="cb83-50"><a href="#cb83-50"></a>  consteval info parent_of(info r);</span>
-<span id="cb83-51"><a href="#cb83-51"></a>  consteval info dealias(info r);</span>
-<span id="cb83-52"><a href="#cb83-52"></a>  consteval info template_of(info r);</span>
-<span id="cb83-53"><a href="#cb83-53"></a>  consteval vector&lt;info&gt; template_arguments_of(info r);</span>
-<span id="cb83-54"><a href="#cb83-54"></a></span>
-<span id="cb83-55"><a href="#cb83-55"></a>  // [meta.reflection.member.queries], reflection member queries</span>
-<span id="cb83-56"><a href="#cb83-56"></a>  template&lt;class... Fs&gt;</span>
-<span id="cb83-57"><a href="#cb83-57"></a>    consteval vector&lt;info&gt; members_of(info type, Fs... filters);</span>
-<span id="cb83-58"><a href="#cb83-58"></a>  template&lt;class... Fs&gt;</span>
-<span id="cb83-59"><a href="#cb83-59"></a>    consteval vector&lt;info&gt; bases_of(info type, Fs... filters);</span>
-<span id="cb83-60"><a href="#cb83-60"></a>  consteval vector&lt;info&gt; static_data_members_of(info type);</span>
-<span id="cb83-61"><a href="#cb83-61"></a>  consteval vector&lt;info&gt; nonstatic_data_members_of(info type);</span>
-<span id="cb83-62"><a href="#cb83-62"></a>  consteval vector&lt;info&gt; subobjects_of(info type);</span>
-<span id="cb83-63"><a href="#cb83-63"></a>  consteval vector&lt;info&gt; enumerators_of(info enum_type);</span>
-<span id="cb83-64"><a href="#cb83-64"></a></span>
-<span id="cb83-65"><a href="#cb83-65"></a>  // [meta.reflection.unary.cat], primary type categories</span>
-<span id="cb83-66"><a href="#cb83-66"></a>  consteval bool is_void(info type);</span>
-<span id="cb83-67"><a href="#cb83-67"></a>  consteval bool is_null_pointer(info type);</span>
-<span id="cb83-68"><a href="#cb83-68"></a>  consteval bool is_integral(info type);</span>
-<span id="cb83-69"><a href="#cb83-69"></a>  consteval bool is_floating_point(info type);</span>
-<span id="cb83-70"><a href="#cb83-70"></a>  consteval bool is_array(info type);</span>
-<span id="cb83-71"><a href="#cb83-71"></a>  consteval bool is_pointer(info type);</span>
-<span id="cb83-72"><a href="#cb83-72"></a>  consteval bool is_lvalue_reference(info type);</span>
-<span id="cb83-73"><a href="#cb83-73"></a>  consteval bool is_rvalue_reference(info type);</span>
-<span id="cb83-74"><a href="#cb83-74"></a>  consteval bool is_member_object_pointer(info type);</span>
-<span id="cb83-75"><a href="#cb83-75"></a>  consteval bool is_member_function_pointer(info type);</span>
-<span id="cb83-76"><a href="#cb83-76"></a>  consteval bool is_enum(info type);</span>
-<span id="cb83-77"><a href="#cb83-77"></a>  consteval bool is_union(info type);</span>
-<span id="cb83-78"><a href="#cb83-78"></a>  consteval bool is_class(info type);</span>
-<span id="cb83-79"><a href="#cb83-79"></a>  consteval bool is_function(info type);</span>
-<span id="cb83-80"><a href="#cb83-80"></a></span>
-<span id="cb83-81"><a href="#cb83-81"></a>  // [meta.reflection.unary.comp], composite type categories</span>
-<span id="cb83-82"><a href="#cb83-82"></a>  consteval bool is_reference(info type);</span>
-<span id="cb83-83"><a href="#cb83-83"></a>  consteval bool is_arithmetic(info type);</span>
-<span id="cb83-84"><a href="#cb83-84"></a>  consteval bool is_fundamental(info type);</span>
-<span id="cb83-85"><a href="#cb83-85"></a>  consteval bool is_object(info type);</span>
-<span id="cb83-86"><a href="#cb83-86"></a>  consteval bool is_scalar(info type);</span>
-<span id="cb83-87"><a href="#cb83-87"></a>  consteval bool is_compound(info type);</span>
-<span id="cb83-88"><a href="#cb83-88"></a>  consteval bool is_member_pointer(info type);</span>
-<span id="cb83-89"><a href="#cb83-89"></a></span>
-<span id="cb83-90"><a href="#cb83-90"></a>  // [meta.reflection unary.prop], type properties</span>
-<span id="cb83-91"><a href="#cb83-91"></a>  consteval bool is_const(info type);</span>
-<span id="cb83-92"><a href="#cb83-92"></a>  consteval bool is_volatile(info type);</span>
-<span id="cb83-93"><a href="#cb83-93"></a>  consteval bool is_trivial(info type);</span>
-<span id="cb83-94"><a href="#cb83-94"></a>  consteval bool is_trivially_copyable(info type);</span>
-<span id="cb83-95"><a href="#cb83-95"></a>  consteval bool is_standard_layout(info type);</span>
-<span id="cb83-96"><a href="#cb83-96"></a>  consteval bool is_empty(info type);</span>
-<span id="cb83-97"><a href="#cb83-97"></a>  consteval bool is_polymorphic(info type);</span>
-<span id="cb83-98"><a href="#cb83-98"></a>  consteval bool is_abstract(info type);</span>
-<span id="cb83-99"><a href="#cb83-99"></a>  consteval bool is_final(info type);</span>
-<span id="cb83-100"><a href="#cb83-100"></a>  consteval bool is_aggregate(info type);</span>
-<span id="cb83-101"><a href="#cb83-101"></a>  consteval bool is_signed(info type);</span>
-<span id="cb83-102"><a href="#cb83-102"></a>  consteval bool is_unsigned(info type);</span>
-<span id="cb83-103"><a href="#cb83-103"></a>  consteval bool is_bounded_array(info type);</span>
-<span id="cb83-104"><a href="#cb83-104"></a>  consteval bool is_unbounded_array(info type);</span>
-<span id="cb83-105"><a href="#cb83-105"></a>  consteval bool is_scoped_enum(info type);</span>
-<span id="cb83-106"><a href="#cb83-106"></a></span>
-<span id="cb83-107"><a href="#cb83-107"></a>  consteval bool is_constructible(info type, span&lt;info const&gt; type_args);</span>
-<span id="cb83-108"><a href="#cb83-108"></a>  consteval bool is_default_constructible(info type);</span>
-<span id="cb83-109"><a href="#cb83-109"></a>  consteval bool is_copy_constructible(info type);</span>
-<span id="cb83-110"><a href="#cb83-110"></a>  consteval bool is_move_constructible(info type);</span>
-<span id="cb83-111"><a href="#cb83-111"></a></span>
-<span id="cb83-112"><a href="#cb83-112"></a>  consteval bool is_assignable(info dst_type, info src_type);</span>
-<span id="cb83-113"><a href="#cb83-113"></a>  consteval bool is_copy_assignable(info type);</span>
-<span id="cb83-114"><a href="#cb83-114"></a>  consteval bool is_move_assignable(info type);</span>
-<span id="cb83-115"><a href="#cb83-115"></a></span>
-<span id="cb83-116"><a href="#cb83-116"></a>  consteval bool is_swappable_with(info dst_type, info src_type);</span>
-<span id="cb83-117"><a href="#cb83-117"></a>  consteval bool is_swappable(info type);</span>
-<span id="cb83-118"><a href="#cb83-118"></a></span>
-<span id="cb83-119"><a href="#cb83-119"></a>  consteval bool is_destructible(info type);</span>
-<span id="cb83-120"><a href="#cb83-120"></a></span>
-<span id="cb83-121"><a href="#cb83-121"></a>  consteval bool is_trivially_constructible(info type, span&lt;info const&gt; type_args);</span>
-<span id="cb83-122"><a href="#cb83-122"></a>  consteval bool is_trivially_default_constructible(info type);</span>
-<span id="cb83-123"><a href="#cb83-123"></a>  consteval bool is_trivially_copy_constructible(info type);</span>
-<span id="cb83-124"><a href="#cb83-124"></a>  consteval bool is_trivially_move_constructible(info type);</span>
-<span id="cb83-125"><a href="#cb83-125"></a></span>
-<span id="cb83-126"><a href="#cb83-126"></a>  consteval bool is_trivially_assignable(info dst_type, info src_type);</span>
-<span id="cb83-127"><a href="#cb83-127"></a>  consteval bool is_trivially_copy_assignable(info type);</span>
-<span id="cb83-128"><a href="#cb83-128"></a>  consteval bool is_trivially_move_assignable(info type);</span>
-<span id="cb83-129"><a href="#cb83-129"></a>  consteval bool is_trivially_destructible(info type);</span>
-<span id="cb83-130"><a href="#cb83-130"></a></span>
-<span id="cb83-131"><a href="#cb83-131"></a>  consteval bool is_nothrow_constructible(info type, span&lt;info const&gt; type_args);</span>
-<span id="cb83-132"><a href="#cb83-132"></a>  consteval bool is_nothrow_default_constructible(info type);</span>
-<span id="cb83-133"><a href="#cb83-133"></a>  consteval bool is_nothrow_copy_constructible(info type);</span>
-<span id="cb83-134"><a href="#cb83-134"></a>  consteval bool is_nothrow_move_constructible(info type);</span>
-<span id="cb83-135"><a href="#cb83-135"></a></span>
-<span id="cb83-136"><a href="#cb83-136"></a>  consteval bool is_nothrow_assignable(info dst_type, info src_type);</span>
-<span id="cb83-137"><a href="#cb83-137"></a>  consteval bool is_nothrow_copy_assignable(info type);</span>
-<span id="cb83-138"><a href="#cb83-138"></a>  consteval bool is_nothrow_move_assignable(info type);</span>
-<span id="cb83-139"><a href="#cb83-139"></a></span>
-<span id="cb83-140"><a href="#cb83-140"></a>  consteval bool is_nothrow_swappable_with(info dst_type, info src_type);</span>
-<span id="cb83-141"><a href="#cb83-141"></a>  consteval bool is_nothrow_swappable(info type);</span>
-<span id="cb83-142"><a href="#cb83-142"></a></span>
-<span id="cb83-143"><a href="#cb83-143"></a>  consteval bool is_nothrow_destructible(info type);</span>
-<span id="cb83-144"><a href="#cb83-144"></a></span>
-<span id="cb83-145"><a href="#cb83-145"></a>  consteval bool is_implicit_lifetime(info type);</span>
-<span id="cb83-146"><a href="#cb83-146"></a></span>
-<span id="cb83-147"><a href="#cb83-147"></a>  consteval bool has_virtual_destructor(info type);</span>
-<span id="cb83-148"><a href="#cb83-148"></a></span>
-<span id="cb83-149"><a href="#cb83-149"></a>  consteval bool has_unique_object_representations(info type);</span>
-<span id="cb83-150"><a href="#cb83-150"></a></span>
-<span id="cb83-151"><a href="#cb83-151"></a>  consteval bool reference_constructs_from_temporary(info dst_type, info src_type);</span>
-<span id="cb83-152"><a href="#cb83-152"></a>  consteval bool reference_converts_from_temporary(info dst_type, info src_type);</span>
-<span id="cb83-153"><a href="#cb83-153"></a></span>
-<span id="cb83-154"><a href="#cb83-154"></a>  // [meta.reflection.unary.prop.query], type property queries</span>
-<span id="cb83-155"><a href="#cb83-155"></a>  consteval size_t alignment_of(info type);</span>
-<span id="cb83-156"><a href="#cb83-156"></a>  consteval size_t rank(info type);</span>
-<span id="cb83-157"><a href="#cb83-157"></a>  consteval size_t extent(info type, unsigned i = 0);</span>
-<span id="cb83-158"><a href="#cb83-158"></a></span>
-<span id="cb83-159"><a href="#cb83-159"></a>  // [meta.reflection.rel], type relations</span>
-<span id="cb83-160"><a href="#cb83-160"></a>  consteval bool is_same(info type1, info type2);</span>
-<span id="cb83-161"><a href="#cb83-161"></a>  consteval bool is_base_of(info base_type, info derived_type);</span>
-<span id="cb83-162"><a href="#cb83-162"></a>  consteval bool is_convertible(info src_type, info dst_type);</span>
-<span id="cb83-163"><a href="#cb83-163"></a>  consteval bool is_nothrow_convertible(info src_type, info dst_type);</span>
-<span id="cb83-164"><a href="#cb83-164"></a>  consteval bool is_layout_compatible(info type1, info type2);</span>
-<span id="cb83-165"><a href="#cb83-165"></a>  consteval bool is_pointer_interconvertible_base_of(info base_type, info derived_type);</span>
-<span id="cb83-166"><a href="#cb83-166"></a></span>
-<span id="cb83-167"><a href="#cb83-167"></a>  consteval bool is_invocable(info type, span&lt;const info&gt; type_args);</span>
-<span id="cb83-168"><a href="#cb83-168"></a>  consteval bool is_invocable_r(info result_type, info type, span&lt;const info&gt; type_args);</span>
-<span id="cb83-169"><a href="#cb83-169"></a></span>
-<span id="cb83-170"><a href="#cb83-170"></a>  consteval bool is_nothrow_invocable(info type, span&lt;const info&gt; type_args);</span>
-<span id="cb83-171"><a href="#cb83-171"></a>  consteval bool is_nothrow_invocable_r(info result_type, info type, span&lt;const info&gt; type_args);</span>
-<span id="cb83-172"><a href="#cb83-172"></a></span>
-<span id="cb83-173"><a href="#cb83-173"></a>  // [meta.reflection.trans.cv], const-volatile modifications</span>
-<span id="cb83-174"><a href="#cb83-174"></a>  consteval info remove_const(info type);</span>
-<span id="cb83-175"><a href="#cb83-175"></a>  consteval info remove_volatile(info type);</span>
-<span id="cb83-176"><a href="#cb83-176"></a>  consteval info remove_cv(info type);</span>
-<span id="cb83-177"><a href="#cb83-177"></a>  consteval info add_const(info type);</span>
-<span id="cb83-178"><a href="#cb83-178"></a>  consteval info add_volatile(info type);</span>
-<span id="cb83-179"><a href="#cb83-179"></a>  consteval info add_cv(info type);</span>
-<span id="cb83-180"><a href="#cb83-180"></a></span>
-<span id="cb83-181"><a href="#cb83-181"></a>  // [meta.reflection.trans.ref], reference modifications</span>
-<span id="cb83-182"><a href="#cb83-182"></a>  consteval info remove_reference(info type);</span>
-<span id="cb83-183"><a href="#cb83-183"></a>  consteval info add_lvalue_reference(info type);</span>
-<span id="cb83-184"><a href="#cb83-184"></a>  consteval info add_rvalue_reference(info type);</span>
-<span id="cb83-185"><a href="#cb83-185"></a></span>
-<span id="cb83-186"><a href="#cb83-186"></a>  // [meta.reflection.trans.sign], sign modifications</span>
-<span id="cb83-187"><a href="#cb83-187"></a>  consteval info make_signed(info type);</span>
-<span id="cb83-188"><a href="#cb83-188"></a>  consteval info make_unsigned(info type);</span>
-<span id="cb83-189"><a href="#cb83-189"></a></span>
-<span id="cb83-190"><a href="#cb83-190"></a>  // [meta.reflection.trans.arr], array modifications</span>
-<span id="cb83-191"><a href="#cb83-191"></a>  consteval info remove_extent(info type);</span>
-<span id="cb83-192"><a href="#cb83-192"></a>  consteval info remove_all_extents(info type);</span>
-<span id="cb83-193"><a href="#cb83-193"></a></span>
-<span id="cb83-194"><a href="#cb83-194"></a>  // [meta.reflection.trans.ptr], pointer modifications</span>
-<span id="cb83-195"><a href="#cb83-195"></a>  consteval info remove_pointer(info type);</span>
-<span id="cb83-196"><a href="#cb83-196"></a>  consteval info add_pointer(info type);</span>
-<span id="cb83-197"><a href="#cb83-197"></a></span>
-<span id="cb83-198"><a href="#cb83-198"></a>  // [meta.reflection.trans.other], other transformations</span>
-<span id="cb83-199"><a href="#cb83-199"></a>  consteval info remove_cvref(info type);</span>
-<span id="cb83-200"><a href="#cb83-200"></a>  consteval info decay(info type);</span>
-<span id="cb83-201"><a href="#cb83-201"></a>  consteval info common_type(span&lt;const info&gt; type_args);</span>
-<span id="cb83-202"><a href="#cb83-202"></a>  consteval info common_reference(span&lt;const info&gt; type_args);</span>
-<span id="cb83-203"><a href="#cb83-203"></a>  consteval info underlying_type(info type);</span>
-<span id="cb83-204"><a href="#cb83-204"></a>  consteval info invoke_result(info type, span&lt;const info&gt; type_args);</span>
-<span id="cb83-205"><a href="#cb83-205"></a>  consteval info unwrap_reference(info type);</span>
-<span id="cb83-206"><a href="#cb83-206"></a>  consteval info unwrap_ref_decay(info type);</span>
-<span id="cb83-207"><a href="#cb83-207"></a>}</span></code></pre></div>
+<div class="sourceCode" id="cb84"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb84-1"><a href="#cb84-1"></a>namespace std::meta {</span>
+<span id="cb84-2"><a href="#cb84-2"></a>  using info = decltype(^::);</span>
+<span id="cb84-3"><a href="#cb84-3"></a></span>
+<span id="cb84-4"><a href="#cb84-4"></a>  // [meta.reflection.names], reflection names and locations</span>
+<span id="cb84-5"><a href="#cb84-5"></a>  consteval string_view name_of(info r);</span>
+<span id="cb84-6"><a href="#cb84-6"></a>  consteval string_view qualified_name_of(info r);</span>
+<span id="cb84-7"><a href="#cb84-7"></a>  consteval string_view display_name_of(info r);</span>
+<span id="cb84-8"><a href="#cb84-8"></a>  consteval source_location source_location_of(info r);</span>
+<span id="cb84-9"><a href="#cb84-9"></a></span>
+<span id="cb84-10"><a href="#cb84-10"></a>  // [meta.reflection.queries], reflection queries</span>
+<span id="cb84-11"><a href="#cb84-11"></a>  consteval bool is_public(info r);</span>
+<span id="cb84-12"><a href="#cb84-12"></a>  consteval bool is_protected(info r);</span>
+<span id="cb84-13"><a href="#cb84-13"></a>  consteval bool is_private(info r);</span>
+<span id="cb84-14"><a href="#cb84-14"></a>  consteval bool is_accessible(info r);</span>
+<span id="cb84-15"><a href="#cb84-15"></a>  consteval bool is_virtual(info r);</span>
+<span id="cb84-16"><a href="#cb84-16"></a>  consteval bool is_pure_virtual(info r);</span>
+<span id="cb84-17"><a href="#cb84-17"></a>  consteval bool is_override(info r);</span>
+<span id="cb84-18"><a href="#cb84-18"></a>  consteval bool is_deleted(info r);</span>
+<span id="cb84-19"><a href="#cb84-19"></a>  consteval bool is_defaulted(info r);</span>
+<span id="cb84-20"><a href="#cb84-20"></a>  consteval bool is_explicit(info r);</span>
+<span id="cb84-21"><a href="#cb84-21"></a>  consteval bool is_bit_field(info r);</span>
+<span id="cb84-22"><a href="#cb84-22"></a>  consteval bool has_static_storage_duration(info r);</span>
+<span id="cb84-23"><a href="#cb84-23"></a>  consteval bool has_internal_linkage(info r);</span>
+<span id="cb84-24"><a href="#cb84-24"></a>  consteval bool has_external_linkage(info r);</span>
+<span id="cb84-25"><a href="#cb84-25"></a>  consteval bool has_linkage(info r);</span>
+<span id="cb84-26"><a href="#cb84-26"></a></span>
+<span id="cb84-27"><a href="#cb84-27"></a>  consteval bool is_namespace(info r);</span>
+<span id="cb84-28"><a href="#cb84-28"></a>  consteval bool is_function(info r);</span>
+<span id="cb84-29"><a href="#cb84-29"></a>  consteval bool is_variable(info r);</span>
+<span id="cb84-30"><a href="#cb84-30"></a>  consteval bool is_type(info r);</span>
+<span id="cb84-31"><a href="#cb84-31"></a>  consteval bool is_alias(info r);</span>
+<span id="cb84-32"><a href="#cb84-32"></a>  consteval bool is_incomplete_type(info r);</span>
+<span id="cb84-33"><a href="#cb84-33"></a>  consteval bool is_template(info r);</span>
+<span id="cb84-34"><a href="#cb84-34"></a>  consteval bool is_function_template(info r);</span>
+<span id="cb84-35"><a href="#cb84-35"></a>  consteval bool is_variable_template(info r);</span>
+<span id="cb84-36"><a href="#cb84-36"></a>  consteval bool is_class_template(info r);</span>
+<span id="cb84-37"><a href="#cb84-37"></a>  consteval bool is_alias_template(info r);</span>
+<span id="cb84-38"><a href="#cb84-38"></a>  consteval bool is_concept(info r);</span>
+<span id="cb84-39"><a href="#cb84-39"></a>  consteval bool has_template_arguments(info r);</span>
+<span id="cb84-40"><a href="#cb84-40"></a>  consteval auto is_class_member(info entity) -&gt; bool;</span>
+<span id="cb84-41"><a href="#cb84-41"></a>  consteval auto is_namespace_member(info entity) -&gt; bool;</span>
+<span id="cb84-42"><a href="#cb84-42"></a>  consteval bool is_nonstatic_data_member(info r);</span>
+<span id="cb84-43"><a href="#cb84-43"></a>  consteval bool is_static_member(info r);</span>
+<span id="cb84-44"><a href="#cb84-44"></a>  consteval bool is_base(info r);</span>
+<span id="cb84-45"><a href="#cb84-45"></a>  consteval bool is_constructor(info r);</span>
+<span id="cb84-46"><a href="#cb84-46"></a>  consteval bool is_destructor(info r);</span>
+<span id="cb84-47"><a href="#cb84-47"></a>  consteval bool is_special_member(info r);</span>
+<span id="cb84-48"><a href="#cb84-48"></a></span>
+<span id="cb84-49"><a href="#cb84-49"></a>  consteval info type_of(info r);</span>
+<span id="cb84-50"><a href="#cb84-50"></a>  consteval info parent_of(info r);</span>
+<span id="cb84-51"><a href="#cb84-51"></a>  consteval info dealias(info r);</span>
+<span id="cb84-52"><a href="#cb84-52"></a>  consteval info template_of(info r);</span>
+<span id="cb84-53"><a href="#cb84-53"></a>  consteval vector&lt;info&gt; template_arguments_of(info r);</span>
+<span id="cb84-54"><a href="#cb84-54"></a></span>
+<span id="cb84-55"><a href="#cb84-55"></a>  // [meta.reflection.member.queries], reflection member queries</span>
+<span id="cb84-56"><a href="#cb84-56"></a>  template&lt;class... Fs&gt;</span>
+<span id="cb84-57"><a href="#cb84-57"></a>    consteval vector&lt;info&gt; members_of(info type, Fs... filters);</span>
+<span id="cb84-58"><a href="#cb84-58"></a>  template&lt;class... Fs&gt;</span>
+<span id="cb84-59"><a href="#cb84-59"></a>    consteval vector&lt;info&gt; bases_of(info type, Fs... filters);</span>
+<span id="cb84-60"><a href="#cb84-60"></a>  consteval vector&lt;info&gt; static_data_members_of(info type);</span>
+<span id="cb84-61"><a href="#cb84-61"></a>  consteval vector&lt;info&gt; nonstatic_data_members_of(info type);</span>
+<span id="cb84-62"><a href="#cb84-62"></a>  consteval vector&lt;info&gt; subobjects_of(info type);</span>
+<span id="cb84-63"><a href="#cb84-63"></a>  consteval vector&lt;info&gt; enumerators_of(info enum_type);</span>
+<span id="cb84-64"><a href="#cb84-64"></a></span>
+<span id="cb84-65"><a href="#cb84-65"></a>  // [meta.reflection.unary.cat], primary type categories</span>
+<span id="cb84-66"><a href="#cb84-66"></a>  consteval bool is_void(info type);</span>
+<span id="cb84-67"><a href="#cb84-67"></a>  consteval bool is_null_pointer(info type);</span>
+<span id="cb84-68"><a href="#cb84-68"></a>  consteval bool is_integral(info type);</span>
+<span id="cb84-69"><a href="#cb84-69"></a>  consteval bool is_floating_point(info type);</span>
+<span id="cb84-70"><a href="#cb84-70"></a>  consteval bool is_array(info type);</span>
+<span id="cb84-71"><a href="#cb84-71"></a>  consteval bool is_pointer(info type);</span>
+<span id="cb84-72"><a href="#cb84-72"></a>  consteval bool is_lvalue_reference(info type);</span>
+<span id="cb84-73"><a href="#cb84-73"></a>  consteval bool is_rvalue_reference(info type);</span>
+<span id="cb84-74"><a href="#cb84-74"></a>  consteval bool is_member_object_pointer(info type);</span>
+<span id="cb84-75"><a href="#cb84-75"></a>  consteval bool is_member_function_pointer(info type);</span>
+<span id="cb84-76"><a href="#cb84-76"></a>  consteval bool is_enum(info type);</span>
+<span id="cb84-77"><a href="#cb84-77"></a>  consteval bool is_union(info type);</span>
+<span id="cb84-78"><a href="#cb84-78"></a>  consteval bool is_class(info type);</span>
+<span id="cb84-79"><a href="#cb84-79"></a>  consteval bool is_function(info type);</span>
+<span id="cb84-80"><a href="#cb84-80"></a></span>
+<span id="cb84-81"><a href="#cb84-81"></a>  // [meta.reflection.unary.comp], composite type categories</span>
+<span id="cb84-82"><a href="#cb84-82"></a>  consteval bool is_reference(info type);</span>
+<span id="cb84-83"><a href="#cb84-83"></a>  consteval bool is_arithmetic(info type);</span>
+<span id="cb84-84"><a href="#cb84-84"></a>  consteval bool is_fundamental(info type);</span>
+<span id="cb84-85"><a href="#cb84-85"></a>  consteval bool is_object(info type);</span>
+<span id="cb84-86"><a href="#cb84-86"></a>  consteval bool is_scalar(info type);</span>
+<span id="cb84-87"><a href="#cb84-87"></a>  consteval bool is_compound(info type);</span>
+<span id="cb84-88"><a href="#cb84-88"></a>  consteval bool is_member_pointer(info type);</span>
+<span id="cb84-89"><a href="#cb84-89"></a></span>
+<span id="cb84-90"><a href="#cb84-90"></a>  // [meta.reflection unary.prop], type properties</span>
+<span id="cb84-91"><a href="#cb84-91"></a>  consteval bool is_const(info type);</span>
+<span id="cb84-92"><a href="#cb84-92"></a>  consteval bool is_volatile(info type);</span>
+<span id="cb84-93"><a href="#cb84-93"></a>  consteval bool is_trivial(info type);</span>
+<span id="cb84-94"><a href="#cb84-94"></a>  consteval bool is_trivially_copyable(info type);</span>
+<span id="cb84-95"><a href="#cb84-95"></a>  consteval bool is_standard_layout(info type);</span>
+<span id="cb84-96"><a href="#cb84-96"></a>  consteval bool is_empty(info type);</span>
+<span id="cb84-97"><a href="#cb84-97"></a>  consteval bool is_polymorphic(info type);</span>
+<span id="cb84-98"><a href="#cb84-98"></a>  consteval bool is_abstract(info type);</span>
+<span id="cb84-99"><a href="#cb84-99"></a>  consteval bool is_final(info type);</span>
+<span id="cb84-100"><a href="#cb84-100"></a>  consteval bool is_aggregate(info type);</span>
+<span id="cb84-101"><a href="#cb84-101"></a>  consteval bool is_signed(info type);</span>
+<span id="cb84-102"><a href="#cb84-102"></a>  consteval bool is_unsigned(info type);</span>
+<span id="cb84-103"><a href="#cb84-103"></a>  consteval bool is_bounded_array(info type);</span>
+<span id="cb84-104"><a href="#cb84-104"></a>  consteval bool is_unbounded_array(info type);</span>
+<span id="cb84-105"><a href="#cb84-105"></a>  consteval bool is_scoped_enum(info type);</span>
+<span id="cb84-106"><a href="#cb84-106"></a></span>
+<span id="cb84-107"><a href="#cb84-107"></a>  consteval bool is_constructible(info type, span&lt;info const&gt; type_args);</span>
+<span id="cb84-108"><a href="#cb84-108"></a>  consteval bool is_default_constructible(info type);</span>
+<span id="cb84-109"><a href="#cb84-109"></a>  consteval bool is_copy_constructible(info type);</span>
+<span id="cb84-110"><a href="#cb84-110"></a>  consteval bool is_move_constructible(info type);</span>
+<span id="cb84-111"><a href="#cb84-111"></a></span>
+<span id="cb84-112"><a href="#cb84-112"></a>  consteval bool is_assignable(info dst_type, info src_type);</span>
+<span id="cb84-113"><a href="#cb84-113"></a>  consteval bool is_copy_assignable(info type);</span>
+<span id="cb84-114"><a href="#cb84-114"></a>  consteval bool is_move_assignable(info type);</span>
+<span id="cb84-115"><a href="#cb84-115"></a></span>
+<span id="cb84-116"><a href="#cb84-116"></a>  consteval bool is_swappable_with(info dst_type, info src_type);</span>
+<span id="cb84-117"><a href="#cb84-117"></a>  consteval bool is_swappable(info type);</span>
+<span id="cb84-118"><a href="#cb84-118"></a></span>
+<span id="cb84-119"><a href="#cb84-119"></a>  consteval bool is_destructible(info type);</span>
+<span id="cb84-120"><a href="#cb84-120"></a></span>
+<span id="cb84-121"><a href="#cb84-121"></a>  consteval bool is_trivially_constructible(info type, span&lt;info const&gt; type_args);</span>
+<span id="cb84-122"><a href="#cb84-122"></a>  consteval bool is_trivially_default_constructible(info type);</span>
+<span id="cb84-123"><a href="#cb84-123"></a>  consteval bool is_trivially_copy_constructible(info type);</span>
+<span id="cb84-124"><a href="#cb84-124"></a>  consteval bool is_trivially_move_constructible(info type);</span>
+<span id="cb84-125"><a href="#cb84-125"></a></span>
+<span id="cb84-126"><a href="#cb84-126"></a>  consteval bool is_trivially_assignable(info dst_type, info src_type);</span>
+<span id="cb84-127"><a href="#cb84-127"></a>  consteval bool is_trivially_copy_assignable(info type);</span>
+<span id="cb84-128"><a href="#cb84-128"></a>  consteval bool is_trivially_move_assignable(info type);</span>
+<span id="cb84-129"><a href="#cb84-129"></a>  consteval bool is_trivially_destructible(info type);</span>
+<span id="cb84-130"><a href="#cb84-130"></a></span>
+<span id="cb84-131"><a href="#cb84-131"></a>  consteval bool is_nothrow_constructible(info type, span&lt;info const&gt; type_args);</span>
+<span id="cb84-132"><a href="#cb84-132"></a>  consteval bool is_nothrow_default_constructible(info type);</span>
+<span id="cb84-133"><a href="#cb84-133"></a>  consteval bool is_nothrow_copy_constructible(info type);</span>
+<span id="cb84-134"><a href="#cb84-134"></a>  consteval bool is_nothrow_move_constructible(info type);</span>
+<span id="cb84-135"><a href="#cb84-135"></a></span>
+<span id="cb84-136"><a href="#cb84-136"></a>  consteval bool is_nothrow_assignable(info dst_type, info src_type);</span>
+<span id="cb84-137"><a href="#cb84-137"></a>  consteval bool is_nothrow_copy_assignable(info type);</span>
+<span id="cb84-138"><a href="#cb84-138"></a>  consteval bool is_nothrow_move_assignable(info type);</span>
+<span id="cb84-139"><a href="#cb84-139"></a></span>
+<span id="cb84-140"><a href="#cb84-140"></a>  consteval bool is_nothrow_swappable_with(info dst_type, info src_type);</span>
+<span id="cb84-141"><a href="#cb84-141"></a>  consteval bool is_nothrow_swappable(info type);</span>
+<span id="cb84-142"><a href="#cb84-142"></a></span>
+<span id="cb84-143"><a href="#cb84-143"></a>  consteval bool is_nothrow_destructible(info type);</span>
+<span id="cb84-144"><a href="#cb84-144"></a></span>
+<span id="cb84-145"><a href="#cb84-145"></a>  consteval bool is_implicit_lifetime(info type);</span>
+<span id="cb84-146"><a href="#cb84-146"></a></span>
+<span id="cb84-147"><a href="#cb84-147"></a>  consteval bool has_virtual_destructor(info type);</span>
+<span id="cb84-148"><a href="#cb84-148"></a></span>
+<span id="cb84-149"><a href="#cb84-149"></a>  consteval bool has_unique_object_representations(info type);</span>
+<span id="cb84-150"><a href="#cb84-150"></a></span>
+<span id="cb84-151"><a href="#cb84-151"></a>  consteval bool reference_constructs_from_temporary(info dst_type, info src_type);</span>
+<span id="cb84-152"><a href="#cb84-152"></a>  consteval bool reference_converts_from_temporary(info dst_type, info src_type);</span>
+<span id="cb84-153"><a href="#cb84-153"></a></span>
+<span id="cb84-154"><a href="#cb84-154"></a>  // [meta.reflection.unary.prop.query], type property queries</span>
+<span id="cb84-155"><a href="#cb84-155"></a>  consteval size_t alignment_of(info type);</span>
+<span id="cb84-156"><a href="#cb84-156"></a>  consteval size_t rank(info type);</span>
+<span id="cb84-157"><a href="#cb84-157"></a>  consteval size_t extent(info type, unsigned i = 0);</span>
+<span id="cb84-158"><a href="#cb84-158"></a></span>
+<span id="cb84-159"><a href="#cb84-159"></a>  // [meta.reflection.rel], type relations</span>
+<span id="cb84-160"><a href="#cb84-160"></a>  consteval bool is_same(info type1, info type2);</span>
+<span id="cb84-161"><a href="#cb84-161"></a>  consteval bool is_base_of(info base_type, info derived_type);</span>
+<span id="cb84-162"><a href="#cb84-162"></a>  consteval bool is_convertible(info src_type, info dst_type);</span>
+<span id="cb84-163"><a href="#cb84-163"></a>  consteval bool is_nothrow_convertible(info src_type, info dst_type);</span>
+<span id="cb84-164"><a href="#cb84-164"></a>  consteval bool is_layout_compatible(info type1, info type2);</span>
+<span id="cb84-165"><a href="#cb84-165"></a>  consteval bool is_pointer_interconvertible_base_of(info base_type, info derived_type);</span>
+<span id="cb84-166"><a href="#cb84-166"></a></span>
+<span id="cb84-167"><a href="#cb84-167"></a>  consteval bool is_invocable(info type, span&lt;const info&gt; type_args);</span>
+<span id="cb84-168"><a href="#cb84-168"></a>  consteval bool is_invocable_r(info result_type, info type, span&lt;const info&gt; type_args);</span>
+<span id="cb84-169"><a href="#cb84-169"></a></span>
+<span id="cb84-170"><a href="#cb84-170"></a>  consteval bool is_nothrow_invocable(info type, span&lt;const info&gt; type_args);</span>
+<span id="cb84-171"><a href="#cb84-171"></a>  consteval bool is_nothrow_invocable_r(info result_type, info type, span&lt;const info&gt; type_args);</span>
+<span id="cb84-172"><a href="#cb84-172"></a></span>
+<span id="cb84-173"><a href="#cb84-173"></a>  // [meta.reflection.trans.cv], const-volatile modifications</span>
+<span id="cb84-174"><a href="#cb84-174"></a>  consteval info remove_const(info type);</span>
+<span id="cb84-175"><a href="#cb84-175"></a>  consteval info remove_volatile(info type);</span>
+<span id="cb84-176"><a href="#cb84-176"></a>  consteval info remove_cv(info type);</span>
+<span id="cb84-177"><a href="#cb84-177"></a>  consteval info add_const(info type);</span>
+<span id="cb84-178"><a href="#cb84-178"></a>  consteval info add_volatile(info type);</span>
+<span id="cb84-179"><a href="#cb84-179"></a>  consteval info add_cv(info type);</span>
+<span id="cb84-180"><a href="#cb84-180"></a></span>
+<span id="cb84-181"><a href="#cb84-181"></a>  // [meta.reflection.trans.ref], reference modifications</span>
+<span id="cb84-182"><a href="#cb84-182"></a>  consteval info remove_reference(info type);</span>
+<span id="cb84-183"><a href="#cb84-183"></a>  consteval info add_lvalue_reference(info type);</span>
+<span id="cb84-184"><a href="#cb84-184"></a>  consteval info add_rvalue_reference(info type);</span>
+<span id="cb84-185"><a href="#cb84-185"></a></span>
+<span id="cb84-186"><a href="#cb84-186"></a>  // [meta.reflection.trans.sign], sign modifications</span>
+<span id="cb84-187"><a href="#cb84-187"></a>  consteval info make_signed(info type);</span>
+<span id="cb84-188"><a href="#cb84-188"></a>  consteval info make_unsigned(info type);</span>
+<span id="cb84-189"><a href="#cb84-189"></a></span>
+<span id="cb84-190"><a href="#cb84-190"></a>  // [meta.reflection.trans.arr], array modifications</span>
+<span id="cb84-191"><a href="#cb84-191"></a>  consteval info remove_extent(info type);</span>
+<span id="cb84-192"><a href="#cb84-192"></a>  consteval info remove_all_extents(info type);</span>
+<span id="cb84-193"><a href="#cb84-193"></a></span>
+<span id="cb84-194"><a href="#cb84-194"></a>  // [meta.reflection.trans.ptr], pointer modifications</span>
+<span id="cb84-195"><a href="#cb84-195"></a>  consteval info remove_pointer(info type);</span>
+<span id="cb84-196"><a href="#cb84-196"></a>  consteval info add_pointer(info type);</span>
+<span id="cb84-197"><a href="#cb84-197"></a></span>
+<span id="cb84-198"><a href="#cb84-198"></a>  // [meta.reflection.trans.other], other transformations</span>
+<span id="cb84-199"><a href="#cb84-199"></a>  consteval info remove_cvref(info type);</span>
+<span id="cb84-200"><a href="#cb84-200"></a>  consteval info decay(info type);</span>
+<span id="cb84-201"><a href="#cb84-201"></a>  consteval info common_type(span&lt;const info&gt; type_args);</span>
+<span id="cb84-202"><a href="#cb84-202"></a>  consteval info common_reference(span&lt;const info&gt; type_args);</span>
+<span id="cb84-203"><a href="#cb84-203"></a>  consteval info underlying_type(info type);</span>
+<span id="cb84-204"><a href="#cb84-204"></a>  consteval info invoke_result(info type, span&lt;const info&gt; type_args);</span>
+<span id="cb84-205"><a href="#cb84-205"></a>  consteval info unwrap_reference(info type);</span>
+<span id="cb84-206"><a href="#cb84-206"></a>  consteval info unwrap_ref_decay(info type);</span>
+<span id="cb84-207"><a href="#cb84-207"></a>}</span></code></pre></div>
 </div>
 </blockquote>
 <h3 data-number="5.2.3" id="meta.reflection.names-reflection-names-and-locations"><span class="header-section-number">5.2.3</span> [meta.reflection.names] Reflection names and locations<a href="#meta.reflection.names-reflection-names-and-locations" class="self-link"></a></h3>
 <blockquote>
 <div class="addu">
-<div class="sourceCode" id="cb84"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb84-1"><a href="#cb84-1"></a><span class="kw">consteval</span> string_view name_of<span class="op">(</span>info r<span class="op">)</span>;</span>
-<span id="cb84-2"><a href="#cb84-2"></a><span class="kw">consteval</span> string_view qualified_name_of<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb85"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb85-1"><a href="#cb85-1"></a><span class="kw">consteval</span> string_view name_of<span class="op">(</span>info r<span class="op">)</span>;</span>
+<span id="cb85-2"><a href="#cb85-2"></a><span class="kw">consteval</span> string_view qualified_name_of<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_61" id="pnum_61">1</a></span> <em>Returns</em>: If <code class="sourceCode cpp">r</code> designates a declared entity <code class="sourceCode cpp">X</code>, then the unqualified and qualified names of <code class="sourceCode cpp">X</code>, respectively. Otherwise, an empty <code class="sourceCode cpp">string_view</code>.</p>
-<div class="sourceCode" id="cb85"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb85-1"><a href="#cb85-1"></a><span class="kw">consteval</span> string_view display_name_of<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb86"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb86-1"><a href="#cb86-1"></a><span class="kw">consteval</span> string_view display_name_of<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_62" id="pnum_62">2</a></span> <em>Returns</em>: An implementation-defined string suitable for identifying the reflected construct.</p>
-<div class="sourceCode" id="cb86"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb86-1"><a href="#cb86-1"></a><span class="kw">consteval</span> source_location source_location_of<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb87"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb87-1"><a href="#cb87-1"></a><span class="kw">consteval</span> source_location source_location_of<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_63" id="pnum_63">3</a></span> <em>Returns</em>: An implementation-defined <code class="sourceCode cpp">source_location</code> corresponding to the reflected construct.</p>
 </div>
 </blockquote>
 <h3 data-number="5.2.4" id="meta.reflection.queries-reflection-queries"><span class="header-section-number">5.2.4</span> [meta.reflection.queries] Reflection queries<a href="#meta.reflection.queries-reflection-queries" class="self-link"></a></h3>
 <blockquote>
 <div class="addu">
-<div class="sourceCode" id="cb87"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb87-1"><a href="#cb87-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_public<span class="op">(</span>info r<span class="op">)</span>;</span>
-<span id="cb87-2"><a href="#cb87-2"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_protected<span class="op">(</span>info r<span class="op">)</span>;</span>
-<span id="cb87-3"><a href="#cb87-3"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_private<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb88"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb88-1"><a href="#cb88-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_public<span class="op">(</span>info r<span class="op">)</span>;</span>
+<span id="cb88-2"><a href="#cb88-2"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_protected<span class="op">(</span>info r<span class="op">)</span>;</span>
+<span id="cb88-3"><a href="#cb88-3"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_private<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_64" id="pnum_64">1</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="kw">true</span></code> if <code class="sourceCode cpp">r</code> designates a class member or base class that is public, protected, or private, respectively. Otherwise, <code class="sourceCode cpp"><span class="kw">false</span></code>.</p>
-<div class="sourceCode" id="cb88"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb88-1"><a href="#cb88-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_accessible<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb89"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb89-1"><a href="#cb89-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_accessible<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_65" id="pnum_65">2</a></span> <em>Returns</em>: TODO</p>
-<div class="sourceCode" id="cb89"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb89-1"><a href="#cb89-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_virtual<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb90"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb90-1"><a href="#cb90-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_virtual<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_66" id="pnum_66">3</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="kw">true</span></code> if <code class="sourceCode cpp">r</code> designates a either a virtual member function or a virtual base class. Otherwise, <code class="sourceCode cpp"><span class="kw">false</span></code>.</p>
-<div class="sourceCode" id="cb90"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb90-1"><a href="#cb90-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_pure_virtual<span class="op">(</span>info r<span class="op">)</span>;</span>
-<span id="cb90-2"><a href="#cb90-2"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_override<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb91"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb91-1"><a href="#cb91-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_pure_virtual<span class="op">(</span>info r<span class="op">)</span>;</span>
+<span id="cb91-2"><a href="#cb91-2"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_override<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_67" id="pnum_67">4</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="kw">true</span></code> if <code class="sourceCode cpp">r</code> designates a member function that is pure virtual or overrides another member function, respectively. Otherwise, <code class="sourceCode cpp"><span class="kw">false</span></code>.</p>
-<div class="sourceCode" id="cb91"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb91-1"><a href="#cb91-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_deleted<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb92"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb92-1"><a href="#cb92-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_deleted<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_68" id="pnum_68">5</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="kw">true</span></code> if <code class="sourceCode cpp">r</code> designates a function or member function that is defined as deleted. Otherwise, <code class="sourceCode cpp"><span class="kw">false</span></code>.</p>
-<div class="sourceCode" id="cb92"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb92-1"><a href="#cb92-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_defaulted<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb93"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb93-1"><a href="#cb93-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_defaulted<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_69" id="pnum_69">6</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="kw">true</span></code> if <code class="sourceCode cpp">r</code> designates a member function that is defined as defaulted. Otherwise, <code class="sourceCode cpp"><span class="kw">false</span></code>.</p>
-<div class="sourceCode" id="cb93"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb93-1"><a href="#cb93-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_explicit<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb94"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb94-1"><a href="#cb94-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_explicit<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_70" id="pnum_70">7</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="kw">true</span></code> if <code class="sourceCode cpp">r</code> designates a member function that is declared explicit. Otherwise, <code class="sourceCode cpp"><span class="kw">false</span></code>.</p>
-<div class="sourceCode" id="cb94"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb94-1"><a href="#cb94-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_bit_field<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb95"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb95-1"><a href="#cb95-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_bit_field<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_71" id="pnum_71">8</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="kw">true</span></code> if <code class="sourceCode cpp">r</code> designates a bit-field. Otherwise, <code class="sourceCode cpp"><span class="kw">false</span></code>.</p>
-<div class="sourceCode" id="cb95"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb95-1"><a href="#cb95-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> has_static_storage_duration<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb96"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb96-1"><a href="#cb96-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> has_static_storage_duration<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_72" id="pnum_72">9</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="kw">true</span></code> if <code class="sourceCode cpp">r</code> designates an object that has static storage duration. Otherwise, <code class="sourceCode cpp"><span class="kw">false</span></code>.</p>
-<div class="sourceCode" id="cb96"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb96-1"><a href="#cb96-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> has_internal_linkage<span class="op">(</span>info r<span class="op">)</span>;</span>
-<span id="cb96-2"><a href="#cb96-2"></a><span class="kw">consteval</span> <span class="dt">bool</span> has_external_linkage<span class="op">(</span>info r<span class="op">)</span>;</span>
-<span id="cb96-3"><a href="#cb96-3"></a><span class="kw">consteval</span> <span class="dt">bool</span> has_linkage<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb97"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb97-1"><a href="#cb97-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> has_internal_linkage<span class="op">(</span>info r<span class="op">)</span>;</span>
+<span id="cb97-2"><a href="#cb97-2"></a><span class="kw">consteval</span> <span class="dt">bool</span> has_external_linkage<span class="op">(</span>info r<span class="op">)</span>;</span>
+<span id="cb97-3"><a href="#cb97-3"></a><span class="kw">consteval</span> <span class="dt">bool</span> has_linkage<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_73" id="pnum_73">10</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="kw">true</span></code> if <code class="sourceCode cpp">r</code> designates an entity that has internal linkage, external linkage, or any linkage, respectively ([basic.link]). Otherwise, <code class="sourceCode cpp"><span class="kw">false</span></code>.</p>
-<div class="sourceCode" id="cb97"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb97-1"><a href="#cb97-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_namespace<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb98"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb98-1"><a href="#cb98-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_namespace<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_74" id="pnum_74">11</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="kw">true</span></code> if <code class="sourceCode cpp">r</code> designates a namespace or namespace alias. Otherwise, <code class="sourceCode cpp"><span class="kw">false</span></code>.</p>
-<div class="sourceCode" id="cb98"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb98-1"><a href="#cb98-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_function<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb99"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb99-1"><a href="#cb99-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_function<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_75" id="pnum_75">12</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="kw">true</span></code> if <code class="sourceCode cpp">r</code> designates a function or member function. Otherwise, <code class="sourceCode cpp"><span class="kw">false</span></code>.</p>
-<div class="sourceCode" id="cb99"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb99-1"><a href="#cb99-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_variable<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb100"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb100-1"><a href="#cb100-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_variable<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_76" id="pnum_76">13</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="kw">true</span></code> if <code class="sourceCode cpp">r</code> designates a variable. Otherwise, <code class="sourceCode cpp"><span class="kw">false</span></code>.</p>
-<div class="sourceCode" id="cb100"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb100-1"><a href="#cb100-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_type<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb101"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb101-1"><a href="#cb101-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_type<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_77" id="pnum_77">14</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="kw">true</span></code> if <code class="sourceCode cpp">r</code> designates a type or a type alias. Otherwise, <code class="sourceCode cpp"><span class="kw">false</span></code>.</p>
-<div class="sourceCode" id="cb101"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb101-1"><a href="#cb101-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_alias<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb102"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb102-1"><a href="#cb102-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_alias<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_78" id="pnum_78">15</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="kw">true</span></code> if <code class="sourceCode cpp">r</code> designates a type alias, alias template, or namespace alias. Otherwise, <code class="sourceCode cpp"><span class="kw">false</span></code>.</p>
-<div class="sourceCode" id="cb102"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb102-1"><a href="#cb102-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_incomplete_type<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb103"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb103-1"><a href="#cb103-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_incomplete_type<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_79" id="pnum_79">16</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="kw">true</span></code> if <code class="sourceCode cpp">delias<span class="op">(</span>r<span class="op">)</span></code> designates an incomplete type. Otherwise, <code class="sourceCode cpp"><span class="kw">false</span></code>.</p>
-<div class="sourceCode" id="cb103"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb103-1"><a href="#cb103-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_template<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb104"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb104-1"><a href="#cb104-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_template<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_80" id="pnum_80">17</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="kw">true</span></code> if <code class="sourceCode cpp">r</code> designates a function template, class template, variable template, or alias template. Otherwise, <code class="sourceCode cpp"><span class="kw">false</span></code>.</p>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_81" id="pnum_81">18</a></span> <span class="note"><span>[ <em>Note 1:</em> </span>A template specialization is not a template. <code class="sourceCode cpp">is_template<span class="op">(^</span>std<span class="op">::</span>vector<span class="op">)</span></code> is <code class="sourceCode cpp"><span class="kw">true</span></code> but <code class="sourceCode cpp">is_template<span class="op">(^</span>std<span class="op">::</span>vector<span class="op">&lt;</span><span class="dt">int</span><span class="op">&gt;)</span></code> is <code class="sourceCode cpp"><span class="kw">false</span></code>.<span> — <em>end note</em> ]</span></span></p>
-<div class="sourceCode" id="cb104"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb104-1"><a href="#cb104-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_function_template<span class="op">(</span>info r<span class="op">)</span>;</span>
-<span id="cb104-2"><a href="#cb104-2"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_variable_template<span class="op">(</span>info r<span class="op">)</span>;</span>
-<span id="cb104-3"><a href="#cb104-3"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_class_template<span class="op">(</span>info r<span class="op">)</span>;</span>
-<span id="cb104-4"><a href="#cb104-4"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_alias_template<span class="op">(</span>info r<span class="op">)</span>;</span>
-<span id="cb104-5"><a href="#cb104-5"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_concept<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb105"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb105-1"><a href="#cb105-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_function_template<span class="op">(</span>info r<span class="op">)</span>;</span>
+<span id="cb105-2"><a href="#cb105-2"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_variable_template<span class="op">(</span>info r<span class="op">)</span>;</span>
+<span id="cb105-3"><a href="#cb105-3"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_class_template<span class="op">(</span>info r<span class="op">)</span>;</span>
+<span id="cb105-4"><a href="#cb105-4"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_alias_template<span class="op">(</span>info r<span class="op">)</span>;</span>
+<span id="cb105-5"><a href="#cb105-5"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_concept<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_82" id="pnum_82">19</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="kw">true</span></code> if <code class="sourceCode cpp">r</code> designates a function template, class template, variable template, alias template, or concept, respectively. Otherwise, <code class="sourceCode cpp"><span class="kw">false</span></code>.</p>
-<div class="sourceCode" id="cb105"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb105-1"><a href="#cb105-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> has_template_arguments<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb106"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb106-1"><a href="#cb106-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> has_template_arguments<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_83" id="pnum_83">20</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="kw">true</span></code> if <code class="sourceCode cpp">r</code> designates an instantiation of a function template, variable template, class template, or an alias template. Otherwise, <code class="sourceCode cpp"><span class="kw">false</span></code>.</p>
-<div class="sourceCode" id="cb106"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb106-1"><a href="#cb106-1"></a><span class="kw">consteval</span> <span class="kw">auto</span> is_class_member<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
-<span id="cb106-2"><a href="#cb106-2"></a><span class="kw">consteval</span> <span class="kw">auto</span> is_namespace_member<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
-<span id="cb106-3"><a href="#cb106-3"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_nonstatic_data_member<span class="op">(</span>info r<span class="op">)</span>;</span>
-<span id="cb106-4"><a href="#cb106-4"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_static_member<span class="op">(</span>info r<span class="op">)</span>;</span>
-<span id="cb106-5"><a href="#cb106-5"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_base<span class="op">(</span>info r<span class="op">)</span>;</span>
-<span id="cb106-6"><a href="#cb106-6"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_constructor<span class="op">(</span>info r<span class="op">)</span>;</span>
-<span id="cb106-7"><a href="#cb106-7"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_destructor<span class="op">(</span>info r<span class="op">)</span>;</span>
-<span id="cb106-8"><a href="#cb106-8"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_special_member<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb107"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb107-1"><a href="#cb107-1"></a><span class="kw">consteval</span> <span class="kw">auto</span> is_class_member<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
+<span id="cb107-2"><a href="#cb107-2"></a><span class="kw">consteval</span> <span class="kw">auto</span> is_namespace_member<span class="op">(</span>info entity<span class="op">)</span> <span class="op">-&gt;</span> <span class="dt">bool</span>;</span>
+<span id="cb107-3"><a href="#cb107-3"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_nonstatic_data_member<span class="op">(</span>info r<span class="op">)</span>;</span>
+<span id="cb107-4"><a href="#cb107-4"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_static_member<span class="op">(</span>info r<span class="op">)</span>;</span>
+<span id="cb107-5"><a href="#cb107-5"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_base<span class="op">(</span>info r<span class="op">)</span>;</span>
+<span id="cb107-6"><a href="#cb107-6"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_constructor<span class="op">(</span>info r<span class="op">)</span>;</span>
+<span id="cb107-7"><a href="#cb107-7"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_destructor<span class="op">(</span>info r<span class="op">)</span>;</span>
+<span id="cb107-8"><a href="#cb107-8"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_special_member<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_84" id="pnum_84">21</a></span> <em>Returns</em>: <code class="sourceCode cpp"><span class="kw">true</span></code> if <code class="sourceCode cpp">r</code> designates a class member, namespace member, non-static data member, static member, base class member, constructor, destructor, or special member, respectively. Otherwise, <code class="sourceCode cpp"><span class="kw">false</span></code>.</p>
-<div class="sourceCode" id="cb107"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb107-1"><a href="#cb107-1"></a><span class="kw">consteval</span> info type_of<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb108"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb108-1"><a href="#cb108-1"></a><span class="kw">consteval</span> info type_of<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_85" id="pnum_85">22</a></span> <em>Mandates</em>: <code class="sourceCode cpp">r</code> designates a typed entity.</p>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_86" id="pnum_86">23</a></span> <em>Returns</em>: A reflection of the type of that entity.</p>
-<div class="sourceCode" id="cb108"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb108-1"><a href="#cb108-1"></a><span class="kw">consteval</span> info parent_of<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb109"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb109-1"><a href="#cb109-1"></a><span class="kw">consteval</span> info parent_of<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_87" id="pnum_87">24</a></span> <em>Mandates</em>: <code class="sourceCode cpp">r</code> designates a member of a class or a namespace.</p>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_88" id="pnum_88">25</a></span> <em>Returns</em>: A reflection of the that entity’s immediately enclosing class or namespace.</p>
-<div class="sourceCode" id="cb109"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb109-1"><a href="#cb109-1"></a><span class="kw">consteval</span> info dealias<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb110"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb110-1"><a href="#cb110-1"></a><span class="kw">consteval</span> info dealias<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_89" id="pnum_89">26</a></span> <em>Returns</em>: If <code class="sourceCode cpp">r</code> designates a type alias or a namespace alias, a reflection designating the underlying entity. Otherwise, <code class="sourceCode cpp">r</code>.</p>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_90" id="pnum_90">27</a></span> [<em>Example</em></p>
-<div class="sourceCode" id="cb110"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb110-1"><a href="#cb110-1"></a>using X = int;</span>
-<span id="cb110-2"><a href="#cb110-2"></a>using Y = X;</span>
-<span id="cb110-3"><a href="#cb110-3"></a>static_assert(dealias(^int) == ^int);</span>
-<span id="cb110-4"><a href="#cb110-4"></a>static_assert(dealias(^X) == ^int);</span>
-<span id="cb110-5"><a href="#cb110-5"></a>static_assert(dealias(^Y) == ^int);</span></code></pre></div>
+<div class="sourceCode" id="cb111"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb111-1"><a href="#cb111-1"></a>using X = int;</span>
+<span id="cb111-2"><a href="#cb111-2"></a>using Y = X;</span>
+<span id="cb111-3"><a href="#cb111-3"></a>static_assert(dealias(^int) == ^int);</span>
+<span id="cb111-4"><a href="#cb111-4"></a>static_assert(dealias(^X) == ^int);</span>
+<span id="cb111-5"><a href="#cb111-5"></a>static_assert(dealias(^Y) == ^int);</span></code></pre></div>
 <p>-<em>end example</em>]</p>
-<div class="sourceCode" id="cb111"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb111-1"><a href="#cb111-1"></a><span class="kw">consteval</span> info template_of<span class="op">(</span>info r<span class="op">)</span>;</span>
-<span id="cb111-2"><a href="#cb111-2"></a><span class="kw">consteval</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span> template_arguments_of<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb112"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb112-1"><a href="#cb112-1"></a><span class="kw">consteval</span> info template_of<span class="op">(</span>info r<span class="op">)</span>;</span>
+<span id="cb112-2"><a href="#cb112-2"></a><span class="kw">consteval</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span> template_arguments_of<span class="op">(</span>info r<span class="op">)</span>;</span></code></pre></div>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_91" id="pnum_91">28</a></span> <em>Mandates</em>: <code class="sourceCode cpp">has_template_arguments<span class="op">(</span>r<span class="op">)</span></code> is <code class="sourceCode cpp"><span class="kw">true</span></code>.</p>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_92" id="pnum_92">29</a></span> <em>Returns</em>: A reflection of the template of <code class="sourceCode cpp">r</code>, and the reflections of the template arguments of, the specialization designated by <code class="sourceCode cpp">r</code>, respectively.</p>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_93" id="pnum_93">30</a></span> [<em>Example</em>:</p>
-<div class="sourceCode" id="cb112"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb112-1"><a href="#cb112-1"></a>template &lt;class T, class U=T&gt; struct Pair { };</span>
-<span id="cb112-2"><a href="#cb112-2"></a>template &lt;class T&gt; using PairPtr = Pair&lt;T*&gt;;</span>
-<span id="cb112-3"><a href="#cb112-3"></a></span>
-<span id="cb112-4"><a href="#cb112-4"></a>static_assert(template_of(^Pair&lt;int&gt;) == ^Pair);</span>
-<span id="cb112-5"><a href="#cb112-5"></a>static_assert(template_arguments_of(^Pair&lt;int&gt;).size() == 2);</span>
-<span id="cb112-6"><a href="#cb112-6"></a></span>
-<span id="cb112-7"><a href="#cb112-7"></a>static_assert(template_of(^PairPtr&lt;int&gt;) == ^PairPtr);</span>
-<span id="cb112-8"><a href="#cb112-8"></a>static_assert(template_arguments_of(^PairPtr&lt;int&gt;).size() == 1);</span></code></pre></div>
+<div class="sourceCode" id="cb113"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb113-1"><a href="#cb113-1"></a>template &lt;class T, class U=T&gt; struct Pair { };</span>
+<span id="cb113-2"><a href="#cb113-2"></a>template &lt;class T&gt; using PairPtr = Pair&lt;T*&gt;;</span>
+<span id="cb113-3"><a href="#cb113-3"></a></span>
+<span id="cb113-4"><a href="#cb113-4"></a>static_assert(template_of(^Pair&lt;int&gt;) == ^Pair);</span>
+<span id="cb113-5"><a href="#cb113-5"></a>static_assert(template_arguments_of(^Pair&lt;int&gt;).size() == 2);</span>
+<span id="cb113-6"><a href="#cb113-6"></a></span>
+<span id="cb113-7"><a href="#cb113-7"></a>static_assert(template_of(^PairPtr&lt;int&gt;) == ^PairPtr);</span>
+<span id="cb113-8"><a href="#cb113-8"></a>static_assert(template_arguments_of(^PairPtr&lt;int&gt;).size() == 1);</span></code></pre></div>
 <p>-<em>end example</em>]</p>
 </div>
 </blockquote>
 <h3 data-number="5.2.5" id="meta.reflection.member.queries-reflection-member-queries"><span class="header-section-number">5.2.5</span> [meta.reflection.member.queries], Reflection member queries<a href="#meta.reflection.member.queries-reflection-member-queries" class="self-link"></a></h3>
 <blockquote>
 <div class="addu">
-<div class="sourceCode" id="cb113"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb113-1"><a href="#cb113-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span><span class="op">...</span> Fs<span class="op">&gt;</span></span>
-<span id="cb113-2"><a href="#cb113-2"></a>  <span class="kw">consteval</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span> members_of<span class="op">(</span>info r, Fs<span class="op">...</span> filters<span class="op">)</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb114"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb114-1"><a href="#cb114-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span><span class="op">...</span> Fs<span class="op">&gt;</span></span>
+<span id="cb114-2"><a href="#cb114-2"></a>  <span class="kw">consteval</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span> members_of<span class="op">(</span>info r, Fs<span class="op">...</span> filters<span class="op">)</span>;</span></code></pre></div>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_94" id="pnum_94">1</a></span> <em>Mandates</em>: <code class="sourceCode cpp">r</code> is a reflection designating either a class type or a namespace and <code class="sourceCode cpp"><span class="op">(</span>std<span class="op">::</span>predicate<span class="op">&lt;</span>Fs, info<span class="op">&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span></code> is <code class="sourceCode cpp"><span class="kw">true</span></code>.</p>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_95" id="pnum_95">2</a></span> <em>Returns</em>: A <code class="sourceCode cpp">vector</code> containing the reflections of all the direct members <code class="sourceCode cpp">m</code> of the entity designated by <code class="sourceCode cpp">r</code> such that <code class="sourceCode cpp"><span class="op">(</span>filters<span class="op">(</span>m<span class="op">)</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span></code> is <code class="sourceCode cpp"><span class="kw">true</span></code>. Data members are returned in the order in which they are declared, but the order of member functions and member types is unspecified. <span class="note"><span>[ <em>Note 1:</em> </span>Base classes are not members.<span> — <em>end note</em> ]</span></span></p>
-<div class="sourceCode" id="cb114"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb114-1"><a href="#cb114-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span><span class="op">...</span> Fs<span class="op">&gt;</span></span>
-<span id="cb114-2"><a href="#cb114-2"></a>  <span class="kw">consteval</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span> bases_of<span class="op">(</span>info type, Fs<span class="op">...</span> filters<span class="op">)</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb115"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb115-1"><a href="#cb115-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span><span class="op">...</span> Fs<span class="op">&gt;</span></span>
+<span id="cb115-2"><a href="#cb115-2"></a>  <span class="kw">consteval</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span> bases_of<span class="op">(</span>info type, Fs<span class="op">...</span> filters<span class="op">)</span>;</span></code></pre></div>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_96" id="pnum_96">3</a></span> <em>Mandates</em>: <code class="sourceCode cpp">type</code> designates a type and <code class="sourceCode cpp"><span class="op">(</span>std<span class="op">::</span>predicate<span class="op">&lt;</span>Fs, info<span class="op">&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span></code> is <code class="sourceCode cpp"><span class="kw">true</span></code>.</p>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_97" id="pnum_97">4</a></span> <em>Returns</em>: Let <code class="sourceCode cpp">C</code> be the type designated by <code class="sourceCode cpp">type</code>. A <code class="sourceCode cpp">vector</code> containing the reflections of all the direct base classes, if any, of <code class="sourceCode cpp">C</code> such that <code class="sourceCode cpp"><span class="op">(</span>filters<span class="op">(</span>class_type<span class="op">)</span> <span class="op">&amp;&amp;</span> <span class="op">...)</span></code> is <code class="sourceCode cpp"><span class="kw">true</span></code>. The base classes are returned in the order in which they appear the <em>base-specifier-list</em> of <code class="sourceCode cpp">C</code>.</p>
-<div class="sourceCode" id="cb115"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb115-1"><a href="#cb115-1"></a><span class="kw">consteval</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span> static_data_members_of<span class="op">(</span>info type<span class="op">)</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb116"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb116-1"><a href="#cb116-1"></a><span class="kw">consteval</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span> static_data_members_of<span class="op">(</span>info type<span class="op">)</span>;</span></code></pre></div>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_98" id="pnum_98">5</a></span> <em>Mandates</em>: <code class="sourceCode cpp">type</code> designates a type.</p>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_99" id="pnum_99">6</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> members_of<span class="op">(</span>type, is_variable<span class="op">)</span>;</code></p>
-<div class="sourceCode" id="cb116"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb116-1"><a href="#cb116-1"></a><span class="kw">consteval</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span> nonstatic_data_members_of<span class="op">(</span>info type<span class="op">)</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb117"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb117-1"><a href="#cb117-1"></a><span class="kw">consteval</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span> nonstatic_data_members_of<span class="op">(</span>info type<span class="op">)</span>;</span></code></pre></div>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_100" id="pnum_100">7</a></span> <em>Mandates</em>: <code class="sourceCode cpp">type</code> designates a type.</p>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_101" id="pnum_101">8</a></span> <em>Effects</em>: Equivalent to: <code class="sourceCode cpp"><span class="cf">return</span> members_of<span class="op">(</span>type, is_nonstatic_data_member<span class="op">)</span>;</code></p>
-<div class="sourceCode" id="cb117"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb117-1"><a href="#cb117-1"></a><span class="kw">consteval</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span> subobjects_of<span class="op">(</span>info type<span class="op">)</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb118"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb118-1"><a href="#cb118-1"></a><span class="kw">consteval</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span> subobjects_of<span class="op">(</span>info type<span class="op">)</span>;</span></code></pre></div>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_102" id="pnum_102">9</a></span> <em>Mandates</em>: <code class="sourceCode cpp">type</code> designates a type.</p>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_103" id="pnum_103">10</a></span> <em>Returns</em>: A <code class="sourceCode cpp">vector</code> containing all the reflections in <code class="sourceCode cpp">bases_of<span class="op">(</span>type<span class="op">)</span></code> followed by all the reflections in <code class="sourceCode cpp">nonstatic_data_members_of<span class="op">(</span>type<span class="op">)</span></code>.</p>
-<div class="sourceCode" id="cb118"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb118-1"><a href="#cb118-1"></a><span class="kw">consteval</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span> enumerators_of<span class="op">(</span>info enum_type<span class="op">)</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb119"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb119-1"><a href="#cb119-1"></a><span class="kw">consteval</span> vector<span class="op">&lt;</span>info<span class="op">&gt;</span> enumerators_of<span class="op">(</span>info enum_type<span class="op">)</span>;</span></code></pre></div>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_104" id="pnum_104">11</a></span> <em>Mandates</em>: <code class="sourceCode cpp">enum_type</code> designates an enumeration.</p>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_105" id="pnum_105">12</a></span> <em>Returns</em>: A <code class="sourceCode cpp">vector</code> containing the reflections of each enumerator of the enumeration designated by <code class="sourceCode cpp">enum_type</code>, in the order in which they are declared.</p>
 </div>
@@ -2813,27 +2852,27 @@ <h4 data-number="5.2.6.1" id="meta.reflection.unary.cat-primary-type-categories"
 <blockquote>
 <div class="addu">
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_108" id="pnum_108">1</a></span> For any type <code class="sourceCode cpp">T</code>, for each function <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span><em>TRAIT</em></code> defined in this clause, <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span><em>TRAIT</em><span class="op">(^</span>T<span class="op">)</span></code> equals the value of the corresponding unary type trait <code class="sourceCode cpp">std<span class="op">::</span><em>TRAIT</em>_v<span class="op">&lt;</span>T<span class="op">&gt;</span></code> as specified in <span>21.3.5.2 <a href="https://wg21.link/meta.unary.cat">[meta.unary.cat]</a></span>.</p>
-<div class="sourceCode" id="cb119"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb119-1"><a href="#cb119-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_void<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb119-2"><a href="#cb119-2"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_null_pointer<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb119-3"><a href="#cb119-3"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_integral<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb119-4"><a href="#cb119-4"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_floating_point<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb119-5"><a href="#cb119-5"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_array<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb119-6"><a href="#cb119-6"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_pointer<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb119-7"><a href="#cb119-7"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_lvalue_reference<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb119-8"><a href="#cb119-8"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_rvalue_reference<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb119-9"><a href="#cb119-9"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_member_object_pointer<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb119-10"><a href="#cb119-10"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_member_function_pointer<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb119-11"><a href="#cb119-11"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_enum<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb119-12"><a href="#cb119-12"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_union<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb119-13"><a href="#cb119-13"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_class<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb119-14"><a href="#cb119-14"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_function<span class="op">(</span>info type<span class="op">)</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb120"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb120-1"><a href="#cb120-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_void<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb120-2"><a href="#cb120-2"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_null_pointer<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb120-3"><a href="#cb120-3"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_integral<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb120-4"><a href="#cb120-4"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_floating_point<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb120-5"><a href="#cb120-5"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_array<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb120-6"><a href="#cb120-6"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_pointer<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb120-7"><a href="#cb120-7"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_lvalue_reference<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb120-8"><a href="#cb120-8"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_rvalue_reference<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb120-9"><a href="#cb120-9"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_member_object_pointer<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb120-10"><a href="#cb120-10"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_member_function_pointer<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb120-11"><a href="#cb120-11"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_enum<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb120-12"><a href="#cb120-12"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_union<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb120-13"><a href="#cb120-13"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_class<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb120-14"><a href="#cb120-14"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_function<span class="op">(</span>info type<span class="op">)</span>;</span></code></pre></div>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_109" id="pnum_109">2</a></span> [<em>Example</em></p>
-<div class="sourceCode" id="cb120"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb120-1"><a href="#cb120-1"></a>// an example implementation</span>
-<span id="cb120-2"><a href="#cb120-2"></a>namespace std::meta {</span>
-<span id="cb120-3"><a href="#cb120-3"></a>  consteval bool is_void(info type) {</span>
-<span id="cb120-4"><a href="#cb120-4"></a>    return value_of&lt;bool&gt;(substitute(^is_void_v, {type}));</span>
-<span id="cb120-5"><a href="#cb120-5"></a>  }</span>
-<span id="cb120-6"><a href="#cb120-6"></a>}</span></code></pre></div>
+<div class="sourceCode" id="cb121"><pre class="sourceCode default"><code class="sourceCode default"><span id="cb121-1"><a href="#cb121-1"></a>// an example implementation</span>
+<span id="cb121-2"><a href="#cb121-2"></a>namespace std::meta {</span>
+<span id="cb121-3"><a href="#cb121-3"></a>  consteval bool is_void(info type) {</span>
+<span id="cb121-4"><a href="#cb121-4"></a>    return value_of&lt;bool&gt;(substitute(^is_void_v, {type}));</span>
+<span id="cb121-5"><a href="#cb121-5"></a>  }</span>
+<span id="cb121-6"><a href="#cb121-6"></a>}</span></code></pre></div>
 <p><em>-end example</em>]</p>
 </div>
 </blockquote>
@@ -2841,13 +2880,13 @@ <h4 data-number="5.2.6.2" id="meta.reflection.unary.comp-composite-type-categori
 <blockquote>
 <div class="addu">
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_110" id="pnum_110">1</a></span> For any type <code class="sourceCode cpp">T</code>, for each function <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span><em>TRAIT</em></code> defined in this clause, <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span><em>TRAIT</em><span class="op">(^</span>T<span class="op">)</span></code> equals the value of the corresponding unary type trait <code class="sourceCode cpp">std<span class="op">::</span><em>TRAIT</em>_v<span class="op">&lt;</span>T<span class="op">&gt;</span></code> as specified in <span>21.3.5.3 <a href="https://wg21.link/meta.unary.comp">[meta.unary.comp]</a></span>.</p>
-<div class="sourceCode" id="cb121"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb121-1"><a href="#cb121-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_reference<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb121-2"><a href="#cb121-2"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_arithmetic<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb121-3"><a href="#cb121-3"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_fundamental<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb121-4"><a href="#cb121-4"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_object<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb121-5"><a href="#cb121-5"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_scalar<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb121-6"><a href="#cb121-6"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_compound<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb121-7"><a href="#cb121-7"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_member_pointer<span class="op">(</span>info type<span class="op">)</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb122"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb122-1"><a href="#cb122-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_reference<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb122-2"><a href="#cb122-2"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_arithmetic<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb122-3"><a href="#cb122-3"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_fundamental<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb122-4"><a href="#cb122-4"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_object<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb122-5"><a href="#cb122-5"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_scalar<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb122-6"><a href="#cb122-6"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_compound<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb122-7"><a href="#cb122-7"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_member_pointer<span class="op">(</span>info type<span class="op">)</span>;</span></code></pre></div>
 </div>
 </blockquote>
 <h4 data-number="5.2.6.3" id="meta.reflection.unary.prop-type-properties"><span class="header-section-number">5.2.6.3</span> [meta.reflection.unary.prop] Type properties<a href="#meta.reflection.unary.prop-type-properties" class="self-link"></a></h4>
@@ -2856,68 +2895,68 @@ <h4 data-number="5.2.6.3" id="meta.reflection.unary.prop-type-properties"><span
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_111" id="pnum_111">1</a></span> For any type <code class="sourceCode cpp">T</code>, for each function <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span><em>UNARY-TRAIT</em></code> defined in this clause with signature <code class="sourceCode cpp"><span class="dt">bool</span><span class="op">(</span>std<span class="op">::</span>meta<span class="op">::</span>info<span class="op">)</span></code>, <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span><em>UNARY-TRAIT</em><span class="op">(^</span>T<span class="op">)</span></code> equals the value of the corresponding type property <code class="sourceCode cpp">std<span class="op">::</span><em>UNARY-TRAIT</em>_v<span class="op">&lt;</span>T<span class="op">&gt;</span></code> as specified in <span>21.3.5.4 <a href="https://wg21.link/meta.unary.prop">[meta.unary.prop]</a></span>.</p>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_112" id="pnum_112">2</a></span> For any types <code class="sourceCode cpp">T</code> and <code class="sourceCode cpp">U</code>, for each function <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span><em>BINARY-TRAIT</em></code> defined in this clause with signature <code class="sourceCode cpp"><span class="dt">bool</span><span class="op">(</span>std<span class="op">::</span>meta<span class="op">::</span>info, std<span class="op">::</span>meta<span class="op">::</span>info<span class="op">)</span></code>, <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span><em>BINARY-TRAIT</em><span class="op">(^</span>T, <span class="op">^</span>U<span class="op">)</span></code> equals the value of the corresponding type property <code class="sourceCode cpp">std<span class="op">::</span><em>BINARY-TRAIT</em>_v<span class="op">&lt;</span>T, U<span class="op">&gt;</span></code> as specified in <span>21.3.5.4 <a href="https://wg21.link/meta.unary.prop">[meta.unary.prop]</a></span>.</p>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_113" id="pnum_113">3</a></span> For any type <code class="sourceCode cpp">T</code> and pack of types <code class="sourceCode cpp">U<span class="op">...</span></code>, for each function <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span><em>VARIADIC-TRAIT</em></code> defined in this clause with signature <code class="sourceCode cpp"><span class="dt">bool</span><span class="op">(</span>std<span class="op">::</span>meta<span class="op">::</span>info, std<span class="op">::</span>span<span class="op">&lt;</span><span class="kw">const</span> std<span class="op">::</span>meta<span class="op">::</span>info<span class="op">&gt;)</span></code>, <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span><em>VARIADIC-TRAIT</em><span class="op">(^</span>T, <span class="op">{^</span>U<span class="op">...})</span></code> equals the value of the corresponding type property <code class="sourceCode cpp">std<span class="op">::</span><em>VARIADIC-TRAIT</em>_v<span class="op">&lt;</span>T, U<span class="op">...&gt;</span></code> as specified in <span>21.3.5.4 <a href="https://wg21.link/meta.unary.prop">[meta.unary.prop]</a></span>.</p>
-<div class="sourceCode" id="cb122"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb122-1"><a href="#cb122-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_const<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb122-2"><a href="#cb122-2"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_volatile<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb122-3"><a href="#cb122-3"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_trivial<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb122-4"><a href="#cb122-4"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_trivially_copyable<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb122-5"><a href="#cb122-5"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_standard_layout<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb122-6"><a href="#cb122-6"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_empty<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb122-7"><a href="#cb122-7"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_polymorphic<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb122-8"><a href="#cb122-8"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_abstract<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb122-9"><a href="#cb122-9"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_final<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb122-10"><a href="#cb122-10"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_aggregate<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb122-11"><a href="#cb122-11"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_signed<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb122-12"><a href="#cb122-12"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_unsigned<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb122-13"><a href="#cb122-13"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_bounded_array<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb122-14"><a href="#cb122-14"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_unbounded_array<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb122-15"><a href="#cb122-15"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_scoped_enum<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb122-16"><a href="#cb122-16"></a></span>
-<span id="cb122-17"><a href="#cb122-17"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_constructible<span class="op">(</span>info type, span<span class="op">&lt;</span>info <span class="kw">const</span><span class="op">&gt;</span> type_args<span class="op">)</span>;</span>
-<span id="cb122-18"><a href="#cb122-18"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_default_constructible<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb122-19"><a href="#cb122-19"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_copy_constructible<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb122-20"><a href="#cb122-20"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_move_constructible<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb122-21"><a href="#cb122-21"></a></span>
-<span id="cb122-22"><a href="#cb122-22"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_assignable<span class="op">(</span>info dst_type, info src_type<span class="op">)</span>;</span>
-<span id="cb122-23"><a href="#cb122-23"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_copy_assignable<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb122-24"><a href="#cb122-24"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_move_assignable<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb122-25"><a href="#cb122-25"></a></span>
-<span id="cb122-26"><a href="#cb122-26"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_swappable_with<span class="op">(</span>info dst_type, info src_type<span class="op">)</span>;</span>
-<span id="cb122-27"><a href="#cb122-27"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_swappable<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb122-28"><a href="#cb122-28"></a></span>
-<span id="cb122-29"><a href="#cb122-29"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_destructible<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb122-30"><a href="#cb122-30"></a></span>
-<span id="cb122-31"><a href="#cb122-31"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_trivially_constructible<span class="op">(</span>info type, span<span class="op">&lt;</span>info <span class="kw">const</span><span class="op">&gt;</span> type_args<span class="op">)</span>;</span>
-<span id="cb122-32"><a href="#cb122-32"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_trivially_default_constructible<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb122-33"><a href="#cb122-33"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_trivially_copy_constructible<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb122-34"><a href="#cb122-34"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_trivially_move_constructible<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb122-35"><a href="#cb122-35"></a></span>
-<span id="cb122-36"><a href="#cb122-36"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_trivially_assignable<span class="op">(</span>info dst_type, info src_type<span class="op">)</span>;</span>
-<span id="cb122-37"><a href="#cb122-37"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_trivially_copy_assignable<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb122-38"><a href="#cb122-38"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_trivially_move_assignable<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb122-39"><a href="#cb122-39"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_trivially_destructible<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb122-40"><a href="#cb122-40"></a></span>
-<span id="cb122-41"><a href="#cb122-41"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_nothrow_constructible<span class="op">(</span>info type, span<span class="op">&lt;</span>info <span class="kw">const</span><span class="op">&gt;</span> type_args<span class="op">)</span>;</span>
-<span id="cb122-42"><a href="#cb122-42"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_nothrow_default_constructible<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb122-43"><a href="#cb122-43"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_nothrow_copy_constructible<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb122-44"><a href="#cb122-44"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_nothrow_move_constructible<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb122-45"><a href="#cb122-45"></a></span>
-<span id="cb122-46"><a href="#cb122-46"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_nothrow_assignable<span class="op">(</span>info dst_type, info src_type<span class="op">)</span>;</span>
-<span id="cb122-47"><a href="#cb122-47"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_nothrow_copy_assignable<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb122-48"><a href="#cb122-48"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_nothrow_move_assignable<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb122-49"><a href="#cb122-49"></a></span>
-<span id="cb122-50"><a href="#cb122-50"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_nothrow_swappable_with<span class="op">(</span>info dst_type, info src_type<span class="op">)</span>;</span>
-<span id="cb122-51"><a href="#cb122-51"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_nothrow_swappable<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb122-52"><a href="#cb122-52"></a></span>
-<span id="cb122-53"><a href="#cb122-53"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_nothrow_destructible<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb122-54"><a href="#cb122-54"></a></span>
-<span id="cb122-55"><a href="#cb122-55"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_implicit_lifetime<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb122-56"><a href="#cb122-56"></a></span>
-<span id="cb122-57"><a href="#cb122-57"></a><span class="kw">consteval</span> <span class="dt">bool</span> has_virtual_destructor<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb122-58"><a href="#cb122-58"></a></span>
-<span id="cb122-59"><a href="#cb122-59"></a><span class="kw">consteval</span> <span class="dt">bool</span> has_unique_object_representations<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb122-60"><a href="#cb122-60"></a></span>
-<span id="cb122-61"><a href="#cb122-61"></a><span class="kw">consteval</span> <span class="dt">bool</span> reference_constructs_from_temporary<span class="op">(</span>info dst_type, info src_type<span class="op">)</span>;</span>
-<span id="cb122-62"><a href="#cb122-62"></a><span class="kw">consteval</span> <span class="dt">bool</span> reference_converts_from_temporary<span class="op">(</span>info dst_type, info src_type<span class="op">)</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb123"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb123-1"><a href="#cb123-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_const<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb123-2"><a href="#cb123-2"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_volatile<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb123-3"><a href="#cb123-3"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_trivial<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb123-4"><a href="#cb123-4"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_trivially_copyable<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb123-5"><a href="#cb123-5"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_standard_layout<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb123-6"><a href="#cb123-6"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_empty<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb123-7"><a href="#cb123-7"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_polymorphic<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb123-8"><a href="#cb123-8"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_abstract<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb123-9"><a href="#cb123-9"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_final<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb123-10"><a href="#cb123-10"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_aggregate<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb123-11"><a href="#cb123-11"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_signed<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb123-12"><a href="#cb123-12"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_unsigned<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb123-13"><a href="#cb123-13"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_bounded_array<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb123-14"><a href="#cb123-14"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_unbounded_array<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb123-15"><a href="#cb123-15"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_scoped_enum<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb123-16"><a href="#cb123-16"></a></span>
+<span id="cb123-17"><a href="#cb123-17"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_constructible<span class="op">(</span>info type, span<span class="op">&lt;</span>info <span class="kw">const</span><span class="op">&gt;</span> type_args<span class="op">)</span>;</span>
+<span id="cb123-18"><a href="#cb123-18"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_default_constructible<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb123-19"><a href="#cb123-19"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_copy_constructible<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb123-20"><a href="#cb123-20"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_move_constructible<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb123-21"><a href="#cb123-21"></a></span>
+<span id="cb123-22"><a href="#cb123-22"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_assignable<span class="op">(</span>info dst_type, info src_type<span class="op">)</span>;</span>
+<span id="cb123-23"><a href="#cb123-23"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_copy_assignable<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb123-24"><a href="#cb123-24"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_move_assignable<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb123-25"><a href="#cb123-25"></a></span>
+<span id="cb123-26"><a href="#cb123-26"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_swappable_with<span class="op">(</span>info dst_type, info src_type<span class="op">)</span>;</span>
+<span id="cb123-27"><a href="#cb123-27"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_swappable<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb123-28"><a href="#cb123-28"></a></span>
+<span id="cb123-29"><a href="#cb123-29"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_destructible<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb123-30"><a href="#cb123-30"></a></span>
+<span id="cb123-31"><a href="#cb123-31"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_trivially_constructible<span class="op">(</span>info type, span<span class="op">&lt;</span>info <span class="kw">const</span><span class="op">&gt;</span> type_args<span class="op">)</span>;</span>
+<span id="cb123-32"><a href="#cb123-32"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_trivially_default_constructible<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb123-33"><a href="#cb123-33"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_trivially_copy_constructible<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb123-34"><a href="#cb123-34"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_trivially_move_constructible<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb123-35"><a href="#cb123-35"></a></span>
+<span id="cb123-36"><a href="#cb123-36"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_trivially_assignable<span class="op">(</span>info dst_type, info src_type<span class="op">)</span>;</span>
+<span id="cb123-37"><a href="#cb123-37"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_trivially_copy_assignable<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb123-38"><a href="#cb123-38"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_trivially_move_assignable<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb123-39"><a href="#cb123-39"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_trivially_destructible<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb123-40"><a href="#cb123-40"></a></span>
+<span id="cb123-41"><a href="#cb123-41"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_nothrow_constructible<span class="op">(</span>info type, span<span class="op">&lt;</span>info <span class="kw">const</span><span class="op">&gt;</span> type_args<span class="op">)</span>;</span>
+<span id="cb123-42"><a href="#cb123-42"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_nothrow_default_constructible<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb123-43"><a href="#cb123-43"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_nothrow_copy_constructible<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb123-44"><a href="#cb123-44"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_nothrow_move_constructible<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb123-45"><a href="#cb123-45"></a></span>
+<span id="cb123-46"><a href="#cb123-46"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_nothrow_assignable<span class="op">(</span>info dst_type, info src_type<span class="op">)</span>;</span>
+<span id="cb123-47"><a href="#cb123-47"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_nothrow_copy_assignable<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb123-48"><a href="#cb123-48"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_nothrow_move_assignable<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb123-49"><a href="#cb123-49"></a></span>
+<span id="cb123-50"><a href="#cb123-50"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_nothrow_swappable_with<span class="op">(</span>info dst_type, info src_type<span class="op">)</span>;</span>
+<span id="cb123-51"><a href="#cb123-51"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_nothrow_swappable<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb123-52"><a href="#cb123-52"></a></span>
+<span id="cb123-53"><a href="#cb123-53"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_nothrow_destructible<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb123-54"><a href="#cb123-54"></a></span>
+<span id="cb123-55"><a href="#cb123-55"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_implicit_lifetime<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb123-56"><a href="#cb123-56"></a></span>
+<span id="cb123-57"><a href="#cb123-57"></a><span class="kw">consteval</span> <span class="dt">bool</span> has_virtual_destructor<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb123-58"><a href="#cb123-58"></a></span>
+<span id="cb123-59"><a href="#cb123-59"></a><span class="kw">consteval</span> <span class="dt">bool</span> has_unique_object_representations<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb123-60"><a href="#cb123-60"></a></span>
+<span id="cb123-61"><a href="#cb123-61"></a><span class="kw">consteval</span> <span class="dt">bool</span> reference_constructs_from_temporary<span class="op">(</span>info dst_type, info src_type<span class="op">)</span>;</span>
+<span id="cb123-62"><a href="#cb123-62"></a><span class="kw">consteval</span> <span class="dt">bool</span> reference_converts_from_temporary<span class="op">(</span>info dst_type, info src_type<span class="op">)</span>;</span></code></pre></div>
 </div>
 </blockquote>
 <h4 data-number="5.2.6.4" id="meta.reflection.unary.prop.query-type-property-queries"><span class="header-section-number">5.2.6.4</span> [meta.reflection.unary.prop.query] Type property queries<a href="#meta.reflection.unary.prop.query-type-property-queries" class="self-link"></a></h4>
@@ -2925,9 +2964,9 @@ <h4 data-number="5.2.6.4" id="meta.reflection.unary.prop.query-type-property-que
 <div class="addu">
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_114" id="pnum_114">1</a></span> For any type <code class="sourceCode cpp">T</code>, for each function <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span><em>PROP</em></code> defined in this clause with signature <code class="sourceCode cpp"><span class="dt">size_t</span><span class="op">(</span>std<span class="op">::</span>meta<span class="op">::</span>info<span class="op">)</span></code>, <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span><em>PROP</em><span class="op">(^</span>T<span class="op">)</span></code> equals the value of the corresponding type property <code class="sourceCode cpp">std<span class="op">::</span><em>PROP</em>_v<span class="op">&lt;</span>T<span class="op">&gt;</span></code> as specified in <span>21.3.6 <a href="https://wg21.link/meta.unary.prop.query">[meta.unary.prop.query]</a></span>.</p>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_115" id="pnum_115">2</a></span> For any type <code class="sourceCode cpp">T</code> and unsigned integer value <code class="sourceCode cpp">I</code>, <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span>extent<span class="op">(^</span>T, I<span class="op">)</span></code> equals <code class="sourceCode cpp">std<span class="op">::</span>extent_v<span class="op">&lt;</span>T, I<span class="op">&gt;</span></code> ([meta.unary.prop.query]).</p>
-<div class="sourceCode" id="cb123"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb123-1"><a href="#cb123-1"></a><span class="kw">consteval</span> <span class="dt">size_t</span> alignment_of<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb123-2"><a href="#cb123-2"></a><span class="kw">consteval</span> <span class="dt">size_t</span> rank<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb123-3"><a href="#cb123-3"></a><span class="kw">consteval</span> <span class="dt">size_t</span> extent<span class="op">(</span>info type, <span class="dt">unsigned</span> i <span class="op">=</span> <span class="dv">0</span><span class="op">)</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb124"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb124-1"><a href="#cb124-1"></a><span class="kw">consteval</span> <span class="dt">size_t</span> alignment_of<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb124-2"><a href="#cb124-2"></a><span class="kw">consteval</span> <span class="dt">size_t</span> rank<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb124-3"><a href="#cb124-3"></a><span class="kw">consteval</span> <span class="dt">size_t</span> extent<span class="op">(</span>info type, <span class="dt">unsigned</span> i <span class="op">=</span> <span class="dv">0</span><span class="op">)</span>;</span></code></pre></div>
 </div>
 </blockquote>
 <h3 data-number="5.2.7" id="meta.reflection.rel-type-relations"><span class="header-section-number">5.2.7</span> [meta.reflection.rel], Type relations<a href="#meta.reflection.rel-type-relations" class="self-link"></a></h3>
@@ -2937,18 +2976,18 @@ <h3 data-number="5.2.7" id="meta.reflection.rel-type-relations"><span class="hea
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_117" id="pnum_117">2</a></span> For any types <code class="sourceCode cpp">T</code> and <code class="sourceCode cpp">U</code>, for each function <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span><em>REL</em></code> defined in this clause with signature <code class="sourceCode cpp"><span class="dt">bool</span><span class="op">(</span>std<span class="op">::</span>meta<span class="op">::</span>info, std<span class="op">::</span>meta<span class="op">::</span>info<span class="op">)</span></code>, <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span><em>REL</em><span class="op">(^</span>T, <span class="op">^</span>U<span class="op">)</span></code> equals the value of the corresponding type relation <code class="sourceCode cpp">std<span class="op">::</span><em>REL</em>_v<span class="op">&lt;</span>T, U<span class="op">&gt;</span></code> as specified in <span>21.3.7 <a href="https://wg21.link/meta.rel">[meta.rel]</a></span>.</p>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_118" id="pnum_118">3</a></span> For any type <code class="sourceCode cpp">T</code> and pack of types <code class="sourceCode cpp">U<span class="op">...</span></code>, for each function <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span><em>VARIADIC-REL</em></code> defined in this clause with signature <code class="sourceCode cpp"><span class="dt">bool</span><span class="op">(</span>std<span class="op">::</span>meta<span class="op">::</span>info, std<span class="op">::</span>span<span class="op">&lt;</span><span class="kw">const</span> std<span class="op">::</span>meta<span class="op">::</span>info<span class="op">&gt;)</span></code>, <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span><em>VARIADIC-REL</em><span class="op">(^</span>T, <span class="op">{^</span>U<span class="op">...})</span></code> equals the value of the corresponding type relation <code class="sourceCode cpp">std<span class="op">::</span><em>VARIADIC-REL</em>_v<span class="op">&lt;</span>T, U<span class="op">...&gt;</span></code> as specified in <span>21.3.7 <a href="https://wg21.link/meta.rel">[meta.rel]</a></span>.</p>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_119" id="pnum_119">4</a></span> For any types <code class="sourceCode cpp">T</code> and <code class="sourceCode cpp">R</code> and pack of types <code class="sourceCode cpp">U<span class="op">...</span></code>, for each function <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span><em>VARIADIC-REL-R</em></code> defined in this clause with signature <code class="sourceCode cpp"><span class="dt">bool</span><span class="op">(</span>std<span class="op">::</span>meta<span class="op">::</span>info, std<span class="op">::</span>meta<span class="op">::</span>info, std<span class="op">::</span>span<span class="op">&lt;</span><span class="kw">const</span> std<span class="op">::</span>meta<span class="op">::</span>info<span class="op">&gt;)</span></code>, <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span><em>VARIADIC-REL-R</em><span class="op">(^</span>R, <span class="op">^</span>T, <span class="op">{^</span>U<span class="op">...})</span></code> equals the value of the corresponding type relation <code class="sourceCode cpp">std<span class="op">::</span><em>VARIADIC-REL-R</em>_v<span class="op">&lt;</span>R, T, U<span class="op">...&gt;</span></code> as specified in <span>21.3.7 <a href="https://wg21.link/meta.rel">[meta.rel]</a></span>.</p>
-<div class="sourceCode" id="cb124"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb124-1"><a href="#cb124-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_same<span class="op">(</span>info type1, info type2<span class="op">)</span>;</span>
-<span id="cb124-2"><a href="#cb124-2"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_base_of<span class="op">(</span>info base_type, info derived_type<span class="op">)</span>;</span>
-<span id="cb124-3"><a href="#cb124-3"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_convertible<span class="op">(</span>info src_type, info dst_type<span class="op">)</span>;</span>
-<span id="cb124-4"><a href="#cb124-4"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_nothrow_convertible<span class="op">(</span>info src_type, info dst_type<span class="op">)</span>;</span>
-<span id="cb124-5"><a href="#cb124-5"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_layout_compatible<span class="op">(</span>info type1, info type2<span class="op">)</span>;</span>
-<span id="cb124-6"><a href="#cb124-6"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_pointer_interconvertible_base_of<span class="op">(</span>info base_type, info derived_type<span class="op">)</span>;</span>
-<span id="cb124-7"><a href="#cb124-7"></a></span>
-<span id="cb124-8"><a href="#cb124-8"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_invocable<span class="op">(</span>info type, span<span class="op">&lt;</span><span class="kw">const</span> info<span class="op">&gt;</span> type_args<span class="op">)</span>;</span>
-<span id="cb124-9"><a href="#cb124-9"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_invocable_r<span class="op">(</span>info result_type, info type, span<span class="op">&lt;</span><span class="kw">const</span> info<span class="op">&gt;</span> type_args<span class="op">)</span>;</span>
-<span id="cb124-10"><a href="#cb124-10"></a></span>
-<span id="cb124-11"><a href="#cb124-11"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_nothrow_invocable<span class="op">(</span>info type, span<span class="op">&lt;</span><span class="kw">const</span> info<span class="op">&gt;</span> type_args<span class="op">)</span>;</span>
-<span id="cb124-12"><a href="#cb124-12"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_nothrow_invocable_r<span class="op">(</span>info result_type, info type, span<span class="op">&lt;</span><span class="kw">const</span> info<span class="op">&gt;</span> type_args<span class="op">)</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb125"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb125-1"><a href="#cb125-1"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_same<span class="op">(</span>info type1, info type2<span class="op">)</span>;</span>
+<span id="cb125-2"><a href="#cb125-2"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_base_of<span class="op">(</span>info base_type, info derived_type<span class="op">)</span>;</span>
+<span id="cb125-3"><a href="#cb125-3"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_convertible<span class="op">(</span>info src_type, info dst_type<span class="op">)</span>;</span>
+<span id="cb125-4"><a href="#cb125-4"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_nothrow_convertible<span class="op">(</span>info src_type, info dst_type<span class="op">)</span>;</span>
+<span id="cb125-5"><a href="#cb125-5"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_layout_compatible<span class="op">(</span>info type1, info type2<span class="op">)</span>;</span>
+<span id="cb125-6"><a href="#cb125-6"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_pointer_interconvertible_base_of<span class="op">(</span>info base_type, info derived_type<span class="op">)</span>;</span>
+<span id="cb125-7"><a href="#cb125-7"></a></span>
+<span id="cb125-8"><a href="#cb125-8"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_invocable<span class="op">(</span>info type, span<span class="op">&lt;</span><span class="kw">const</span> info<span class="op">&gt;</span> type_args<span class="op">)</span>;</span>
+<span id="cb125-9"><a href="#cb125-9"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_invocable_r<span class="op">(</span>info result_type, info type, span<span class="op">&lt;</span><span class="kw">const</span> info<span class="op">&gt;</span> type_args<span class="op">)</span>;</span>
+<span id="cb125-10"><a href="#cb125-10"></a></span>
+<span id="cb125-11"><a href="#cb125-11"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_nothrow_invocable<span class="op">(</span>info type, span<span class="op">&lt;</span><span class="kw">const</span> info<span class="op">&gt;</span> type_args<span class="op">)</span>;</span>
+<span id="cb125-12"><a href="#cb125-12"></a><span class="kw">consteval</span> <span class="dt">bool</span> is_nothrow_invocable_r<span class="op">(</span>info result_type, info type, span<span class="op">&lt;</span><span class="kw">const</span> info<span class="op">&gt;</span> type_args<span class="op">)</span>;</span></code></pre></div>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_120" id="pnum_120">5</a></span> <span class="note"><span>[ <em>Note 1:</em> </span>If <code class="sourceCode cpp">t</code> is a reflection of the type <code class="sourceCode cpp"><span class="dt">int</span></code> and <code class="sourceCode cpp">u</code> is a reflection of an alias to the type <code class="sourceCode cpp"><span class="dt">int</span></code>, then <code class="sourceCode cpp">t <span class="op">==</span> u</code> is <code class="sourceCode cpp"><span class="kw">false</span></code> but <code class="sourceCode cpp">is_same<span class="op">(</span>t, u<span class="op">)</span></code> is <code class="sourceCode cpp"><span class="kw">true</span></code>. <code class="sourceCode cpp">t <span class="op">==</span> dealias<span class="op">(</span>u<span class="op">)</span></code> is also <code class="sourceCode cpp"><span class="kw">true</span></code>.<span> — <em>end note</em> ]</span></span>.</p>
 </div>
 </blockquote>
@@ -2962,45 +3001,45 @@ <h4 data-number="5.2.8.1" id="meta.reflection.trans.cv-const-volatile-modificati
 <blockquote>
 <div class="addu">
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_122" id="pnum_122">1</a></span> For any type <code class="sourceCode cpp">T</code>, for each function <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span><em>MOD</em></code> defined in this clause, <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span><em>MOD</em><span class="op">(^</span>T<span class="op">)</span></code> returns the reflection of the corresponding type <code class="sourceCode cpp">std<span class="op">::</span><em>MOD</em>_t<span class="op">&lt;</span>T<span class="op">&gt;</span></code> as specified in <span>21.3.8.2 <a href="https://wg21.link/meta.trans.cv">[meta.trans.cv]</a></span>.</p>
-<div class="sourceCode" id="cb125"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb125-1"><a href="#cb125-1"></a><span class="kw">consteval</span> info remove_const<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb125-2"><a href="#cb125-2"></a><span class="kw">consteval</span> info remove_volatile<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb125-3"><a href="#cb125-3"></a><span class="kw">consteval</span> info remove_cv<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb125-4"><a href="#cb125-4"></a><span class="kw">consteval</span> info add_const<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb125-5"><a href="#cb125-5"></a><span class="kw">consteval</span> info add_volatile<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb125-6"><a href="#cb125-6"></a><span class="kw">consteval</span> info add_cv<span class="op">(</span>info type<span class="op">)</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb126"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb126-1"><a href="#cb126-1"></a><span class="kw">consteval</span> info remove_const<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb126-2"><a href="#cb126-2"></a><span class="kw">consteval</span> info remove_volatile<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb126-3"><a href="#cb126-3"></a><span class="kw">consteval</span> info remove_cv<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb126-4"><a href="#cb126-4"></a><span class="kw">consteval</span> info add_const<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb126-5"><a href="#cb126-5"></a><span class="kw">consteval</span> info add_volatile<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb126-6"><a href="#cb126-6"></a><span class="kw">consteval</span> info add_cv<span class="op">(</span>info type<span class="op">)</span>;</span></code></pre></div>
 </div>
 </blockquote>
 <h4 data-number="5.2.8.2" id="meta.reflection.trans.ref-reference-modifications"><span class="header-section-number">5.2.8.2</span> [meta.reflection.trans.ref], Reference modifications<a href="#meta.reflection.trans.ref-reference-modifications" class="self-link"></a></h4>
 <blockquote>
 <div class="addu">
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_123" id="pnum_123">1</a></span> For any type <code class="sourceCode cpp">T</code>, for each function <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span><em>MOD</em></code> defined in this clause, <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span><em>MOD</em><span class="op">(^</span>T<span class="op">)</span></code> returns the reflection of the corresponding type <code class="sourceCode cpp">std<span class="op">::</span><em>MOD</em>_t<span class="op">&lt;</span>T<span class="op">&gt;</span></code> as specified in <span>21.3.8.3 <a href="https://wg21.link/meta.trans.ref">[meta.trans.ref]</a></span>.</p>
-<div class="sourceCode" id="cb126"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb126-1"><a href="#cb126-1"></a><span class="kw">consteval</span> info remove_reference<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb126-2"><a href="#cb126-2"></a><span class="kw">consteval</span> info add_lvalue_reference<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb126-3"><a href="#cb126-3"></a><span class="kw">consteval</span> info add_rvalue_reference<span class="op">(</span>info type<span class="op">)</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb127"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb127-1"><a href="#cb127-1"></a><span class="kw">consteval</span> info remove_reference<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb127-2"><a href="#cb127-2"></a><span class="kw">consteval</span> info add_lvalue_reference<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb127-3"><a href="#cb127-3"></a><span class="kw">consteval</span> info add_rvalue_reference<span class="op">(</span>info type<span class="op">)</span>;</span></code></pre></div>
 </div>
 </blockquote>
 <h4 data-number="5.2.8.3" id="meta.reflection.trans.sign-sign-modifications"><span class="header-section-number">5.2.8.3</span> [meta.reflection.trans.sign], Sign modifications<a href="#meta.reflection.trans.sign-sign-modifications" class="self-link"></a></h4>
 <blockquote>
 <div class="addu">
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_124" id="pnum_124">1</a></span> For any type <code class="sourceCode cpp">T</code>, for each function <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span><em>MOD</em></code> defined in this clause, <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span><em>MOD</em><span class="op">(^</span>T<span class="op">)</span></code> returns the reflection of the corresponding type <code class="sourceCode cpp">std<span class="op">::</span><em>MOD</em>_t<span class="op">&lt;</span>T<span class="op">&gt;</span></code> as specified in <span>21.3.8.4 <a href="https://wg21.link/meta.trans.sign">[meta.trans.sign]</a></span>.</p>
-<div class="sourceCode" id="cb127"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb127-1"><a href="#cb127-1"></a><span class="kw">consteval</span> info make_signed<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb127-2"><a href="#cb127-2"></a><span class="kw">consteval</span> info make_unsigned<span class="op">(</span>info type<span class="op">)</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb128"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb128-1"><a href="#cb128-1"></a><span class="kw">consteval</span> info make_signed<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb128-2"><a href="#cb128-2"></a><span class="kw">consteval</span> info make_unsigned<span class="op">(</span>info type<span class="op">)</span>;</span></code></pre></div>
 </div>
 </blockquote>
 <h4 data-number="5.2.8.4" id="meta.reflection.trans.arr-array-modifications"><span class="header-section-number">5.2.8.4</span> [meta.reflection.trans.arr], Array modifications<a href="#meta.reflection.trans.arr-array-modifications" class="self-link"></a></h4>
 <blockquote>
 <div class="addu">
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_125" id="pnum_125">1</a></span> For any type <code class="sourceCode cpp">T</code>, for each function <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span><em>MOD</em></code> defined in this clause, <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span><em>MOD</em><span class="op">(^</span>T<span class="op">)</span></code> returns the reflection of the corresponding type <code class="sourceCode cpp">std<span class="op">::</span><em>MOD</em>_t<span class="op">&lt;</span>T<span class="op">&gt;</span></code> as specified in <span>21.3.8.5 <a href="https://wg21.link/meta.trans.arr">[meta.trans.arr]</a></span>.</p>
-<div class="sourceCode" id="cb128"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb128-1"><a href="#cb128-1"></a><span class="kw">consteval</span> info remove_extent<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb128-2"><a href="#cb128-2"></a><span class="kw">consteval</span> info remove_all_extents<span class="op">(</span>info type<span class="op">)</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb129"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb129-1"><a href="#cb129-1"></a><span class="kw">consteval</span> info remove_extent<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb129-2"><a href="#cb129-2"></a><span class="kw">consteval</span> info remove_all_extents<span class="op">(</span>info type<span class="op">)</span>;</span></code></pre></div>
 </div>
 </blockquote>
 <h4 data-number="5.2.8.5" id="meta.reflection.trans.ptr-pointer-modifications"><span class="header-section-number">5.2.8.5</span> [meta.reflection.trans.ptr], Pointer modifications<a href="#meta.reflection.trans.ptr-pointer-modifications" class="self-link"></a></h4>
 <blockquote>
 <div class="addu">
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_126" id="pnum_126">1</a></span> For any type <code class="sourceCode cpp">T</code>, for each function <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span><em>MOD</em></code> defined in this clause, <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span><em>MOD</em><span class="op">(^</span>T<span class="op">)</span></code> returns the reflection of the corresponding type <code class="sourceCode cpp">std<span class="op">::</span><em>MOD</em>_t<span class="op">&lt;</span>T<span class="op">&gt;</span></code> as specified in <span>21.3.8.6 <a href="https://wg21.link/meta.trans.ptr">[meta.trans.ptr]</a></span>.</p>
-<div class="sourceCode" id="cb129"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb129-1"><a href="#cb129-1"></a><span class="kw">consteval</span> info remove_pointer<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb129-2"><a href="#cb129-2"></a><span class="kw">consteval</span> info add_pointer<span class="op">(</span>info type<span class="op">)</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb130"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb130-1"><a href="#cb130-1"></a><span class="kw">consteval</span> info remove_pointer<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb130-2"><a href="#cb130-2"></a><span class="kw">consteval</span> info add_pointer<span class="op">(</span>info type<span class="op">)</span>;</span></code></pre></div>
 </div>
 </blockquote>
 <h4 data-number="5.2.8.6" id="meta.reflection.trans.other-other-transformations"><span class="header-section-number">5.2.8.6</span> [meta.reflection.trans.other], Other transformations<a href="#meta.reflection.trans.other-other-transformations" class="self-link"></a></h4>
@@ -3010,23 +3049,23 @@ <h4 data-number="5.2.8.6" id="meta.reflection.trans.other-other-transformations"
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_127" id="pnum_127">1</a></span> For any type <code class="sourceCode cpp">T</code>, for each function <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span><em>MOD</em></code> defined in this clause with signature <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span>info<span class="op">(</span>std<span class="op">::</span>meta<span class="op">::</span>info<span class="op">)</span></code>, <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span><em>MOD</em><span class="op">(^</span>T<span class="op">)</span></code> returns the reflection of the corresponding type <code class="sourceCode cpp">std<span class="op">::</span><em>MOD</em>_t<span class="op">&lt;</span>T<span class="op">&gt;</span></code> as specified in <span>21.3.8.7 <a href="https://wg21.link/meta.trans.other">[meta.trans.other]</a></span>.</p>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_128" id="pnum_128">2</a></span> For any pack of types <code class="sourceCode cpp">T<span class="op">...</span></code>, for each function <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span><em>VARIADIC-MOD</em></code> defined in this clause with signature <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span>info<span class="op">(</span>std<span class="op">::</span>span<span class="op">&lt;</span><span class="kw">const</span> std<span class="op">::</span>meta<span class="op">::</span>info<span class="op">&gt;)</span></code>, <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span><em>VARIADIC-MOD</em><span class="op">({^</span>T<span class="op">...})</span></code> returns the reflection of the corresponding type <code class="sourceCode cpp">std<span class="op">::</span><em>VARIADIC-MOD</em>_t<span class="op">&lt;</span>T<span class="op">...&gt;</span></code> as specified in <span>21.3.8.7 <a href="https://wg21.link/meta.trans.other">[meta.trans.other]</a></span>.</p>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_129" id="pnum_129">3</a></span> For any type <code class="sourceCode cpp">T</code> and pack of types <code class="sourceCode cpp">U<span class="op">...</span></code>, <code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span>invoke_result<span class="op">(^</span>T, <span class="op">{^</span>u<span class="op">...})</span></code> returns the reflection of the corresponding type <code class="sourceCode cpp">std<span class="op">::</span>invoke_result_t<span class="op">&lt;</span>T, U<span class="op">...&gt;</span></code> (<span>21.3.8.7 <a href="https://wg21.link/meta.trans.other">[meta.trans.other]</a></span>).</p>
-<div class="sourceCode" id="cb130"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb130-1"><a href="#cb130-1"></a><span class="kw">consteval</span> info remove_cvref<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb130-2"><a href="#cb130-2"></a><span class="kw">consteval</span> info decay<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb130-3"><a href="#cb130-3"></a><span class="kw">consteval</span> info common_type<span class="op">(</span>span<span class="op">&lt;</span><span class="kw">const</span> info<span class="op">&gt;</span> type_args<span class="op">)</span>;</span>
-<span id="cb130-4"><a href="#cb130-4"></a><span class="kw">consteval</span> info common_reference<span class="op">(</span>span<span class="op">&lt;</span><span class="kw">const</span> info<span class="op">&gt;</span> type_args<span class="op">)</span>;</span>
-<span id="cb130-5"><a href="#cb130-5"></a><span class="kw">consteval</span> info underlying_type<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb130-6"><a href="#cb130-6"></a><span class="kw">consteval</span> info invoke_result<span class="op">(</span>info type, span<span class="op">&lt;</span><span class="kw">const</span> info<span class="op">&gt;</span> type_args<span class="op">)</span>;</span>
-<span id="cb130-7"><a href="#cb130-7"></a><span class="kw">consteval</span> info unwrap_reference<span class="op">(</span>info type<span class="op">)</span>;</span>
-<span id="cb130-8"><a href="#cb130-8"></a><span class="kw">consteval</span> info unwrap_ref_decay<span class="op">(</span>info type<span class="op">)</span>;</span></code></pre></div>
+<div class="sourceCode" id="cb131"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb131-1"><a href="#cb131-1"></a><span class="kw">consteval</span> info remove_cvref<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb131-2"><a href="#cb131-2"></a><span class="kw">consteval</span> info decay<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb131-3"><a href="#cb131-3"></a><span class="kw">consteval</span> info common_type<span class="op">(</span>span<span class="op">&lt;</span><span class="kw">const</span> info<span class="op">&gt;</span> type_args<span class="op">)</span>;</span>
+<span id="cb131-4"><a href="#cb131-4"></a><span class="kw">consteval</span> info common_reference<span class="op">(</span>span<span class="op">&lt;</span><span class="kw">const</span> info<span class="op">&gt;</span> type_args<span class="op">)</span>;</span>
+<span id="cb131-5"><a href="#cb131-5"></a><span class="kw">consteval</span> info underlying_type<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb131-6"><a href="#cb131-6"></a><span class="kw">consteval</span> info invoke_result<span class="op">(</span>info type, span<span class="op">&lt;</span><span class="kw">const</span> info<span class="op">&gt;</span> type_args<span class="op">)</span>;</span>
+<span id="cb131-7"><a href="#cb131-7"></a><span class="kw">consteval</span> info unwrap_reference<span class="op">(</span>info type<span class="op">)</span>;</span>
+<span id="cb131-8"><a href="#cb131-8"></a><span class="kw">consteval</span> info unwrap_ref_decay<span class="op">(</span>info type<span class="op">)</span>;</span></code></pre></div>
 <p><span class="marginalizedparent"><a class="marginalized" href="#pnum_130" id="pnum_130">4</a></span> [<em>Example</em>:</p>
-<div class="sourceCode" id="cb131"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb131-1"><a href="#cb131-1"></a><span class="co">// example implementation</span></span>
-<span id="cb131-2"><a href="#cb131-2"></a><span class="kw">consteval</span> info unwrap_reference<span class="op">(</span>info type<span class="op">)</span> <span class="op">{</span></span>
-<span id="cb131-3"><a href="#cb131-3"></a>  <span class="cf">if</span> <span class="op">(</span>has_template_arguments<span class="op">(</span>type<span class="op">)</span> <span class="op">&amp;&amp;</span> template_of<span class="op">(</span>type<span class="op">)</span> <span class="op">==</span> <span class="op">^</span>reference_wrapper<span class="op">)</span> <span class="op">{</span></span>
-<span id="cb131-4"><a href="#cb131-4"></a>    <span class="cf">return</span> add_lvalue_reference<span class="op">(</span>template_arguments_of<span class="op">(</span>type<span class="op">)[</span><span class="dv">0</span><span class="op">])</span>;</span>
-<span id="cb131-5"><a href="#cb131-5"></a>  <span class="op">}</span> <span class="cf">else</span> <span class="op">{</span></span>
-<span id="cb131-6"><a href="#cb131-6"></a>    <span class="cf">return</span> type;</span>
-<span id="cb131-7"><a href="#cb131-7"></a>  <span class="op">}</span></span>
-<span id="cb131-8"><a href="#cb131-8"></a><span class="op">}</span></span></code></pre></div>
+<div class="sourceCode" id="cb132"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb132-1"><a href="#cb132-1"></a><span class="co">// example implementation</span></span>
+<span id="cb132-2"><a href="#cb132-2"></a><span class="kw">consteval</span> info unwrap_reference<span class="op">(</span>info type<span class="op">)</span> <span class="op">{</span></span>
+<span id="cb132-3"><a href="#cb132-3"></a>  <span class="cf">if</span> <span class="op">(</span>has_template_arguments<span class="op">(</span>type<span class="op">)</span> <span class="op">&amp;&amp;</span> template_of<span class="op">(</span>type<span class="op">)</span> <span class="op">==</span> <span class="op">^</span>reference_wrapper<span class="op">)</span> <span class="op">{</span></span>
+<span id="cb132-4"><a href="#cb132-4"></a>    <span class="cf">return</span> add_lvalue_reference<span class="op">(</span>template_arguments_of<span class="op">(</span>type<span class="op">)[</span><span class="dv">0</span><span class="op">])</span>;</span>
+<span id="cb132-5"><a href="#cb132-5"></a>  <span class="op">}</span> <span class="cf">else</span> <span class="op">{</span></span>
+<span id="cb132-6"><a href="#cb132-6"></a>    <span class="cf">return</span> type;</span>
+<span id="cb132-7"><a href="#cb132-7"></a>  <span class="op">}</span></span>
+<span id="cb132-8"><a href="#cb132-8"></a><span class="op">}</span></span></code></pre></div>
 <p><em>-end example</em>]</p>
 </div>
 </blockquote>
diff --git a/2996_reflection/reflection.md b/2996_reflection/reflection.md
index 2ad7d0b1..0755c122 100644
--- a/2996_reflection/reflection.md
+++ b/2996_reflection/reflection.md
@@ -1054,6 +1054,52 @@ Thus `f` is a function reference to the correct specialization of `struct_to_tup
 
 [On Compiler Explorer](https://godbolt.org/z/Moqf84nc1), with a different implementation than either of the above.
 
+## Named Tuple
+
+The tricky thing with implementing a named tuple is actually strings as non-type template parameters.
+Because you cannot just pass `"x"` into a non-type template parameter of the form `auto V`, that leaves us with two ways of specifying the constituents:
+
+1. Can introduce a `pair` type so that we can write `make_named_tuple<pair<int, "x">, pair<double, "y">>()`, or
+2. Can just do reflections all the way down so that we can write `make_named_tuple<^int, ^"x", ^double, ^"y">()`.
+
+We do not currently support splicing string literals (although that may change in the next revision), and the `pair` approach follows the similar pattern already shown with `define_class` (given a suitable `fixed_string` type):
+
+::: bq
+```cpp
+template <class T, fixed_string Name>
+struct pair {
+    static constexpr auto name() -> std::string_view { return Name.view(); }
+    using type = T;
+};
+
+template <class... Tags>
+consteval auto make_named_tuple(std::meta::info type, Tags... tags) {
+    std::vector<std::meta::nsdm_description> nsdms;
+    auto f = [&]<class Tag>(Tag tag){
+        nsdms.push_back(std::meta::nsdm_description(
+            dealias(^Tag::type),
+            {.name=Tag::name()}));
+
+    };
+    (f(tags), ...);
+    return define_class(type, nsdms);
+}
+
+struct R;
+static_assert(is_type(make_named_tuple(^R, pair<int, "x">{}, pair<double, "y">())));
+
+static_assert(type_of(nonstatic_data_members_of(^R)[0]) == ^int);
+static_assert(type_of(nonstatic_data_members_of(^R)[1]) == ^double);
+
+int main() {
+    [[maybe_unused]] auto r = R{.x=1, .y=2.0};
+}
+```
+:::
+
+[On Compiler Explorer](https://godbolt.org/z/GKM4947fM).
+
+
 ## Compile-Time Ticket Counter
 
 The features proposed here make it a little easier to update a ticket counter at compile time.