<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml" lang xml:lang>
<head>
  <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-10-08" />
  <title>Reflection Syntax Options Summary</title>
  <style>
      code{white-space: pre-wrap;}
      span.smallcaps{font-variant: small-caps;}
      span.underline{text-decoration: underline;}
      div.column{display: inline-block; vertical-align: top; width: 50%;}
      div.csl-block{margin-left: 1.5em;}
      ul.task-list{list-style: none;}
      pre > code.sourceCode { white-space: pre; position: relative; }
      pre > code.sourceCode > span { display: inline-block; line-height: 1.25; }
      pre > code.sourceCode > span:empty { height: 1.2em; }
      .sourceCode { overflow: visible; }
      code.sourceCode > span { color: inherit; text-decoration: inherit; }
      div.sourceCode { margin: 1em 0; }
      pre.sourceCode { margin: 0; }
      @media screen {
      div.sourceCode { overflow: auto; }
      }
      @media print {
      pre > code.sourceCode { white-space: pre-wrap; }
      pre > code.sourceCode > span { text-indent: -5em; padding-left: 5em; }
      }
      pre.numberSource code
        { counter-reset: source-line 0; }
      pre.numberSource code > span
        { position: relative; left: -4em; counter-increment: source-line; }
      pre.numberSource code > span > a:first-child::before
        { content: counter(source-line);
          position: relative; left: -1em; text-align: right; vertical-align: baseline;
          border: none; display: inline-block;
          -webkit-touch-callout: none; -webkit-user-select: none;
          -khtml-user-select: none; -moz-user-select: none;
          -ms-user-select: none; user-select: none;
          padding: 0 4px; width: 4em;
          color: #aaaaaa;
        }
      pre.numberSource { margin-left: 3em; border-left: 1px solid #aaaaaa;  padding-left: 4px; }
      div.sourceCode
        {  background-color: #f6f8fa; }
      @media screen {
      pre > code.sourceCode > span > a:first-child::before { text-decoration: underline; }
      }
      code span { } /* Normal */
      code span.al { color: #ff0000; } /* Alert */
      code span.an { } /* Annotation */
      code span.at { } /* Attribute */
      code span.bn { color: #9f6807; } /* BaseN */
      code span.bu { color: #9f6807; } /* BuiltIn */
      code span.cf { color: #00607c; } /* ControlFlow */
      code span.ch { color: #9f6807; } /* Char */
      code span.cn { } /* Constant */
      code span.co { color: #008000; font-style: italic; } /* Comment */
      code span.cv { color: #008000; font-style: italic; } /* CommentVar */
      code span.do { color: #008000; } /* Documentation */
      code span.dt { color: #00607c; } /* DataType */
      code span.dv { color: #9f6807; } /* DecVal */
      code span.er { color: #ff0000; font-weight: bold; } /* Error */
      code span.ex { } /* Extension */
      code span.fl { color: #9f6807; } /* Float */
      code span.fu { } /* Function */
      code span.im { } /* Import */
      code span.in { color: #008000; } /* Information */
      code span.kw { color: #00607c; } /* Keyword */
      code span.op { color: #af1915; } /* Operator */
      code span.ot { } /* Other */
      code span.pp { color: #6f4e37; } /* Preprocessor */
      code span.re { } /* RegionMarker */
      code span.sc { color: #9f6807; } /* SpecialChar */
      code span.ss { color: #9f6807; } /* SpecialString */
      code span.st { color: #9f6807; } /* String */
      code span.va { } /* Variable */
      code span.vs { color: #9f6807; } /* VerbatimString */
      code span.wa { color: #008000; font-weight: bold; } /* Warning */
      code.diff {color: #898887}
      code.diff span.va {color: #006e28}
      code.diff span.st {color: #bf0303}
  </style>
  <style type="text/css">
body {
margin: 5em;
font-family: serif;

hyphens: auto;
line-height: 1.35;
text-align: justify;
}
@media screen and (max-width: 30em) {
body {
margin: 1.5em;
}
}
div.wrapper {
max-width: 60em;
margin: auto;
}
ul {
list-style-type: none;
padding-left: 2em;
margin-top: -0.2em;
margin-bottom: -0.2em;
}
a {
text-decoration: none;
color: #4183C4;
}
a.hidden_link {
text-decoration: none;
color: inherit;
}
li {
margin-top: 0.6em;
margin-bottom: 0.6em;
}
h1, h2, h3, h4 {
position: relative;
line-height: 1;
}
a.self-link {
position: absolute;
top: 0;
left: calc(-1 * (3.5rem - 26px));
width: calc(3.5rem - 26px);
height: 2em;
text-align: center;
border: none;
transition: opacity .2s;
opacity: .5;
font-family: sans-serif;
font-weight: normal;
font-size: 83%;
}
a.self-link:hover { opacity: 1; }
a.self-link::before { content: "§"; }
ul > li:before {
content: "\2014";
position: absolute;
margin-left: -1.5em;
}
:target { background-color: #C9FBC9; }
:target .codeblock { background-color: #C9FBC9; }
:target ul { background-color: #C9FBC9; }
.abbr_ref { float: right; }
.folded_abbr_ref { float: right; }
:target .folded_abbr_ref { display: none; }
:target .unfolded_abbr_ref { float: right; display: inherit; }
.unfolded_abbr_ref { display: none; }
.secnum { display: inline-block; min-width: 35pt; }
.header-section-number { display: inline-block; min-width: 35pt; }
.annexnum { display: block; }
div.sourceLinkParent {
float: right;
}
a.sourceLink {
position: absolute;
opacity: 0;
margin-left: 10pt;
}
a.sourceLink:hover {
opacity: 1;
}
a.itemDeclLink {
position: absolute;
font-size: 75%;
text-align: right;
width: 5em;
opacity: 0;
}
a.itemDeclLink:hover { opacity: 1; }
span.marginalizedparent {
position: relative;
left: -5em;
}
li span.marginalizedparent { left: -7em; }
li ul > li span.marginalizedparent { left: -9em; }
li ul > li ul > li span.marginalizedparent { left: -11em; }
li ul > li ul > li ul > li span.marginalizedparent { left: -13em; }
div.footnoteNumberParent {
position: relative;
left: -4.7em;
}
a.marginalized {
position: absolute;
font-size: 75%;
text-align: right;
width: 5em;
}
a.enumerated_item_num {
position: relative;
left: -3.5em;
display: inline-block;
margin-right: -3em;
text-align: right;
width: 3em;
}
div.para { margin-bottom: 0.6em; margin-top: 0.6em; text-align: justify; }
div.section { text-align: justify; }
div.sentence { display: inline; }
span.indexparent {
display: inline;
position: relative;
float: right;
right: -1em;
}
a.index {
position: absolute;
display: none;
}
a.index:before { content: "⟵"; }

a.index:target {
display: inline;
}
.indexitems {
margin-left: 2em;
text-indent: -2em;
}
div.itemdescr {
margin-left: 3em;
}
.bnf {
font-family: serif;
margin-left: 40pt;
margin-top: 0.5em;
margin-bottom: 0.5em;
}
.ncbnf {
font-family: serif;
margin-top: 0.5em;
margin-bottom: 0.5em;
margin-left: 40pt;
}
.ncsimplebnf {
font-family: serif;
font-style: italic;
margin-top: 0.5em;
margin-bottom: 0.5em;
margin-left: 40pt;
background: inherit; 
}
span.textnormal {
font-style: normal;
font-family: serif;
white-space: normal;
display: inline-block;
}
span.rlap {
display: inline-block;
width: 0px;
}
span.descr { font-style: normal; font-family: serif; }
span.grammarterm { font-style: italic; }
span.term { font-style: italic; }
span.terminal { font-family: monospace; font-style: normal; }
span.nonterminal { font-style: italic; }
span.tcode { font-family: monospace; font-style: normal; }
span.textbf { font-weight: bold; }
span.textsc { font-variant: small-caps; }
a.nontermdef { font-style: italic; font-family: serif; }
span.emph { font-style: italic; }
span.techterm { font-style: italic; }
span.mathit { font-style: italic; }
span.mathsf { font-family: sans-serif; }
span.mathrm { font-family: serif; font-style: normal; }
span.textrm { font-family: serif; }
span.textsl { font-style: italic; }
span.mathtt { font-family: monospace; font-style: normal; }
span.mbox { font-family: serif; font-style: normal; }
span.ungap { display: inline-block; width: 2pt; }
span.textit { font-style: italic; }
span.texttt { font-family: monospace; }
span.tcode_in_codeblock { font-family: monospace; font-style: normal; }
span.phantom { color: white; }

span.math { font-style: normal; }
span.mathblock {
display: block;
margin-left: auto;
margin-right: auto;
margin-top: 1.2em;
margin-bottom: 1.2em;
text-align: center;
}
span.mathalpha {
font-style: italic;
}
span.synopsis {
font-weight: bold;
margin-top: 0.5em;
display: block;
}
span.definition {
font-weight: bold;
display: block;
}
.codeblock {
margin-left: 1.2em;
line-height: 127%;
}
.outputblock {
margin-left: 1.2em;
line-height: 127%;
}
div.itemdecl {
margin-top: 2ex;
}
code.itemdeclcode {
white-space: pre;
display: block;
}
span.textsuperscript {
vertical-align: super;
font-size: smaller;
line-height: 0;
}
.footnotenum { vertical-align: super; font-size: smaller; line-height: 0; }
.footnote {
font-size: small;
margin-left: 2em;
margin-right: 2em;
margin-top: 0.6em;
margin-bottom: 0.6em;
}
div.minipage {
display: inline-block;
margin-right: 3em;
}
div.numberedTable {
text-align: center;
margin: 2em;
}
div.figure {
text-align: center;
margin: 2em;
}
table {
border: 1px solid black;
border-collapse: collapse;
margin-left: auto;
margin-right: auto;
margin-top: 0.8em;
text-align: left;
hyphens: none; 
}
td, th {
padding-left: 1em;
padding-right: 1em;
vertical-align: top;
}
td.empty {
padding: 0px;
padding-left: 1px;
}
td.left {
text-align: left;
}
td.right {
text-align: right;
}
td.center {
text-align: center;
}
td.justify {
text-align: justify;
}
td.border {
border-left: 1px solid black;
}
tr.rowsep, td.cline {
border-top: 1px solid black;
}
tr.even, tr.odd {
border-bottom: 1px solid black;
}
tr.capsep {
border-top: 3px solid black;
border-top-style: double;
}
tr.header {
border-bottom: 3px solid black;
border-bottom-style: double;
}
th {
border-bottom: 1px solid black;
}
span.centry {
font-weight: bold;
}
div.table {
display: block;
margin-left: auto;
margin-right: auto;
text-align: center;
width: 90%;
}
span.indented {
display: block;
margin-left: 2em;
margin-bottom: 1em;
margin-top: 1em;
}
ol.enumeratea { list-style-type: none; background: inherit; }
ol.enumerate { list-style-type: none; background: inherit; }

code.sourceCode > span { display: inline; }
</style>
  <link href="data:image/x-icon;base64,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" rel="icon" />
  
  <!--[if lt IE 9]>
    <script src="//cdnjs.cloudflare.com/ajax/libs/html5shiv/3.7.3/html5shiv-printshiv.min.js"></script>
  <![endif]-->
</head>
<body>
<div class="wrapper">
<header id="title-block-header">
<h1 class="title" style="text-align:center">Reflection Syntax Options
Summary</h1>
<table style="border:none;float:right">
  <tr>
    <td>Document #:</td>
    <td>P3419</td>
  </tr>
  <tr>
    <td>Date:</td>
    <td>2024-10-08</td>
  </tr>
  <tr>
    <td style="vertical-align:top">Project:</td>
    <td>Programming Language C++</td>
  </tr>
  <tr>
    <td style="vertical-align:top">Audience:</td>
    <td>
      EWG<br>
    </td>
  </tr>
  <tr>
    <td style="vertical-align:top">Reply-to:</td>
    <td>
      Michael Levine<br>&lt;<a href="mailto:mlevine55@bloomberg.net" class="email">mlevine55@bloomberg.net</a>&gt;<br>
    </td>
  </tr>
</table>
</header>
<div style="clear:both">
<div id="TOC" role="doc-toc">
<h1 id="toctitle">Contents</h1>
<ul>
<li><a href="#goals" id="toc-goals"><span class="toc-section-number">1</span> Goals<span></span></a></li>
<li><a href="#some-potential-operator-pairs" id="toc-some-potential-operator-pairs"><span class="toc-section-number">2</span> Some Potential Operator
Pairs<span></span></a></li>
<li><a href="#get-meta-operator-options" id="toc-get-meta-operator-options"><span class="toc-section-number">3</span> Get Meta Operator
Options<span></span></a>
<ul>
<li><a href="#summary" id="toc-summary"><span class="toc-section-number">3.1</span> Summary<span></span></a></li>
<li><a href="#advantages-and-disadvantages" id="toc-advantages-and-disadvantages"><span class="toc-section-number">3.2</span> Advantages and
Disadvantages<span></span></a></li>
</ul></li>
<li><a href="#splicing-in-meta-operator-options" id="toc-splicing-in-meta-operator-options"><span class="toc-section-number">4</span> Splicing in Meta Operator
Options<span></span></a>
<ul>
<li><a href="#summary-1" id="toc-summary-1"><span class="toc-section-number">4.1</span> Summary<span></span></a></li>
<li><a href="#advantages-and-disadvantages-1" id="toc-advantages-and-disadvantages-1"><span class="toc-section-number">4.2</span> Advantages and
Disadvantages<span></span></a></li>
</ul></li>
<li><a href="#get-meta-contextual-and-function-keywords" id="toc-get-meta-contextual-and-function-keywords"><span class="toc-section-number">5</span> Get Meta Contextual and Function
Keywords<span></span></a>
<ul>
<li><a href="#summary-2" id="toc-summary-2"><span class="toc-section-number">5.1</span> Summary<span></span></a></li>
<li><a href="#advantages-and-disadvantages-2" id="toc-advantages-and-disadvantages-2"><span class="toc-section-number">5.2</span> Advantages and
Disadvantages<span></span></a></li>
</ul></li>
<li><a href="#splice-in-meta-contextual-and-function-keywords" id="toc-splice-in-meta-contextual-and-function-keywords"><span class="toc-section-number">6</span> Splice in Meta Contextual and
Function Keywords<span></span></a>
<ul>
<li><a href="#summary-3" id="toc-summary-3"><span class="toc-section-number">6.1</span> Summary<span></span></a></li>
<li><a href="#advantages-and-disadvantages-3" id="toc-advantages-and-disadvantages-3"><span class="toc-section-number">6.2</span> Advantages and
Disadvantages<span></span></a></li>
</ul></li>
<li><a href="#general-syntax-types" id="toc-general-syntax-types"><span class="toc-section-number">7</span> General Syntax
Types<span></span></a>
<ul>
<li><a href="#summary-4" id="toc-summary-4"><span class="toc-section-number">7.1</span> Summary<span></span></a></li>
<li><a href="#advantages-and-disadvantages-4" id="toc-advantages-and-disadvantages-4"><span class="toc-section-number">7.2</span> Advantages and
Disadvantages<span></span></a></li>
</ul></li>
<li><a href="#acknowledgements" id="toc-acknowledgements"><span class="toc-section-number">8</span>
Acknowledgements<span></span></a></li>
<li><a href="#bibliography" id="toc-bibliography"><span class="toc-section-number">9</span> References<span></span></a></li>
</ul>
</div>
<h1 data-number="1" id="goals"><span class="header-section-number">1</span> Goals<a href="#goals" class="self-link"></a></h1>
<p>This paper presents a summary of reflection syntax options. Some of
these options are activately under consideration, while others have
already been discussed and dismissed. However, the reasons for their
dismissal have not necessary been recorded in a central location
showcasing their perceived advantages or disadvantages relative to other
options. This paper intends to be a reference for such discussions. A
specific non-goal of the paper is the promotion of a particular
syntax.</p>
<h1 data-number="2" id="some-potential-operator-pairs"><span class="header-section-number">2</span> Some Potential Operator Pairs<a href="#some-potential-operator-pairs" class="self-link"></a></h1>
<table style="width:46%;">
<colgroup>
<col style="width: 6%" />
<col style="width: 15%" />
<col style="width: 23%" />
</colgroup>
<thead>
<tr class="header">
<th><div style="text-align:center">
<strong>#</strong>
</div></th>
<th><div style="text-align:center">
<strong>Get Meta</strong>
</div></th>
<th><div style="text-align:center">
<strong>Splice in Meta</strong>
</div></th>
</tr>
</thead>
<tbody>
<tr class="odd">
<td>1</td>
<td><code class="sourceCode cpp"><span class="op">@&lt;</span>foo</code></td>
<td><code class="sourceCode cpp"><span class="op">@&gt;</span>foo</code></td>
</tr>
<tr class="even">
<td>2</td>
<td><code class="sourceCode cpp"><span class="op">^^</span>foo</code></td>
<td><code class="sourceCode cpp"><span class="op">[:</span> foo <span class="op">:]</span></code></td>
</tr>
<tr class="odd">
<td>3</td>
<td><code class="sourceCode cpp"><span class="op">^^</span>foo</code></td>
<td><code class="sourceCode cpp">,,foo</code></td>
</tr>
<tr class="even">
<td>4</td>
<td><code class="sourceCode cpp"><span class="op">&lt;-</span>foo</code></td>
<td><code class="sourceCode cpp"><span class="op">-&gt;</span>foo</code></td>
</tr>
<tr class="odd">
<td>5</td>
<td><code class="sourceCode cpp"><span class="er">$$</span>foo</code></td>
<td><code class="sourceCode cpp"><span class="er">$</span>foo</code></td>
</tr>
<tr class="even">
<td>6</td>
<td>`foo</td>
<td><code class="sourceCode cpp">,foo</code></td>
</tr>
<tr class="odd">
<td>7</td>
<td><code class="sourceCode cpp"><span class="op">^</span>foo</code></td>
<td><code class="sourceCode cpp"><span class="op">[:</span> foo <span class="op">:]</span></code></td>
</tr>
<tr class="even">
<td>8</td>
<td><code class="sourceCode cpp"><span class="op">@&lt;&lt;</span>foo</code></td>
<td><code class="sourceCode cpp"><span class="op">&gt;&gt;@</span>foo</code></td>
</tr>
<tr class="odd">
<td>9</td>
<td><code class="sourceCode cpp"><span class="op">@&lt;-</span>foo</code></td>
<td><code class="sourceCode cpp"><span class="op">-&gt;@</span>foo</code></td>
</tr>
<tr class="even">
<td>10</td>
<td><code class="sourceCode cpp"><span class="op">&lt;@</span>foo</code></td>
<td><code class="sourceCode cpp"><span class="op">@&gt;</span>foo</code></td>
</tr>
<tr class="odd">
<td>11</td>
<td><code class="sourceCode cpp"><span class="op">&lt;@</span>foo</code></td>
<td><code class="sourceCode cpp"><span class="op">&gt;@</span>foo</code></td>
</tr>
<tr class="even">
<td>12</td>
<td><code class="sourceCode cpp"><span class="op">&amp;&amp;</span>foo</code></td>
<td><code class="sourceCode cpp"><span class="op">&amp;&amp;&gt;</span>foo</code></td>
</tr>
<tr class="odd">
<td>13</td>
<td><code class="sourceCode cpp"><span class="op">:</span>foo</code></td>
<td><code class="sourceCode cpp"><span class="er">$</span>foo</code></td>
</tr>
<tr class="even">
<td>14</td>
<td><code class="sourceCode cpp"><span class="op">/</span>foo</code></td>
<td><code class="sourceCode cpp">\foo</code></td>
</tr>
<tr class="odd">
<td>15</td>
<td><code class="sourceCode cpp"><span class="op">^^</span>foo</code></td>
<td><code class="sourceCode cpp"><span class="er">$$</span>foo</code></td>
</tr>
<tr class="even">
<td>16</td>
<td>``foo</td>
<td><code class="sourceCode cpp">,,foo</code></td>
</tr>
<tr class="odd">
<td>17</td>
<td><code class="sourceCode cpp"><span class="op">@&lt;&lt;</span>foo</code></td>
<td><code class="sourceCode cpp"><span class="op">@&gt;&gt;</span>foo</code></td>
</tr>
<tr class="even">
<td>18</td>
<td><code class="sourceCode cpp"><span class="op">@&lt;-</span>foo</code></td>
<td><code class="sourceCode cpp"><span class="op">@-&gt;</span>foo</code></td>
</tr>
</tbody>
</table>
<h1 data-number="3" id="get-meta-operator-options"><span class="header-section-number">3</span> Get Meta Operator Options<a href="#get-meta-operator-options" class="self-link"></a></h1>
<h2 data-number="3.1" id="summary"><span class="header-section-number">3.1</span> Summary<a href="#summary" class="self-link"></a></h2>
<table style="width:22%;">
<colgroup>
<col style="width: 6%" />
<col style="width: 15%" />
</colgroup>
<thead>
<tr class="header">
<th><div style="text-align:center">
<strong>#</strong>
</div></th>
<th><div style="text-align:center">
<strong>Syntax</strong>
</div></th>
</tr>
</thead>
<tbody>
<tr class="odd">
<td>1</td>
<td><code class="sourceCode cpp"><span class="op">^^</span>foo</code></td>
</tr>
<tr class="even">
<td>2</td>
<td><code class="sourceCode cpp"><span class="op">^</span>foo</code></td>
</tr>
<tr class="odd">
<td>3</td>
<td><code class="sourceCode cpp"><span class="op">@&lt;</span>foo</code></td>
</tr>
<tr class="even">
<td>4</td>
<td><code class="sourceCode cpp"><span class="op">@&lt;&lt;</span>foo</code></td>
</tr>
<tr class="odd">
<td>5</td>
<td><code class="sourceCode cpp"><span class="op">@&lt;-</span>foo</code></td>
</tr>
<tr class="even">
<td>6</td>
<td><code class="sourceCode cpp"><span class="op">&lt;@</span>foo</code></td>
</tr>
<tr class="odd">
<td>7</td>
<td><code class="sourceCode cpp"><span class="op">|</span>foo</code></td>
</tr>
<tr class="even">
<td>8</td>
<td><code class="sourceCode cpp"><span class="op">/</span>foo</code></td>
</tr>
<tr class="odd">
<td>9</td>
<td><code class="sourceCode cpp"><span class="op">%</span>foo</code></td>
</tr>
<tr class="even">
<td>10</td>
<td>`foo</td>
</tr>
<tr class="odd">
<td>11</td>
<td><code class="sourceCode cpp"><span class="op">:</span>foo</code></td>
</tr>
<tr class="even">
<td>12</td>
<td><code class="sourceCode cpp"><span class="op">~~</span>foo</code></td>
</tr>
<tr class="odd">
<td>13</td>
<td><code class="sourceCode cpp"><span class="op">^-</span>foo</code></td>
</tr>
<tr class="even">
<td>14</td>
<td><code class="sourceCode cpp"><span class="op">&lt;-</span>foo</code></td>
</tr>
<tr class="odd">
<td>15</td>
<td><code class="sourceCode cpp"><span class="op">-&lt;</span>foo</code></td>
</tr>
<tr class="even">
<td>16</td>
<td><code class="sourceCode cpp"><span class="op">^%</span>foo</code></td>
</tr>
<tr class="odd">
<td>17</td>
<td><code class="sourceCode cpp"><span class="er">$$</span>foo</code></td>
</tr>
<tr class="even">
<td>18</td>
<td><code class="sourceCode cpp"><span class="op">&amp;&amp;</span>foo</code></td>
</tr>
<tr class="odd">
<td>19</td>
<td><code class="sourceCode cpp"><span class="op">@</span>foo</code></td>
</tr>
<tr class="even">
<td>20</td>
<td><code class="sourceCode cpp"><span class="pp">#</span><span class="er">foo</span></code></td>
</tr>
<tr class="odd">
<td>21</td>
<td><code class="sourceCode cpp"><span class="er">$</span>foo</code></td>
</tr>
<tr class="even">
<td>22</td>
<td><code class="sourceCode cpp"><span class="ch">&#39;f</span><span class="er">oo</span></code></td>
</tr>
<tr class="odd">
<td>23</td>
<td><code class="sourceCode cpp"><span class="op">=</span>foo</code></td>
</tr>
<tr class="even">
<td>24</td>
<td><code class="sourceCode cpp"><span class="op">?</span>foo</code></td>
</tr>
<tr class="odd">
<td>25</td>
<td><code class="sourceCode cpp">\foo</code></td>
</tr>
<tr class="even">
<td>26</td>
<td><code class="sourceCode cpp"><span class="op">^[</span>foo<span class="op">]</span></code></td>
</tr>
<tr class="odd">
<td>27</td>
<td><code class="sourceCode cpp"><span class="er">$</span><span class="op">{</span>foo<span class="op">}</span></code></td>
</tr>
<tr class="even">
<td>28</td>
<td><code class="sourceCode cpp"><span class="er">$</span><span class="op">(</span>foo<span class="op">)</span></code></td>
</tr>
<tr class="odd">
<td>29</td>
<td><code class="sourceCode cpp"><span class="op">/</span>\foo</code></td>
</tr>
<tr class="even">
<td>30</td>
<td>``foo</td>
</tr>
</tbody>
</table>
<h2 data-number="3.2" id="advantages-and-disadvantages"><span class="header-section-number">3.2</span> Advantages and Disadvantages<a href="#advantages-and-disadvantages" class="self-link"></a></h2>
<p><strong># 1:
<code class="sourceCode cpp"><span class="op">^^</span>foo</code></strong></p>
<ul>
<li>Advantages
<ol type="1">
<li>There is no ambiguity with blocks <span class="citation" data-cites="p3381r0">[<a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3381r0.html" role="doc-biblioref">P3381R0</a>]</span>.</li>
<li>This is the syntax recommended by <span class="citation" data-cites="p3381r0">[<a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3381r0.html" role="doc-biblioref">P3381R0</a>]</span>.</li>
</ol></li>
<li>Disadvantages
<ol type="1">
<li>It is longer than the status quo <span class="citation" data-cites="p3381r0">[<a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3381r0.html" role="doc-biblioref">P3381R0</a>]</span>.</li>
<li>It could potentially be used for logical xor.</li>
<li>Its use as a binary operator has a syntactic ambiguity with Clang’s
blocks extension and will probably not be able to be used for <code class="sourceCode cpp">exclusive<span class="op">-</span><span class="kw">or</span></code>.
An example is <code class="sourceCode cpp">expr <span class="op">^^</span> <span class="op">{</span> <span class="cf">return</span> <span class="dv">1</span>; <span class="op">}()</span></code>.</li>
</ol></li>
</ul>
<p><strong># 2:
<code class="sourceCode cpp"><span class="op">^</span>foo</code></strong></p>
<ul>
<li>Advantages
<ol type="1">
<li>The upward arrow style notation indicates something is being pulled
from <code class="sourceCode cpp">foo</code>.</li>
<li>It is a relatively rarely used binary operator <span class="citation" data-cites="p3381r0">[<a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3381r0.html" role="doc-biblioref">P3381R0</a>]</span>.</li>
</ol></li>
<li>Disadvantages
<ol type="1">
<li>Clang has an old extension called “blocks” that uses
<code class="sourceCode cpp"><span class="op">^</span></code> to both
introduce a block and as part of the syntax for “block types” <span class="citation" data-cites="p3381r0">[<a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3381r0.html" role="doc-biblioref">P3381R0</a>]</span>. With this extension, some
parses may not be able to be disambiguated. <code class="sourceCode cpp">type<span class="op">-</span>id<span class="op">(^</span>ident<span class="op">)()</span></code>
is ambiguous, and <code class="sourceCode cpp"><span class="kw">auto</span> A <span class="op">=</span> <span class="op">^{</span> f<span class="op">()</span>; <span class="op">}</span>;</code>
with <span class="citation" data-cites="p3294r1">[<a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3294r1.html" role="doc-biblioref">P3294R1</a>]</span> is ambiguous <span class="citation" data-cites="p3381r0">[<a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3381r0.html" role="doc-biblioref">P3381R0</a>]</span>.</li>
<li>It is an operator being used in C++ for non-operator syntax.</li>
<li>It is too similar to
<code class="sourceCode cpp">foo<span class="op">^</span></code>, which
is used as a type in other languages built on top of C++ such as
ObjectiveC++ <span class="citation" data-cites="p3381r0">[<a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3381r0.html" role="doc-biblioref">P3381R0</a>]</span> and the Microsoft .NET
extensions.</li>
</ol></li>
</ul>
<p><strong># 3:
<code class="sourceCode cpp"><span class="op">@&lt;</span>foo</code></strong></p>
<ul>
<li>Advantages
<ol type="1">
<li>It is similar to Go’s channel syntax <span class="citation" data-cites="goChannels">[<a href="https://gobyexample.com/channel-directions" role="doc-biblioref">GoChannels</a>]</span>.</li>
<li>It shouldn’t have a nesting issue as the character order solves
it.</li>
</ol></li>
<li>Disadvantages
<ol type="1">
<li>There is potential concern about readability with the angle brackets
in a template argument context, an example of which would be <code class="sourceCode cpp">fn<span class="op">&lt;@&lt;</span>foo<span class="op">&gt;</span></code>.</li>
</ol></li>
</ul>
<p><strong># 4:
<code class="sourceCode cpp"><span class="op">@&lt;&lt;</span>foo</code></strong></p>
<ul>
<li>Advantages
<ol type="1">
<li>It makes the direction louder and easier to read than using
<code class="sourceCode cpp"><span class="op">@&lt;</span>foo</code>.</li>
</ol></li>
</ul>
<p><strong># 5:
<code class="sourceCode cpp"><span class="op">@&lt;-</span>foo</code></strong></p>
<ul>
<li>Advantages
<ol type="1">
<li>It further emphasizes the direction of the data flow.</li>
</ol></li>
<li>Disadvantages
<ol type="1">
<li>It might need parentheses for the
<code class="sourceCode cpp"><span class="op">-</span></code> sign.</li>
</ol></li>
</ul>
<p><strong># 7:
<code class="sourceCode cpp"><span class="op">|</span>foo</code></strong></p>
<ul>
<li>Advantages
<ol type="1">
<li>It is not part of a digraph <span class="citation" data-cites="p3381r0">[<a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3381r0.html" role="doc-biblioref">P3381R0</a>]</span>.</li>
<li>This is not ambiguous to compilers <span class="citation" data-cites="p3381r0">[<a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3381r0.html" role="doc-biblioref">P3381R0</a>]</span>.</li>
</ol></li>
<li>Disadvantages
<ol type="1">
<li>It looks like half of an absolute value notation and could be
confused as part of a magnitude notation when using multiple reflections
in a single line as in <code class="sourceCode cpp"><span class="cf">if</span> <span class="op">(|</span>T <span class="op">==</span> <span class="op">|</span>U<span class="op">)</span></code>
<span class="citation" data-cites="p3381r0">[<a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3381r0.html" role="doc-biblioref">P3381R0</a>]</span>.</li>
</ol></li>
</ul>
<p><strong># 8:
<code class="sourceCode cpp"><span class="op">/</span>foo</code></strong></p>
<ul>
<li>Advantages
<ol type="1">
<li>It can offer nice symmetry with using
<code class="sourceCode cpp">\</code> for code injection <span class="citation" data-cites="p3381r0">[<a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3381r0.html" role="doc-biblioref">P3381R0</a>]</span>.</li>
</ol></li>
<li>Disadvantages
<ol type="1">
<li>It is very close to comment syntax and could require parentheses for
<code class="sourceCode cpp"><span class="op">/(/</span>e<span class="op">)</span></code>
and <code class="sourceCode cpp"><span class="op">/(*</span>e<span class="op">)</span></code>
<span class="citation" data-cites="p3381r0">[<a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3381r0.html" role="doc-biblioref">P3381R0</a>]</span>.</li>
</ol></li>
</ul>
<p><strong># 9:
<code class="sourceCode cpp"><span class="op">%</span>foo</code></strong></p>
<ul>
<li>Advantages
<ol type="1">
<li>It is a relatively rarely used binary operator <span class="citation" data-cites="p3381r0">[<a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3381r0.html" role="doc-biblioref">P3381R0</a>]</span>.</li>
</ol></li>
<li>Disadvantages
<ol type="1">
<li>When passed as a first template argument as in <code class="sourceCode cpp">C<span class="op">&lt;%</span>T<span class="op">&gt;</span> c;</code>,
<code class="sourceCode cpp"><span class="op">&lt;%</span></code> is a
digraph for
<code class="sourceCode cpp"><span class="op">{</span></code>. This
would require spaces or parentheses to get around this issue <span class="citation" data-cites="p3381r0">[<a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3381r0.html" role="doc-biblioref">P3381R0</a>]</span>.</li>
</ol></li>
</ul>
<p><strong># 10: `foo</strong></p>
<ul>
<li>Advantages
<ol type="1">
<li>This is a very lispy syntax. In Common Lisp it is used to disable
evaluation for a subexpression <span class="citation" data-cites="clSpec">[<a href="https://www.lispworks.com/documentation/HyperSpec/Body/02_df.htm" role="doc-biblioref">CLSpec</a>]</span>.</li>
<li>It was recently added to the basic character set <span class="citation" data-cites="p3381r0">[<a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3381r0.html" role="doc-biblioref">P3381R0</a>]</span>.</li>
<li>It is a small character, even smaller than
<code class="sourceCode cpp"><span class="op">^</span></code> <span class="citation" data-cites="p3381r0">[<a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3381r0.html" role="doc-biblioref">P3381R0</a>]</span>.</li>
</ol></li>
<li>Disadvantages
<ol type="1">
<li>Markdown uses it extensively, and not all Markdown implementations
give you ways to escape it <span class="citation" data-cites="p3381r0">[<a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3381r0.html" role="doc-biblioref">P3381R0</a>]</span>.</li>
</ol></li>
</ul>
<p><strong># 11:
<code class="sourceCode cpp"><span class="op">:</span>foo</code></strong></p>
<ul>
<li>Advantages
<ol type="1">
<li>It is used by the Julia programming language for metaprogramming to
construct inline expressions such as <code class="sourceCode cpp">ex2 <span class="op">=</span> Expr<span class="op">(:</span>call, <span class="op">:+</span>, <span class="dv">1</span> , <span class="dv">1</span><span class="op">)</span></code>
to produce a Julia Expr type such as <code class="sourceCode cpp"><span class="op">:(</span><span class="dv">1</span> <span class="op">+</span> <span class="dv">1</span><span class="op">)</span></code>
<span class="citation" data-cites="juliaMeta">[<a href="https://docs.julialang.org/en/v1/manual/metaprogramming/" role="doc-biblioref">JuliaMeta</a>]</span>.</li>
</ol></li>
<li>Disadvantages
<ol type="1">
<li>Passing it as a template argument as in <code class="sourceCode cpp">C<span class="op">&lt;:</span>T<span class="op">&gt;</span></code>
would not work because
<code class="sourceCode cpp"><span class="op">&lt;:</span></code> is a
digraph for
<code class="sourceCode cpp"><span class="op">[</span></code> <span class="citation" data-cites="p3381r0">[<a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3381r0.html" role="doc-biblioref">P3381R0</a>]</span>. This can potentially be
remedied by being called as <code class="sourceCode cpp">C<span class="op">&lt;(:</span>T<span class="op">)&gt;</span></code>,
but this could leads to errors that are difficult to debug.</li>
<li>It composes poorly with the splicing operator <code class="sourceCode cpp"><span class="op">[::</span>foo<span class="op">:]</span></code>.</li>
<li>It may be ambiguous when parsing an array-index whose operand is a
qualified-id or when parsing a reflect-expression composed inside a
splice-specifier.</li>
</ol></li>
</ul>
<p><strong># 12:
<code class="sourceCode cpp"><span class="op">~~</span>foo</code></strong></p>
<ul>
<li>Disadvantages
<ol type="1">
<li>It is ambiguous. If <code class="sourceCode cpp">foo</code> is an
integral expression, then
<code class="sourceCode cpp"><span class="op">~~</span>foo</code> means
to flip all of the bits and then flip them again.</li>
<li>It may require parentheses to parse the intended, single
<code class="sourceCode cpp"><span class="op">~</span></code>
symbol.</li>
<li><code class="sourceCode cpp"><span class="op">~</span></code> is
already a unary operator.</li>
</ol></li>
</ul>
<p><strong># 13:
<code class="sourceCode cpp"><span class="op">^-</span>foo</code></strong></p>
<ul>
<li>Disadvantages
<ol type="1">
<li>It may require parentheses to parse the
<code class="sourceCode cpp"><span class="op">-</span></code>
symbol.</li>
</ol></li>
</ul>
<p><strong># 14:
<code class="sourceCode cpp"><span class="op">&lt;-</span>foo</code></strong></p>
<ul>
<li>Advantages
<ol type="1">
<li>It is similar to Go’s channel syntax <span class="citation" data-cites="goChannels">[<a href="https://gobyexample.com/channel-directions" role="doc-biblioref">GoChannels</a>]</span>.</li>
</ol></li>
<li>Disadvantages
<ol type="1">
<li>It could be hard to disambiguate
<code class="sourceCode cpp"><span class="op">&lt;&lt;-</span></code>
from <code class="sourceCode cpp"><span class="op">&lt;</span> <span class="op">&lt;-</span></code>
when used as a template argument as in <code class="sourceCode cpp">fn<span class="op">&lt;&lt;-</span>foo<span class="op">&gt;</span></code>.</li>
<li>It may require parentheses to parse the
<code class="sourceCode cpp"><span class="op">-</span></code>
symbol.</li>
</ol></li>
</ul>
<p><strong># 18: <code class="sourceCode cpp"><span class="op">&amp;&amp;</span>foo</code></strong></p>
<ul>
<li>Disadvantages
<ol type="1">
<li>It can lead to code like this: <code class="sourceCode cpp"><span class="cf">if</span> <span class="op">(&amp;&amp;</span>foo<span class="op">&amp;&amp;</span> <span class="op">==</span> <span class="op">&amp;&amp;</span>foo<span class="op">&amp;&amp;</span> <span class="op">&amp;&amp;</span> <span class="op">&amp;&amp;</span>foo<span class="op">&amp;&amp;</span> <span class="op">==</span> <span class="op">&amp;&amp;</span>foo<span class="op">&amp;&amp;)</span></code>
where <code class="sourceCode cpp"><span class="op">&amp;&amp;</span>foo<span class="op">&amp;&amp;</span></code>
is a reflection on a <code class="sourceCode cpp">foo</code> reflection
type. This is comparing two reflections for equality.</li>
<li>It can be an issue with reflecting on an rvalue reference as in
<code class="sourceCode cpp"><span class="op">(&amp;&amp;</span>foo<span class="op">&amp;&amp;)</span></code>.</li>
<li>The
<code class="sourceCode cpp"><span class="op">&amp;&amp;</span></code>
is already used for logical <code class="sourceCode cpp">AND</code> and
rvalue/forward references.</li>
</ol></li>
</ul>
<p><strong># 19:
<code class="sourceCode cpp"><span class="op">@</span>foo</code></strong></p>
<ul>
<li>Disadvantages
<ol type="1">
<li>It was potentially going to be used as a splat for simple
splices.</li>
<li>Compilers already allow the use of
<code class="sourceCode cpp"><span class="op">@</span></code> in
identifiers as an extension, so we wouldn’t be able to disambiguate
between reflecting on an identifier and actually being an identifier
<span class="citation" data-cites="p3381r0">[<a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3381r0.html" role="doc-biblioref">P3381R0</a>]</span>.</li>
<li>It is used as an extension in Objective-C. As such, a number of
potential identifiers have meaning already
(<code class="sourceCode cpp"><span class="op">@</span>property</code>,
<code class="sourceCode cpp"><span class="op">@</span>dynamic</code>,
<code class="sourceCode cpp"><span class="op">@</span>optional</code>,
etc). This also cannot be escaped since <code class="sourceCode cpp"><span class="op">@(</span>foo<span class="op">)</span></code>
is a boxed expression and <code class="sourceCode cpp"><span class="op">@[</span>foo<span class="op">]</span></code>
and <code class="sourceCode cpp"><span class="op">@{</span>foo<span class="op">}</span></code>
are container literals <span class="citation" data-cites="p3381r0">[<a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3381r0.html" role="doc-biblioref">P3381R0</a>]</span>.</li>
</ol></li>
</ul>
<p><strong># 20: <code class="sourceCode cpp"><span class="pp">#</span><span class="er">foo</span></code></strong></p>
<ul>
<li>Disadvantages
<ol type="1">
<li>It precludes usage in existing C macros, given that <code class="sourceCode cpp"><span class="pp">#define MACRO</span><span class="op">(</span>x<span class="op">)</span><span class="pp"> </span>do_something_with<span class="op">(</span><span class="pp">#</span>x<span class="op">)</span></code>
already has meaning <span class="citation" data-cites="p3381r0">[<a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3381r0.html" role="doc-biblioref">P3381R0</a>]</span>.</li>
</ol></li>
</ul>
<p><strong># 21:
<code class="sourceCode cpp"><span class="er">$</span>foo</code></strong></p>
<ul>
<li>Advantages
<ol type="1">
<li>It doesn’t conflict with anything else in C++ since it was recently
added to the basic character set <span class="citation" data-cites="p3381r0">[<a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3381r0.html" role="doc-biblioref">P3381R0</a>]</span>.</li>
</ol></li>
<li>Disadvantages
<ol type="1">
<li>Compilers support its use in identifiers as an extension <span class="citation" data-cites="p3381r0">[<a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3381r0.html" role="doc-biblioref">P3381R0</a>]</span>.</li>
<li>It is typically used as a splicing syntax in other languages, not as
the get meta syntax.</li>
</ol></li>
</ul>
<p><strong># 23:
<code class="sourceCode cpp"><span class="op">=</span>foo</code></strong></p>
<ul>
<li>Advantages
<ol type="1">
<li>It is already used as a binary operator <span class="citation" data-cites="p3381r0">[<a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3381r0.html" role="doc-biblioref">P3381R0</a>]</span>.</li>
</ol></li>
<li>Disadvantages
<ol type="1">
<li>It is too commonly used as a binary operator to now overload it for
reflection usage <span class="citation" data-cites="p3381r0">[<a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3381r0.html" role="doc-biblioref">P3381R0</a>]</span>.</li>
</ol></li>
</ul>
<p><strong># 24:
<code class="sourceCode cpp"><span class="op">?</span>foo</code></strong></p>
<ul>
<li>Advantages
<ol type="1">
<li>It already exists within the language today <span class="citation" data-cites="p3381r0">[<a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3381r0.html" role="doc-biblioref">P3381R0</a>]</span>.</li>
<li>It would not be ambiguous with the conditional operator <span class="citation" data-cites="p3381r0">[<a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3381r0.html" role="doc-biblioref">P3381R0</a>]</span>.</li>
<li>The syntax naturally implies asking what an entity is, and the
answer is its reflection <span class="citation" data-cites="p3381r0">[<a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3381r0.html" role="doc-biblioref">P3381R0</a>]</span>.</li>
</ol></li>
<li>Disadvantages
<ol type="1">
<li>It is associated with predicates in different programming languages
for null coalescing, optional chaining, and error propagation (<code class="sourceCode cpp">v<span class="op">.</span>empty<span class="op">?</span></code>)
<span class="citation" data-cites="p3381r0">[<a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3381r0.html" role="doc-biblioref">P3381R0</a>]</span>.</li>
<li><span class="citation" data-cites="p2688r1">[<a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p2688r1.pdf" role="doc-biblioref">P2688R1</a>]</span> proposes using it for pattern
matching <span class="citation" data-cites="p3381r0">[<a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3381r0.html" role="doc-biblioref">P3381R0</a>]</span>.</li>
</ol></li>
</ul>
<p><strong># 25: <code class="sourceCode cpp">\foo</code></strong></p>
<ul>
<li>Advantages
<ol type="1">
<li>It is an available operator.</li>
</ol></li>
<li>Disadvantages
<ol type="1">
<li>There is an issue with UCNs. <code class="sourceCode cpp">\u0</code>
is parsed as a UCN instead of a reflection of
<code class="sourceCode cpp">u0</code> <span class="citation" data-cites="p3381r0">[<a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3381r0.html" role="doc-biblioref">P3381R0</a>]</span>.</li>
<li>Some prefer it as an interpolator, for which there is prior art
<span class="citation" data-cites="p3381r0">[<a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3381r0.html" role="doc-biblioref">P3381R0</a>]</span>.</li>
</ol></li>
</ul>
<p><strong># 26: <code class="sourceCode cpp"><span class="op">^[</span>foo<span class="op">]</span></code></strong></p>
<ul>
<li>Advantages
<ol type="1">
<li>It doesn’t have an issue with block ambiguity, as opposed to
<code class="sourceCode cpp"><span class="op">^</span>foo</code> <span class="citation" data-cites="p3381r0">[<a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3381r0.html" role="doc-biblioref">P3381R0</a>]</span>.</li>
<li>It can be more symmetric with splicing if splicing uses similar
syntax like <code class="sourceCode cpp"><span class="op">[:</span> foo <span class="op">:]</span></code>
<span class="citation" data-cites="p3381r0">[<a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3381r0.html" role="doc-biblioref">P3381R0</a>]</span>.</li>
</ol></li>
<li>Disadvantages
<ol type="1">
<li>It is a heavier syntax <span class="citation" data-cites="p3381r0">[<a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3381r0.html" role="doc-biblioref">P3381R0</a>]</span>.</li>
</ol></li>
</ul>
<p><strong># 27: <code class="sourceCode cpp"><span class="er">$</span><span class="op">{</span>foo<span class="op">}</span></code></strong></p>
<ul>
<li>Advantages
<ol type="1">
<li>It does not conflict with compiler support for using
<code class="sourceCode cpp"><span class="er">$</span></code> in
identifiers as an extension <span class="citation" data-cites="p3381r0">[<a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3381r0.html" role="doc-biblioref">P3381R0</a>]</span>.</li>
</ol></li>
<li>Disadvantages
<ol type="1">
<li>The <code class="sourceCode cpp"><span class="er">$</span></code>
symbol is typically used as a splicing syntax in other languages, not as
the get meta syntax.</li>
<li>There might be an issue with token sequences that might require an
extra set of braces <span class="citation" data-cites="p3381r0">[<a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3381r0.html" role="doc-biblioref">P3381R0</a>]</span>.</li>
</ol></li>
</ul>
<p><strong># 28: <code class="sourceCode cpp"><span class="er">$</span><span class="op">(</span>foo<span class="op">)</span></code></strong></p>
<ul>
<li>Advantages
<ol type="1">
<li>It does not conflict with compiler support for using
<code class="sourceCode cpp"><span class="er">$</span></code> in
identifiers as an extension <span class="citation" data-cites="p3381r0">[<a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3381r0.html" role="doc-biblioref">P3381R0</a>]</span>.</li>
</ol></li>
<li>Disadvantages
<ol type="1">
<li>The <code class="sourceCode cpp"><span class="er">$</span></code> is
typically used as a splicing syntax in other languages, not as the get
meta syntax.</li>
</ol></li>
</ul>
<p><strong># 29:
<code class="sourceCode cpp"><span class="op">/</span>\foo</code></strong></p>
<ul>
<li>Advantages
<ol type="1">
<li>It is the big caret equivalent of the
<code class="sourceCode cpp"><span class="op">^</span></code>
symbol.</li>
</ol></li>
<li>Disadvantages
<ol type="1">
<li>There is an issue with UCNs.
<code class="sourceCode cpp"><span class="op">/</span>\u0</code> will
have <code class="sourceCode cpp">\u0</code> parsed as a UCN instead of
a reflection of <code class="sourceCode cpp">u0</code> <span class="citation" data-cites="p3381r0">[<a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3381r0.html" role="doc-biblioref">P3381R0</a>]</span>.</li>
</ol></li>
</ul>
<p><strong># 30: ``foo</strong></p>
<ul>
<li>Advantages
<ol type="1">
<li>This is a very lispy syntax. In Common Lisp the single `foo is used
to disable evaluation for a subexpression <span class="citation" data-cites="clSpec">[<a href="https://www.lispworks.com/documentation/HyperSpec/Body/02_df.htm" role="doc-biblioref">CLSpec</a>]</span>.</li>
</ol></li>
<li>Disadvantages
<ol type="1">
<li>Markdown uses three backquotes to indicate the start and end of a
code block, so it might be hard for Markdown to distinguish between
starting a code block and capturing an inline code block of a reflection
of foo.</li>
</ol></li>
</ul>
<h1 data-number="4" id="splicing-in-meta-operator-options"><span class="header-section-number">4</span> Splicing in Meta Operator
Options<a href="#splicing-in-meta-operator-options" class="self-link"></a></h1>
<h2 data-number="4.1" id="summary-1"><span class="header-section-number">4.1</span> Summary<a href="#summary-1" class="self-link"></a></h2>
<table style="width:29%;">
<colgroup>
<col style="width: 6%" />
<col style="width: 22%" />
</colgroup>
<thead>
<tr class="header">
<th><div style="text-align:center">
<strong>#</strong>
</div></th>
<th><div style="text-align:center">
<strong>Syntax</strong>
</div></th>
</tr>
</thead>
<tbody>
<tr class="odd">
<td>1</td>
<td><code class="sourceCode cpp"><span class="op">[:</span> foo <span class="op">:]</span></code></td>
</tr>
<tr class="even">
<td>2</td>
<td><code class="sourceCode cpp"><span class="op">@&gt;</span>foo</code></td>
</tr>
<tr class="odd">
<td>3</td>
<td><code class="sourceCode cpp"><span class="op">@&gt;&gt;</span>foo</code></td>
</tr>
<tr class="even">
<td>4</td>
<td><code class="sourceCode cpp"><span class="op">@-&gt;</span>foo</code></td>
</tr>
<tr class="odd">
<td>5</td>
<td><code class="sourceCode cpp">foo<span class="op">@&gt;</span></code></td>
</tr>
<tr class="even">
<td>6</td>
<td><code class="sourceCode cpp"><span class="op">(:</span> foo <span class="op">:)</span></code></td>
</tr>
<tr class="odd">
<td>7</td>
<td><code class="sourceCode cpp"><span class="op">(^</span> foo <span class="op">^)</span></code></td>
</tr>
<tr class="even">
<td>8</td>
<td><code class="sourceCode cpp"><span class="op">(^</span>_ foo _<span class="op">^)</span></code></td>
</tr>
<tr class="odd">
<td>9</td>
<td><code class="sourceCode cpp"><span class="op">-&gt;</span>foo</code></td>
</tr>
<tr class="even">
<td>10</td>
<td><code class="sourceCode cpp"><span class="op">&gt;-</span>foo</code></td>
</tr>
<tr class="odd">
<td>11</td>
<td><code class="sourceCode cpp"><span class="er">$</span>foo</code></td>
</tr>
<tr class="even">
<td>12</td>
<td><code class="sourceCode cpp"><span class="er">$$</span>foo</code></td>
</tr>
<tr class="odd">
<td>13</td>
<td><code class="sourceCode cpp">,foo</code></td>
</tr>
<tr class="even">
<td>14</td>
<td><code class="sourceCode cpp">,,foo</code></td>
</tr>
<tr class="odd">
<td>15</td>
<td><code class="sourceCode cpp"><span class="op">&amp;&amp;&gt;</span>foo</code></td>
</tr>
<tr class="even">
<td>16</td>
<td><code class="sourceCode cpp">foo<span class="op">@</span></code></td>
</tr>
<tr class="odd">
<td>17</td>
<td><code class="sourceCode cpp"><span class="op">[|</span> foo <span class="op">|]</span></code></td>
</tr>
<tr class="even">
<td>18</td>
<td><code class="sourceCode cpp"><span class="er">$</span><span class="op">{</span>foo<span class="op">}</span></code></td>
</tr>
<tr class="odd">
<td>19</td>
<td><code class="sourceCode cpp"><span class="er">$</span><span class="op">(</span>foo<span class="op">)</span></code></td>
</tr>
<tr class="even">
<td>20</td>
<td><code class="sourceCode cpp">,<span class="op">@</span>foo</code></td>
</tr>
<tr class="odd">
<td>21</td>
<td><code class="sourceCode cpp">foo<span class="op">&amp;&amp;</span></code></td>
</tr>
<tr class="even">
<td>22</td>
<td><code class="sourceCode cpp"><span class="op">&gt;&gt;@</span>foo</code></td>
</tr>
<tr class="odd">
<td>23</td>
<td><code class="sourceCode cpp"><span class="op">-&gt;@</span>foo</code></td>
</tr>
</tbody>
</table>
<h2 data-number="4.2" id="advantages-and-disadvantages-1"><span class="header-section-number">4.2</span> Advantages and Disadvantages<a href="#advantages-and-disadvantages-1" class="self-link"></a></h2>
<p><strong># 6: <code class="sourceCode cpp"><span class="op">(:</span> foo <span class="op">:)</span></code></strong></p>
<ul>
<li>Disadvantages
<ol type="1">
<li>It might be confusing to someone reading the code quickly.</li>
<li>It will render as a smiley face.</li>
</ol></li>
</ul>
<p><strong># 9:
<code class="sourceCode cpp"><span class="op">-&gt;</span>foo</code></strong></p>
<ul>
<li>Advantages
<ol type="1">
<li>It is similar to Go’s channel syntax <span class="citation" data-cites="goChannels">[<a href="https://gobyexample.com/channel-directions" role="doc-biblioref">GoChannels</a>]</span>.</li>
</ol></li>
<li>Disadvantages
<ol type="1">
<li>It could be a good relocation syntax in C++29.</li>
<li>It could be difficult to parse, particularly as a template argument
as in <code class="sourceCode cpp">fn<span class="op">&lt;-&gt;</span>foo<span class="op">&gt;</span></code>.</li>
</ol></li>
</ul>
<p><strong># 10:
<code class="sourceCode cpp"><span class="op">&gt;-</span>foo</code></strong></p>
<ul>
<li>Disadvantages
<ol type="1">
<li>There is a potential parsing ambiguity. <code class="sourceCode cpp">tvar<span class="op">&lt;&gt;-</span>foo<span class="op">&gt;-</span><span class="dv">3</span></code>
can be parsed as <code class="sourceCode cpp"><span class="op">(</span>tvar<span class="op">&lt;&gt;</span> <span class="op">-</span> foo<span class="op">)</span> <span class="op">&gt;</span> <span class="op">-</span><span class="dv">3</span></code>
or as <code class="sourceCode cpp">tvar<span class="op">&lt;(&gt;-</span>foo<span class="op">)&gt;</span> <span class="op">-</span> <span class="dv">3</span></code>.</li>
<li>It might require parentheses to parse the
<code class="sourceCode cpp"><span class="op">-</span></code> symbol for
code such as <code class="sourceCode cpp"><span class="op">&gt;-(-</span>foo<span class="op">)</span></code>.</li>
</ol></li>
</ul>
<p><strong># 11:
<code class="sourceCode cpp"><span class="er">$</span>foo</code></strong></p>
<ul>
<li>Advantages
<ol type="1">
<li>This syntax is used for splicing in a number of programming
languages.</li>
<li>It doesn’t conflict with anything else in C++ since it was recently
added to the basic character set <span class="citation" data-cites="p3381r0">[<a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3381r0.html" role="doc-biblioref">P3381R0</a>]</span>.</li>
</ol></li>
<li>Disadvantages
<ol type="1">
<li>Compilers allow using
<code class="sourceCode cpp"><span class="er">$</span></code> in
identifiers as an extension, so it can be hard to differentiate between
an identifier and reflecting on an identifier <span class="citation" data-cites="p3381r0">[<a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3381r0.html" role="doc-biblioref">P3381R0</a>]</span>.</li>
</ol></li>
</ul>
<p><strong># 13: <code class="sourceCode cpp">,foo</code></strong></p>
<ul>
<li>Advantages
<ol type="1">
<li>In Common Lisp it is used to evaluate and splice in an expression
<span class="citation" data-cites="clSpec">[<a href="https://www.lispworks.com/documentation/HyperSpec/Body/02_df.htm" role="doc-biblioref">CLSpec</a>]</span>.</li>
</ol></li>
<li>Disadvantages
<ol type="1">
<li>It may be difficult to parse.</li>
</ol></li>
</ul>
<p><strong># 14: <code class="sourceCode cpp">,,foo</code></strong></p>
<ul>
<li>Disadvantages
<ol type="1">
<li>It may be difficult to parse. An example could be <code class="sourceCode cpp">fn<span class="op">(</span>,,<span class="dt">bool</span>, ,,<span class="dt">int</span>, ,,<span class="dt">char</span><span class="op">)</span></code>.</li>
</ol></li>
</ul>
<p><strong># 17: <code class="sourceCode cpp"><span class="op">[|</span> foo <span class="op">|]</span></code></strong></p>
<ul>
<li>Advantages
<ol type="1">
<li>It is used in Template Haskell for expression quotation <span class="citation" data-cites="thQuotes">[<a href="https://downloads.haskell.org/ghc/latest/docs/users_guide/exts/template_haskell.html#extension-TemplateHaskellQuotes" role="doc-biblioref">thQuotes</a>]</span>.</li>
</ol></li>
</ul>
<p><strong># 18 <code class="sourceCode cpp"><span class="er">$</span><span class="op">{</span>foo<span class="op">}</span></code></strong></p>
<ul>
<li>Advantages
<ol type="1">
<li>It does not conflict with compiler support for using
<code class="sourceCode cpp"><span class="er">$</span></code> in
identifiers as an extension <span class="citation" data-cites="p3381r0">[<a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3381r0.html" role="doc-biblioref">P3381R0</a>]</span>.</li>
</ol></li>
<li>Disadvantages
<ol type="1">
<li>There might be an issue with token sequences that might require an
extra set of braces <span class="citation" data-cites="p3381r0">[<a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3381r0.html" role="doc-biblioref">P3381R0</a>]</span>.</li>
</ol></li>
</ul>
<p><strong># 19 <code class="sourceCode cpp"><span class="er">$</span><span class="op">(</span>foo<span class="op">)</span></code></strong></p>
<ul>
<li>Advantages
<ol type="1">
<li>It does not conflict with compiler support for using
<code class="sourceCode cpp"><span class="er">$</span></code> in
identifiers as an extension <span class="citation" data-cites="p3381r0">[<a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3381r0.html" role="doc-biblioref">P3381R0</a>]</span>.</li>
</ol></li>
</ul>
<p><strong># 20:
<code class="sourceCode cpp">,<span class="op">@</span>foo</code></strong></p>
<ul>
<li>Advantages
<ol type="1">
<li>In Common Lisp it is used to evaluate and splice in a list of values
resulting from an expression <span class="citation" data-cites="clSpec">[<a href="https://www.lispworks.com/documentation/HyperSpec/Body/02_df.htm" role="doc-biblioref">CLSpec</a>]</span>.</li>
</ol></li>
</ul>
<h1 data-number="5" id="get-meta-contextual-and-function-keywords"><span class="header-section-number">5</span> Get Meta Contextual and Function
Keywords<a href="#get-meta-contextual-and-function-keywords" class="self-link"></a></h1>
<h2 data-number="5.1" id="summary-2"><span class="header-section-number">5.1</span> Summary<a href="#summary-2" class="self-link"></a></h2>
<table style="width:42%;">
<colgroup>
<col style="width: 6%" />
<col style="width: 34%" />
</colgroup>
<thead>
<tr class="header">
<th><div style="text-align:center">
<strong>#</strong>
</div></th>
<th><div style="text-align:center">
<strong>Syntax</strong>
</div></th>
</tr>
</thead>
<tbody>
<tr class="odd">
<td>1</td>
<td><code class="sourceCode cpp">lift foo</code></td>
</tr>
<tr class="even">
<td>2</td>
<td><code class="sourceCode cpp">lift<span class="op">(</span>foo<span class="op">)</span></code></td>
</tr>
<tr class="odd">
<td>3</td>
<td><code class="sourceCode cpp">reflexpr foo</code></td>
</tr>
<tr class="even">
<td>4</td>
<td><code class="sourceCode cpp">reflexpr<span class="op">(</span>foo<span class="op">)</span></code></td>
</tr>
<tr class="odd">
<td>5</td>
<td><code class="sourceCode cpp">refl foo</code></td>
</tr>
<tr class="even">
<td>6</td>
<td><code class="sourceCode cpp">refl<span class="op">(</span>foo<span class="op">)</span></code></td>
</tr>
<tr class="odd">
<td>7</td>
<td><code class="sourceCode cpp">ref foo</code></td>
</tr>
<tr class="even">
<td>8</td>
<td><code class="sourceCode cpp">ref<span class="op">(</span>foo<span class="op">)</span></code></td>
</tr>
<tr class="odd">
<td>9</td>
<td><code class="sourceCode cpp">meta foo</code></td>
</tr>
<tr class="even">
<td>10</td>
<td><code class="sourceCode cpp">meta<span class="op">(</span>foo<span class="op">)</span></code></td>
</tr>
<tr class="odd">
<td>11</td>
<td><code class="sourceCode cpp">symbol foo</code></td>
</tr>
<tr class="even">
<td>12</td>
<td><code class="sourceCode cpp">symbol<span class="op">(</span>foo<span class="op">)</span></code></td>
</tr>
<tr class="odd">
<td>13</td>
<td><code class="sourceCode cpp">syntax foo</code></td>
</tr>
<tr class="even">
<td>14</td>
<td><code class="sourceCode cpp">syntax<span class="op">(</span>foo<span class="op">)</span></code></td>
</tr>
<tr class="odd">
<td>15</td>
<td><code class="sourceCode cpp">expr foo</code></td>
</tr>
<tr class="even">
<td>16</td>
<td><code class="sourceCode cpp">expr<span class="op">(</span>foo<span class="op">)</span></code></td>
</tr>
<tr class="odd">
<td>17</td>
<td><code class="sourceCode cpp">reflect foo</code></td>
</tr>
<tr class="even">
<td>18</td>
<td><code class="sourceCode cpp">reflect<span class="op">(</span>foo<span class="op">)</span></code></td>
</tr>
<tr class="odd">
<td>19</td>
<td><code class="sourceCode cpp">metafy foo</code></td>
</tr>
<tr class="even">
<td>20</td>
<td><code class="sourceCode cpp">metafy<span class="op">(</span>foo<span class="op">)</span></code></td>
</tr>
<tr class="odd">
<td>21</td>
<td><code class="sourceCode cpp">metify foo</code></td>
</tr>
<tr class="even">
<td>22</td>
<td><code class="sourceCode cpp">metify<span class="op">(</span>foo<span class="op">)</span></code></td>
</tr>
<tr class="odd">
<td>23</td>
<td><code class="sourceCode cpp">inspect foo</code></td>
</tr>
<tr class="even">
<td>24</td>
<td><code class="sourceCode cpp">inspect<span class="op">(</span>foo<span class="op">)</span></code></td>
</tr>
<tr class="odd">
<td>25</td>
<td><code class="sourceCode cpp">reflectof foo</code></td>
</tr>
<tr class="even">
<td>26</td>
<td><code class="sourceCode cpp">reflectof<span class="op">(</span>foo<span class="op">)</span></code></td>
</tr>
<tr class="odd">
<td>27</td>
<td><code class="sourceCode cpp">reflof foo</code></td>
</tr>
<tr class="even">
<td>28</td>
<td><code class="sourceCode cpp">reflof<span class="op">(</span>foo<span class="op">)</span></code></td>
</tr>
<tr class="odd">
<td>29</td>
<td><code class="sourceCode cpp">metaof foo</code></td>
</tr>
<tr class="even">
<td>30</td>
<td><code class="sourceCode cpp">metaof<span class="op">(</span>foo<span class="op">)</span></code></td>
</tr>
<tr class="odd">
<td>31</td>
<td><code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span>meta<span class="op">(</span>foo<span class="op">)</span></code></td>
</tr>
<tr class="even">
<td>32</td>
<td><code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span>get<span class="op">(</span>foo<span class="op">)</span></code></td>
</tr>
<tr class="odd">
<td>33</td>
<td><code class="sourceCode cpp">std<span class="op">::</span>meta<span class="op">::</span>parse<span class="op">(</span>foo<span class="op">)</span></code></td>
</tr>
</tbody>
</table>
<h2 data-number="5.2" id="advantages-and-disadvantages-2"><span class="header-section-number">5.2</span> Advantages and Disadvantages<a href="#advantages-and-disadvantages-2" class="self-link"></a></h2>
<p><strong># 4: <code class="sourceCode cpp">reflexpr<span class="op">(</span>foo<span class="op">)</span></code></strong></p>
<ul>
<li>Advantages
<ol type="1">
<li>This is the originally proposed keyword <span class="citation" data-cites="p1240r0">[<a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p1240r0.pdf" role="doc-biblioref">P1240R0</a>]</span>.</li>
</ol></li>
</ul>
<p><strong># 15:
<code class="sourceCode cpp">expr foo</code></strong></p>
<ul>
<li>Disadvantages
<ol type="1">
<li>Compilers often use internal
<code class="sourceCode cpp">Expr</code> data structure
definitions.</li>
<li>It implies getting an expression from foo, not meta info.</li>
<li>The full <code class="sourceCode cpp">expr foo</code> <em>would</em>
be an expression, and <code class="sourceCode cpp">foo</code> is not
generally an expression.</li>
</ol></li>
</ul>
<p><strong># 16: <code class="sourceCode cpp">expr<span class="op">(</span>foo<span class="op">)</span></code></strong></p>
<ul>
<li>Disadvantages
<ol type="1">
<li>Compilers often use internal
<code class="sourceCode cpp">Expr</code> data structure
definitions.</li>
<li>It implies getting an expression from foo, not meta info.</li>
</ol></li>
</ul>
<h1 data-number="6" id="splice-in-meta-contextual-and-function-keywords"><span class="header-section-number">6</span> Splice in Meta Contextual and
Function Keywords<a href="#splice-in-meta-contextual-and-function-keywords" class="self-link"></a></h1>
<h2 data-number="6.1" id="summary-3"><span class="header-section-number">6.1</span> Summary<a href="#summary-3" class="self-link"></a></h2>
<table style="width:35%;">
<colgroup>
<col style="width: 6%" />
<col style="width: 27%" />
</colgroup>
<thead>
<tr class="header">
<th><div style="text-align:center">
<strong>#</strong>
</div></th>
<th><div style="text-align:center">
<strong>Syntax</strong>
</div></th>
</tr>
</thead>
<tbody>
<tr class="odd">
<td>1</td>
<td><code class="sourceCode cpp">splice foo</code></td>
</tr>
<tr class="even">
<td>2</td>
<td><code class="sourceCode cpp">splice<span class="op">(</span>foo<span class="op">)</span></code></td>
</tr>
<tr class="odd">
<td>3</td>
<td><code class="sourceCode cpp">splice_in foo</code></td>
</tr>
<tr class="even">
<td>4</td>
<td><code class="sourceCode cpp">splice_in<span class="op">(</span>foo<span class="op">)</span></code></td>
</tr>
<tr class="odd">
<td>5</td>
<td><code class="sourceCode cpp">eval foo</code></td>
</tr>
<tr class="even">
<td>6</td>
<td><code class="sourceCode cpp">eval<span class="op">(</span>foo<span class="op">)</span></code></td>
</tr>
<tr class="odd">
<td>7</td>
<td><code class="sourceCode cpp">evalmeta foo</code></td>
</tr>
<tr class="even">
<td>8</td>
<td><code class="sourceCode cpp">evalmeta<span class="op">(</span>foo<span class="op">)</span></code></td>
</tr>
<tr class="odd">
<td>9</td>
<td><code class="sourceCode cpp">unlift foo</code></td>
</tr>
<tr class="even">
<td>10</td>
<td><code class="sourceCode cpp">unlift<span class="op">(</span>foo<span class="op">)</span></code></td>
</tr>
<tr class="odd">
<td>11</td>
<td><code class="sourceCode cpp">demeta foo</code></td>
</tr>
<tr class="even">
<td>12</td>
<td><code class="sourceCode cpp">demeta<span class="op">(</span>foo<span class="op">)</span></code></td>
</tr>
<tr class="odd">
<td>13</td>
<td><code class="sourceCode cpp">unmeta foo</code></td>
</tr>
<tr class="even">
<td>14</td>
<td><code class="sourceCode cpp">unmeta<span class="op">(</span>foo<span class="op">)</span></code></td>
</tr>
<tr class="odd">
<td>15</td>
<td><code class="sourceCode cpp">unref foo</code></td>
</tr>
<tr class="even">
<td>16</td>
<td><code class="sourceCode cpp">unref<span class="op">(</span>foo<span class="op">)</span></code></td>
</tr>
<tr class="odd">
<td>17</td>
<td><code class="sourceCode cpp">deref foo</code></td>
</tr>
<tr class="even">
<td>18</td>
<td><code class="sourceCode cpp">deref<span class="op">(</span>foo<span class="op">)</span></code></td>
</tr>
<tr class="odd">
<td>19</td>
<td><code class="sourceCode cpp">unrefl foo</code></td>
</tr>
<tr class="even">
<td>20</td>
<td><code class="sourceCode cpp">unrefl<span class="op">(</span>foo<span class="op">)</span></code></td>
</tr>
<tr class="odd">
<td>21</td>
<td><code class="sourceCode cpp">derefl foo</code></td>
</tr>
<tr class="even">
<td>22</td>
<td><code class="sourceCode cpp">derefl<span class="op">(</span>foo<span class="op">)</span></code></td>
</tr>
<tr class="odd">
<td>23</td>
<td><code class="sourceCode cpp">value foo</code></td>
</tr>
<tr class="even">
<td>24</td>
<td><code class="sourceCode cpp">value<span class="op">(</span>foo<span class="op">)</span></code></td>
</tr>
<tr class="odd">
<td>25</td>
<td><code class="sourceCode cpp">getvalue foo</code></td>
</tr>
<tr class="even">
<td>26</td>
<td><code class="sourceCode cpp">getvalue<span class="op">(</span>foo<span class="op">)</span></code></td>
</tr>
<tr class="odd">
<td>27</td>
<td><code class="sourceCode cpp">unexpr foo</code></td>
</tr>
<tr class="even">
<td>28</td>
<td><code class="sourceCode cpp">unexpr<span class="op">(</span>foo<span class="op">)</span></code></td>
</tr>
<tr class="odd">
<td>29</td>
<td><code class="sourceCode cpp">deexpr foo</code></td>
</tr>
<tr class="even">
<td>30</td>
<td><code class="sourceCode cpp">deexpr<span class="op">(</span>foo<span class="op">)</span></code></td>
</tr>
<tr class="odd">
<td>31</td>
<td><code class="sourceCode cpp">dereflect foo</code></td>
</tr>
<tr class="even">
<td>32</td>
<td><code class="sourceCode cpp">dereflect<span class="op">(</span>foo<span class="op">)</span></code></td>
</tr>
<tr class="odd">
<td>33</td>
<td><code class="sourceCode cpp">unreflect foo</code></td>
</tr>
<tr class="even">
<td>34</td>
<td><code class="sourceCode cpp">unreflect<span class="op">(</span>foo<span class="op">)</span></code></td>
</tr>
<tr class="odd">
<td>35</td>
<td><code class="sourceCode cpp">demetafy foo</code></td>
</tr>
<tr class="even">
<td>36</td>
<td><code class="sourceCode cpp">demetafy<span class="op">(</span>foo<span class="op">)</span></code></td>
</tr>
<tr class="odd">
<td>37</td>
<td><code class="sourceCode cpp">unmetafy foo</code></td>
</tr>
<tr class="even">
<td>38</td>
<td><code class="sourceCode cpp">unmetafy<span class="op">(</span>foo<span class="op">)</span></code></td>
</tr>
<tr class="odd">
<td>39</td>
<td><code class="sourceCode cpp">unmetify foo</code></td>
</tr>
<tr class="even">
<td>40</td>
<td><code class="sourceCode cpp">unmetify<span class="op">(</span>foo<span class="op">)</span></code></td>
</tr>
<tr class="odd">
<td>41</td>
<td><code class="sourceCode cpp">uninspect foo</code></td>
</tr>
<tr class="even">
<td>42</td>
<td><code class="sourceCode cpp">uninspect<span class="op">(</span>foo<span class="op">)</span></code></td>
</tr>
<tr class="odd">
<td>43</td>
<td><code class="sourceCode cpp">deinspect foo</code></td>
</tr>
<tr class="even">
<td>44</td>
<td><code class="sourceCode cpp">deinspect<span class="op">(</span>foo<span class="op">)</span></code></td>
</tr>
<tr class="odd">
<td>45</td>
<td><code class="sourceCode cpp">dump foo</code></td>
</tr>
<tr class="even">
<td>46</td>
<td><code class="sourceCode cpp">dump<span class="op">(</span>foo<span class="op">)</span></code></td>
</tr>
<tr class="odd">
<td>47</td>
<td><code class="sourceCode cpp">unsyntax foo</code></td>
</tr>
<tr class="even">
<td>48</td>
<td><code class="sourceCode cpp">unsyntax<span class="op">(</span>foo<span class="op">)</span></code></td>
</tr>
<tr class="odd">
<td>49</td>
<td><code class="sourceCode cpp">desyntax foo</code></td>
</tr>
<tr class="even">
<td>50</td>
<td><code class="sourceCode cpp">desyntax<span class="op">(</span>foo<span class="op">)</span></code></td>
</tr>
<tr class="odd">
<td>51</td>
<td><code class="sourceCode cpp">desugar foo</code></td>
</tr>
<tr class="even">
<td>52</td>
<td><code class="sourceCode cpp">desugar<span class="op">(</span>foo<span class="op">)</span></code></td>
</tr>
<tr class="odd">
<td>53</td>
<td><code class="sourceCode cpp">unsymbol foo</code></td>
</tr>
<tr class="even">
<td>54</td>
<td><code class="sourceCode cpp">unsymbol<span class="op">(</span>foo<span class="op">)</span></code></td>
</tr>
<tr class="odd">
<td>55</td>
<td><code class="sourceCode cpp">desymbol foo</code></td>
</tr>
<tr class="even">
<td>56</td>
<td><code class="sourceCode cpp">desymbol<span class="op">(</span>foo<span class="op">)</span></code></td>
</tr>
<tr class="odd">
<td>57</td>
<td><code class="sourceCode cpp">unreflexpr foo</code></td>
</tr>
<tr class="even">
<td>58</td>
<td><code class="sourceCode cpp">unreflexpr<span class="op">(</span>foo<span class="op">)</span></code></td>
</tr>
</tbody>
</table>
<h2 data-number="6.2" id="advantages-and-disadvantages-3"><span class="header-section-number">6.2</span> Advantages and Disadvantages<a href="#advantages-and-disadvantages-3" class="self-link"></a></h2>
<p><strong># 17:
<code class="sourceCode cpp">deref foo</code></strong></p>
<ul>
<li>Disadvantages
<ol type="1">
<li>It sounds like you are dereferencing
<code class="sourceCode cpp">foo</code>, not splicing in its meta
value.</li>
</ol></li>
</ul>
<p><strong># 18: <code class="sourceCode cpp">deref<span class="op">(</span>foo<span class="op">)</span></code></strong></p>
<ul>
<li>Disadvantages
<ol type="1">
<li>It sounds like you are dereferencing
<code class="sourceCode cpp">foo</code>, not splicing in its meta
value.</li>
</ol></li>
</ul>
<p><strong># 58: <code class="sourceCode cpp">unreflexpr<span class="op">(</span>foo<span class="op">)</span></code></strong></p>
<ul>
<li>Advantages
<ol type="1">
<li>The original reflection design used this <span class="citation" data-cites="p1240r0">[<a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p1240r0.pdf" role="doc-biblioref">P1240R0</a>]</span>.</li>
</ol></li>
<li>Disadvantages
<ol type="1">
<li>It is verbose <span class="citation" data-cites="p3381r0">[<a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3381r0.html" role="doc-biblioref">P3381R0</a>]</span>.</li>
</ol></li>
</ul>
<h1 data-number="7" id="general-syntax-types"><span class="header-section-number">7</span> General Syntax Types<a href="#general-syntax-types" class="self-link"></a></h1>
<h2 data-number="7.1" id="summary-4"><span class="header-section-number">7.1</span> Summary<a href="#summary-4" class="self-link"></a></h2>
<table style="width:57%;">
<colgroup>
<col style="width: 6%" />
<col style="width: 50%" />
</colgroup>
<thead>
<tr class="header">
<th><div style="text-align:center">
<strong>#</strong>
</div></th>
<th><div style="text-align:center">
<strong>Syntax Type</strong>
</div></th>
</tr>
</thead>
<tbody>
<tr class="odd">
<td>1</td>
<td>Unary prefix operators</td>
</tr>
<tr class="even">
<td>2</td>
<td>Bounded splice operators</td>
</tr>
<tr class="odd">
<td>3</td>
<td>Single character splice operators</td>
</tr>
<tr class="even">
<td>4</td>
<td>Function keywords</td>
</tr>
<tr class="odd">
<td>5</td>
<td>Contextual keywords</td>
</tr>
<tr class="even">
<td>6</td>
<td>Library functions</td>
</tr>
</tbody>
</table>
<h2 data-number="7.2" id="advantages-and-disadvantages-4"><span class="header-section-number">7.2</span> Advantages and Disadvantages<a href="#advantages-and-disadvantages-4" class="self-link"></a></h2>
<p><strong># 1: Unary prefix operators</strong></p>
<ul>
<li>Disadvantages
<ol type="1">
<li>It requires operator precedence rules to parse the code.</li>
<li>It may require inserting parentheses to ensure operational order,
similar to pointer dereferencing: <code class="sourceCode cpp"><span class="op">*(</span>foo<span class="op">())</span></code>.</li>
</ol></li>
</ul>
<p><strong># 2: Bounded splice operators</strong></p>
<ul>
<li>Advantages
<ol type="1">
<li>They can be easier to parse for nested name specifiers like <code class="sourceCode cpp"><span class="op">[:</span>Cls<span class="op">::</span>reflection_member<span class="op">:]::</span>inner<span class="op">::</span>member</code>,
which is easier to parse than <code class="sourceCode cpp"><span class="er">$</span>Cls<span class="op">::</span>reflection_member<span class="op">::</span>inner<span class="op">::</span>member</code>.</li>
</ol></li>
</ul>
<p><strong># 3: Single character splice operators</strong></p>
<ul>
<li>Advantages
<ol type="1">
<li>They are a terser syntax.</li>
</ol></li>
<li>Disadvantages
<ol type="1">
<li>There is potentially an issue with postfix operators when it comes
to parsing.</li>
<li>It can be difficult to parse complicated expressions that need to be
spliced in.</li>
</ol></li>
</ul>
<p><strong># 4: Function keywords</strong></p>
<ul>
<li>Disadvantages
<ol type="1">
<li>It is a heavier syntax, and it does not contribute more than a
terser syntax to readability <span class="citation" data-cites="p3381r0">[<a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3381r0.html" role="doc-biblioref">P3381R0</a>]</span>.</li>
<li>A reflection is typically taken to pass the reflection to a function
that operates on it, not just to get the reflection. As a result, making
a reflection syntax stand out is less impactful given its pass-through
nature <span class="citation" data-cites="p3381r0">[<a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3381r0.html" role="doc-biblioref">P3381R0</a>]</span>.</li>
<li>Novices will rarely use reflection, so choosing a novice-friendly
keyword may not serve its most common user base <span class="citation" data-cites="p3381r0">[<a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3381r0.html" role="doc-biblioref">P3381R0</a>]</span>.</li>
<li>For splicing, unparenthesized keywords, when used as a part of an
unqualified-id, make it difficult to know where the splice ends. An
example is <code class="sourceCode cpp">splice foo<span class="op">::</span>bar<span class="op">::</span>baz</code>.</li>
</ol></li>
</ul>
<p><strong># 5: Contextual keywords</strong></p>
<ul>
<li>Disadvantages
<ol type="1">
<li>It is a heavier syntax, and it does not contribute more than a
terser syntax to readability <span class="citation" data-cites="p3381r0">[<a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3381r0.html" role="doc-biblioref">P3381R0</a>]</span>.</li>
<li>A reflection is typically taken to pass the reflection to a function
that operates on it, not just to get the reflection. As a result, making
a reflection syntax stand out is less impactful given its pass-through
nature <span class="citation" data-cites="p3381r0">[<a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3381r0.html" role="doc-biblioref">P3381R0</a>]</span>.</li>
<li>Novices will rarely use reflection, so choosing a novice-friendly
keyword may not serve its most common user base <span class="citation" data-cites="p3381r0">[<a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3381r0.html" role="doc-biblioref">P3381R0</a>]</span>.</li>
</ol></li>
</ul>
<h1 data-number="8" id="acknowledgements"><span class="header-section-number">8</span> Acknowledgements<a href="#acknowledgements" class="self-link"></a></h1>
<p>Some of the syntax ideas, as well as their respective advantages and
disadvantages, are my own, but many others came from discussions with
Alisdair Meredith and a number of my other colleagues and peers.</p>
<h1 data-number="9" id="bibliography"><span class="header-section-number">9</span> References<a href="#bibliography" class="self-link"></a></h1>
<div id="refs" class="references csl-bib-body hanging-indent" data-entry-spacing="1" role="doc-bibliography">
<div id="ref-clSpec" class="csl-entry" role="doc-biblioentry">
[CLSpec] Common Lisp HyperSpec: 2.4.6 Backquote. <a href="https://www.lispworks.com/documentation/HyperSpec/Body/02_df.htm"><div class="csl-block">https://www.lispworks.com/documentation/HyperSpec/Body/02_df.htm</div></a>
</div>
<div id="ref-goChannels" class="csl-entry" role="doc-biblioentry">
[GoChannels] Go by Example: Channel Directions. <a href="https://gobyexample.com/channel-directions"><div class="csl-block">https://gobyexample.com/channel-directions</div></a>
</div>
<div id="ref-juliaMeta" class="csl-entry" role="doc-biblioentry">
[JuliaMeta] Julia Programming Language Documentation: Metaprogramming.
<a href="https://docs.julialang.org/en/v1/manual/metaprogramming/"><div class="csl-block">https://docs.julialang.org/en/v1/manual/metaprogramming/</div></a>
</div>
<div id="ref-p1240r0" class="csl-entry" role="doc-biblioentry">
[P1240R0] Andrew Sutton, Faisal Vali, and Daveed Vandevoorde.
2018-08-10. Scalable Reflection in C++. (August 2018). <a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p1240r0.pdf"><div class="csl-block">https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p1240r0.pdf</div></a>
</div>
<div id="ref-p2688r1" class="csl-entry" role="doc-biblioentry">
[P2688R1] Michael Park. 2024-02-15. Pattern Matching: match Expression.
(February 2024). <a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p2688r1.pdf"><div class="csl-block">https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p2688r1.pdf</div></a>
</div>
<div id="ref-p3294r1" class="csl-entry" role="doc-biblioentry">
[P3294R1] Andrei Alexandrescu, Barry Revzin, and Daveed Vandevoorde.
2024-07-16. Code Injection with Token Sequences. (July 2024). <a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3294r1.html"><div class="csl-block">https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3294r1.html</div></a>
</div>
<div id="ref-p3381r0" class="csl-entry" role="doc-biblioentry">
[P3381R0] Wyatt Childers, Peter Dimov, Dan Katz, Barry Revzin, Andrew
Sutton, Faisal Vali, and Daveed Vandevoorde. 2024-09-16. Syntax for
Reflection. (September 2024). <a href="https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3381r0.html"><div class="csl-block">https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3381r0.html</div></a>
</div>
<div id="ref-thQuotes" class="csl-entry" role="doc-biblioentry">
[thQuotes] Glasgow Haskell Compiler Documentation: Language Extension:
Template Haskell: Quotes Syntax. <a href="https://downloads.haskell.org/ghc/latest/docs/users_guide/exts/template_haskell.html#extension-TemplateHaskellQuotes"><div class="csl-block">https://downloads.haskell.org/ghc/latest/docs/users_guide/exts/template_haskell.html#extension-TemplateHaskellQuotes</div></a>
</div>
</div>
</div>
</div>
</body>
</html>
