Separate syntax highlighting category for header/body characters ;:?

14 files changed, 143 insertions, 143 deletions

diff --git a/docs/doc/block.html b/docs/doc/block.html
index 64643e7d..40de8ab2 100644
--- a/docs/doc/block.html
+++ b/docs/doc/block.html
@@ -135,26 +135,26 @@
 </pre>
 <p>Because <code><span class='Value'>𝕣</span></code> only ever refers to a 1-modifier or 2-modifer, it can never make sense to refer to it as a function, and the uppercase letter <code><span class='Value'>ℝ</span></code> is not recognized by BQN. In order to allow <code><span class='Value'>𝕣</span></code> to be spelled as a 1-modifier <code><span class='Modifier'>_𝕣</span></code> or 2-modifier <code><span class='Modifier2'>_𝕣_</span></code>, it is treated as an ordinary identifier character, so it must be separated from letters or numbers by spaces.</p>
 <h2 id="block-headers"><a class="header" href="#block-headers">Block headers</a></h2>
-<p>As a program becomes larger, it often becomes necessary to name inputs to blocks rather than just using special names. It can also become difficult to identify what kind of block is being defined, as it requires scanning through the block for special names. A <em>block header</em>, which is separated from the body of a block by a colon <code><span class='Value'>:</span></code>, specifies the kind of block and can declare names for the block and its inputs.</p>
-<pre><span class='Function'>Fact</span> <span class='Gets'>←</span> <span class='Brace'>{</span> <span class='Function'>F</span> <span class='Value'>n:</span>
+<p>As a program becomes larger, it often becomes necessary to name inputs to blocks rather than just using special names. It can also become difficult to identify what kind of block is being defined, as it requires scanning through the block for special names. A <em>block header</em>, which is separated from the body of a block by a colon <code><span class='Head'>:</span></code>, specifies the kind of block and can declare names for the block and its inputs.</p>
+<pre><span class='Function'>Fact</span> <span class='Gets'>←</span> <span class='Brace'>{</span> <span class='Function'>F</span> <span class='Value'>n</span><span class='Head'>:</span>
   <span class='Value'>n</span> <span class='Function'>×</span> <span class='Paren'>(</span><span class='Number'>0</span><span class='Modifier2'>⊸</span><span class='Function'>&lt;</span><span class='Paren'>)</span><span class='Modifier2'>◶</span><span class='Number'>1</span><span class='Ligature'>‿</span><span class='Function'>F</span> <span class='Value'>n</span><span class='Function'>-</span><span class='Number'>1</span>
 <span class='Brace'>}</span>
 </pre>
 <p>Its syntax mirrors an application of the block. As suggested by the positioning, the names given in a header apply only inside the block: for example <code><span class='Function'>F</span></code> above is only defined inside the <code><span class='Brace'>{}</span></code> braces while <code><span class='Function'>Fact</span></code> could be used either outside or inside. Some other possibilites are given below.</p>
 <pre><span class='Comment'># A dyadic function that refers to itself as Func
-</span><span class='Brace'>{</span> <span class='Value'>l</span> <span class='Function'>Func</span> <span class='Value'>r:</span>
+</span><span class='Brace'>{</span> <span class='Value'>l</span> <span class='Function'>Func</span> <span class='Value'>r</span><span class='Head'>:</span>
   <span class='Value'>…</span>
 
 <span class='Comment'># A deferred 1-modifier with a list argument
-</span><span class='Brace'>{</span> <span class='Function'>Fn</span> <span class='Modifier'>_apply</span> <span class='Bracket'>⟨</span><span class='Value'>a</span><span class='Separator'>,</span><span class='Value'>b</span><span class='Bracket'>⟩</span><span class='Value'>:</span>
+</span><span class='Brace'>{</span> <span class='Function'>Fn</span> <span class='Modifier'>_apply</span> <span class='Bracket'>⟨</span><span class='Value'>a</span><span class='Separator'>,</span><span class='Value'>b</span><span class='Bracket'>⟩</span><span class='Head'>:</span>
   <span class='Value'>…</span>
 
 <span class='Comment'># A monadic function with no names given
-</span><span class='Brace'>{</span> <span class='Function'>𝕊</span><span class='Value'>𝕩:</span>
+</span><span class='Brace'>{</span> <span class='Function'>𝕊</span><span class='Value'>𝕩</span><span class='Head'>:</span>
   <span class='Value'>…</span>
 
 <span class='Comment'># An immediate or deferred 2-modifier
-</span><span class='Brace'>{</span> <span class='Function'>F</span> <span class='Modifier2'>_op_</span> <span class='Value'>val:</span>
+</span><span class='Brace'>{</span> <span class='Function'>F</span> <span class='Modifier2'>_op_</span> <span class='Value'>val</span><span class='Head'>:</span>
   <span class='Value'>…</span>
 </pre>
 <p>In all cases special names still work just like in a headerless function. In this respect the effect of the header is the same as a series of assignments at the beginning of a function, such as the following translation of the second header above:</p>
@@ -167,31 +167,31 @@
 <p>Unlike these assignments, the header also constrains what inputs the block can take: a monadic 1-modifier like the one above can't take a right operand or left argument, and consequently its body can't contain <code><span class='Function'>𝔾</span></code> or <code><span class='Value'>𝕨</span></code>. Calling it with a left argument, or a right argument that isn't a two-element list, will result in an error.</p>
 <h3 id="destructuring"><a class="header" href="#destructuring">Destructuring</a></h3>
 <p>Arguments, but not operands, allow destructuring like assignment does. While assignment only tolerates lists of variables, header destructuring also allows constants. The argument must match the given structure, including the constants where they appear, or an error results.</p>
-<a class="replLink" title="Open in the REPL" target="_blank" href="https://mlochbaum.github.io/BQN/try.html#code=RGVzdHJ1Y3Qg4oaQIHsg8J2ViiBh4oC/MeKAv+KfqGIsMuKfqTogYeKJjWIgfQpEZXN0cnVjdCAgICAgICA14oC/MeKAv+KfqDcsMuKfqQ==">↗️</a><pre>    <span class='Function'>Destruct</span> <span class='Gets'>←</span> <span class='Brace'>{</span> <span class='Function'>𝕊</span> <span class='Value'>a</span><span class='Ligature'>‿</span><span class='Number'>1</span><span class='Ligature'>‿</span><span class='Bracket'>⟨</span><span class='Value'>b</span><span class='Separator'>,</span><span class='Number'>2</span><span class='Bracket'>⟩</span><span class='Value'>:</span> <span class='Value'>a</span><span class='Function'>≍</span><span class='Value'>b</span> <span class='Brace'>}</span>
+<a class="replLink" title="Open in the REPL" target="_blank" href="https://mlochbaum.github.io/BQN/try.html#code=RGVzdHJ1Y3Qg4oaQIHsg8J2ViiBh4oC/MeKAv+KfqGIsMuKfqTogYeKJjWIgfQpEZXN0cnVjdCAgICAgICA14oC/MeKAv+KfqDcsMuKfqQ==">↗️</a><pre>    <span class='Function'>Destruct</span> <span class='Gets'>←</span> <span class='Brace'>{</span> <span class='Function'>𝕊</span> <span class='Value'>a</span><span class='Ligature'>‿</span><span class='Number'>1</span><span class='Ligature'>‿</span><span class='Bracket'>⟨</span><span class='Value'>b</span><span class='Separator'>,</span><span class='Number'>2</span><span class='Bracket'>⟩</span><span class='Head'>:</span> <span class='Value'>a</span><span class='Function'>≍</span><span class='Value'>b</span> <span class='Brace'>}</span>
     <span class='Function'>Destruct</span>       <span class='Number'>5</span><span class='Ligature'>‿</span><span class='Number'>1</span><span class='Ligature'>‿</span><span class='Bracket'>⟨</span><span class='Number'>7</span><span class='Separator'>,</span><span class='Number'>2</span><span class='Bracket'>⟩</span>
 ⟨ 5 7 ⟩
 </pre>
 <h3 id="special-names-in-headers"><a class="header" href="#special-names-in-headers">Special names in headers</a></h3>
-<p>Any element of a function or modifier header can be left nameless by using the corresponding special name in that position, instead of an identifier. For example, the header <code><span class='Value'>𝕨</span> <span class='Function'>𝔽</span><span class='Modifier2'>_𝕣_</span><span class='Function'>𝔾</span> <span class='Value'>𝕩:</span></code> incorporates as much vagueness as possible. It indicates a deferred 2-modifier, but provides no other information.</p>
+<p>Any element of a function or modifier header can be left nameless by using the corresponding special name in that position, instead of an identifier. For example, the header <code><span class='Value'>𝕨</span> <span class='Function'>𝔽</span><span class='Modifier2'>_𝕣_</span><span class='Function'>𝔾</span> <span class='Value'>𝕩</span><span class='Head'>:</span></code> incorporates as much vagueness as possible. It indicates a deferred 2-modifier, but provides no other information.</p>
 <p>The name <code><span class='Value'>𝕨</span></code> in this context can refer to either a left argument or no left argument, allowing a header with arguments to be used even for an ambiguous function. Recall that <code><span class='Value'>𝕨</span></code> is the only token other than <code><span class='Nothing'>·</span></code> that can have no value. If an identifier or list is given as the left argument, then the function must be called with a left argument.</p>
 <h3 id="short-headers"><a class="header" href="#short-headers">Short headers</a></h3>
-<p>A header does not need to include all inputs, as shown by the <code><span class='Function'>F</span> <span class='Modifier2'>_op_</span> <span class='Value'>val:</span></code> header above. The simplest case, when no inputs are given, is called a <em>label</em>. While it doesn't restrict the inputs, a label specifies the type of the block and gives an internal name that can be used to refer to it.</p>
-<pre><span class='Brace'>{</span> <span class='Value'>b:</span>   <span class='Comment'># Block
-</span><span class='Brace'>{</span> <span class='Function'>𝕊</span><span class='Value'>:</span>   <span class='Comment'># Function
-</span><span class='Brace'>{</span> <span class='Modifier'>_𝕣</span><span class='Value'>:</span>  <span class='Comment'># 1-Modifier
-</span><span class='Brace'>{</span> <span class='Modifier2'>_𝕣_</span><span class='Value'>:</span> <span class='Comment'># 2-Modifier
+<p>A header does not need to include all inputs, as shown by the <code><span class='Function'>F</span> <span class='Modifier2'>_op_</span> <span class='Value'>val</span><span class='Head'>:</span></code> header above. The simplest case, when no inputs are given, is called a <em>label</em>. While it doesn't restrict the inputs, a label specifies the type of the block and gives an internal name that can be used to refer to it.</p>
+<pre><span class='Brace'>{</span> <span class='Value'>b</span><span class='Head'>:</span>   <span class='Comment'># Block
+</span><span class='Brace'>{</span> <span class='Function'>𝕊</span><span class='Head'>:</span>   <span class='Comment'># Function
+</span><span class='Brace'>{</span> <span class='Modifier'>_𝕣</span><span class='Head'>:</span>  <span class='Comment'># 1-Modifier
+</span><span class='Brace'>{</span> <span class='Modifier2'>_𝕣_</span><span class='Head'>:</span> <span class='Comment'># 2-Modifier
 </span></pre>
 <p>For immediate blocks, this is the only type of header possible, and it must use an identifier as there is no applicable special name. However, the name can't be used: it doesn't make sense to refer to a value while it is still being computed!</p>
 <h2 id="multiple-bodies"><a class="header" href="#multiple-bodies">Multiple bodies</a></h2>
-<p>Blocks that define functions and deferred modifiers can include more than one body, separated by semicolons <code><span class='Value'>;</span></code>. The body used for a particular evaluation is chosen based on the arguments the the block. One special case applies when there are exactly two bodies either without headers or with labels only: in this case, the first applies when there is one argument and the second when there are two.</p>
-<a class="replLink" title="Open in the REPL" target="_blank" href="https://mlochbaum.github.io/BQN/try.html#code=QW1iaXYg4oaQIHsg4p+oMSzwnZWp4p+pIDsg4p+oMizwnZWoLPCdlanin6kgfQpBbWJpdiAnYScKJ2EnIEFtYml2ICdiJw==">↗️</a><pre>    <span class='Function'>Ambiv</span> <span class='Gets'>←</span> <span class='Brace'>{</span> <span class='Bracket'>⟨</span><span class='Number'>1</span><span class='Separator'>,</span><span class='Value'>𝕩</span><span class='Bracket'>⟩</span> <span class='Value'>;</span> <span class='Bracket'>⟨</span><span class='Number'>2</span><span class='Separator'>,</span><span class='Value'>𝕨</span><span class='Separator'>,</span><span class='Value'>𝕩</span><span class='Bracket'>⟩</span> <span class='Brace'>}</span>
+<p>Blocks that define functions and deferred modifiers can include more than one body, separated by semicolons <code><span class='Head'>;</span></code>. The body used for a particular evaluation is chosen based on the arguments the the block. One special case applies when there are exactly two bodies either without headers or with labels only: in this case, the first applies when there is one argument and the second when there are two.</p>
+<a class="replLink" title="Open in the REPL" target="_blank" href="https://mlochbaum.github.io/BQN/try.html#code=QW1iaXYg4oaQIHsg4p+oMSzwnZWp4p+pIDsg4p+oMizwnZWoLPCdlanin6kgfQpBbWJpdiAnYScKJ2EnIEFtYml2ICdiJw==">↗️</a><pre>    <span class='Function'>Ambiv</span> <span class='Gets'>←</span> <span class='Brace'>{</span> <span class='Bracket'>⟨</span><span class='Number'>1</span><span class='Separator'>,</span><span class='Value'>𝕩</span><span class='Bracket'>⟩</span> <span class='Head'>;</span> <span class='Bracket'>⟨</span><span class='Number'>2</span><span class='Separator'>,</span><span class='Value'>𝕨</span><span class='Separator'>,</span><span class='Value'>𝕩</span><span class='Bracket'>⟩</span> <span class='Brace'>}</span>
     <span class='Function'>Ambiv</span> <span class='String'>'a'</span>
 ⟨ 1 'a' ⟩
     <span class='String'>'a'</span> <span class='Function'>Ambiv</span> <span class='String'>'b'</span>
 ⟨ 2 'a' 'b' ⟩
 </pre>
 <p>Bodies before the last two must have headers that include arguments. When a block that includes this type of header is called, its headers are checked in order for compatibility with the arguments. The first body with a compatible header is used.</p>
-<a class="replLink" title="Open in the REPL" target="_blank" href="https://mlochbaum.github.io/BQN/try.html#code=Q2FzZUFkZCDihpAgeyAy8J2VijM6MOKAvzUgOyAy8J2VivCdlak64p+oMSwyK/Cdlanin6kgOyDwnZWK8J2VqToy4oC/8J2VqSB9CjIgQ2FzZUFkZCAzCjIgQ2FzZUFkZCA0CiAgQ2FzZUFkZCA0">↗️</a><pre>    <span class='Function'>CaseAdd</span> <span class='Gets'>←</span> <span class='Brace'>{</span> <span class='Number'>2</span><span class='Function'>𝕊</span><span class='Number'>3</span><span class='Value'>:</span><span class='Number'>0</span><span class='Ligature'>‿</span><span class='Number'>5</span> <span class='Value'>;</span> <span class='Number'>2</span><span class='Function'>𝕊</span><span class='Value'>𝕩:</span><span class='Bracket'>⟨</span><span class='Number'>1</span><span class='Separator'>,</span><span class='Number'>2</span><span class='Function'>+</span><span class='Value'>𝕩</span><span class='Bracket'>⟩</span> <span class='Value'>;</span> <span class='Function'>𝕊</span><span class='Value'>𝕩:</span><span class='Number'>2</span><span class='Ligature'>‿</span><span class='Value'>𝕩</span> <span class='Brace'>}</span>
+<a class="replLink" title="Open in the REPL" target="_blank" href="https://mlochbaum.github.io/BQN/try.html#code=Q2FzZUFkZCDihpAgeyAy8J2VijM6MOKAvzUgOyAy8J2VivCdlak64p+oMSwyK/Cdlanin6kgOyDwnZWK8J2VqToy4oC/8J2VqSB9CjIgQ2FzZUFkZCAzCjIgQ2FzZUFkZCA0CiAgQ2FzZUFkZCA0">↗️</a><pre>    <span class='Function'>CaseAdd</span> <span class='Gets'>←</span> <span class='Brace'>{</span> <span class='Number'>2</span><span class='Function'>𝕊</span><span class='Number'>3</span><span class='Head'>:</span><span class='Number'>0</span><span class='Ligature'>‿</span><span class='Number'>5</span> <span class='Head'>;</span> <span class='Number'>2</span><span class='Function'>𝕊</span><span class='Value'>𝕩</span><span class='Head'>:</span><span class='Bracket'>⟨</span><span class='Number'>1</span><span class='Separator'>,</span><span class='Number'>2</span><span class='Function'>+</span><span class='Value'>𝕩</span><span class='Bracket'>⟩</span> <span class='Head'>;</span> <span class='Function'>𝕊</span><span class='Value'>𝕩</span><span class='Head'>:</span><span class='Number'>2</span><span class='Ligature'>‿</span><span class='Value'>𝕩</span> <span class='Brace'>}</span>
     <span class='Number'>2</span> <span class='Function'>CaseAdd</span> <span class='Number'>3</span>
 ⟨ 0 5 ⟩
     <span class='Number'>2</span> <span class='Function'>CaseAdd</span> <span class='Number'>4</span>
@@ -206,16 +206,16 @@
 <h3 id="case-headers"><a class="header" href="#case-headers">Case headers</a></h3>
 <p>A special rule allows for convenient case-matching syntax for one-argument functions. In any function header with one argument, the function name can be omitted as long as the argument is <em>not</em> a plain identifier—it must be <code><span class='Value'>𝕩</span></code> or a compound value like a list to distinguish it from an immediate block label.</p>
 <pre><span class='Function'>Test</span> <span class='Gets'>←</span> <span class='Brace'>{</span>
-  <span class='String'>&quot;abc&quot;</span><span class='Value'>:</span> <span class='String'>&quot;string&quot;</span> <span class='Value'>;</span>
-  <span class='Bracket'>⟨</span><span class='Number'>2</span><span class='Separator'>,</span><span class='Value'>b</span><span class='Bracket'>⟩</span><span class='Value'>:</span> <span class='Function'>⌽</span><span class='Value'>𝕩</span>       <span class='Value'>;</span>
-  <span class='Number'>5</span><span class='Value'>:</span>     <span class='String'>&quot;number&quot;</span> <span class='Value'>;</span>
-  <span class='Value'>𝕩:</span>     <span class='String'>&quot;default&quot;</span>
+  <span class='String'>&quot;abc&quot;</span><span class='Head'>:</span> <span class='String'>&quot;string&quot;</span> <span class='Head'>;</span>
+  <span class='Bracket'>⟨</span><span class='Number'>2</span><span class='Separator'>,</span><span class='Value'>b</span><span class='Bracket'>⟩</span><span class='Head'>:</span> <span class='Function'>⌽</span><span class='Value'>𝕩</span>       <span class='Head'>;</span>
+  <span class='Number'>5</span><span class='Head'>:</span>     <span class='String'>&quot;number&quot;</span> <span class='Head'>;</span>
+  <span class='Value'>𝕩</span><span class='Head'>:</span>     <span class='String'>&quot;default&quot;</span>
 <span class='Brace'>}</span>
 </pre>
 <p>These case-style headers function exactly the same as if they were preceded by <code><span class='Function'>𝕊</span></code>, and can be mixed with other kinds of headers.</p>
 <h3 id="predicates"><a class="header" href="#predicates">Predicates</a></h3>
-<p>Destructuring with a header is quite limited, only allowing matching structure and data with exact equality. A predicate, written with <code><span class='Value'>?</span></code>, allows you to test an arbitrary property before evaluating the rest of the body, and also serves as a limited kind of control flow. It can be thought of as an extension to a header, so that for example the following function requires the argument to have two elements and for the first to be less than the second before using the first body. Otherwise it moves to the next body, which is unconditional.</p>
-<a class="replLink" title="Open in the REPL" target="_blank" href="https://mlochbaum.github.io/BQN/try.html#code=Q2hlY2tQYWlyIOKGkCB7IPCdlYrin6hhLGLin6k6IGE8Yj8gIm9rIiA7ICJub3Qgb2siIH0KCkNoZWNrUGFpciDin6gzLDjin6kgICAgIyBGYWlscyBkZXN0cnVjdHVyaW5nCkNoZWNrUGFpciDin6gxLDQsNeKfqSAgIyBOb3QgYSBwYWlyCkNoZWNrUGFpciDin6gzLMKvMeKfqSAgICMgTm90IGFzY2VuZGluZw==">↗️</a><pre>    <span class='Function'>CheckPair</span> <span class='Gets'>←</span> <span class='Brace'>{</span> <span class='Function'>𝕊</span><span class='Bracket'>⟨</span><span class='Value'>a</span><span class='Separator'>,</span><span class='Value'>b</span><span class='Bracket'>⟩</span><span class='Value'>:</span> <span class='Value'>a</span><span class='Function'>&lt;</span><span class='Value'>b?</span> <span class='String'>&quot;ok&quot;</span> <span class='Value'>;</span> <span class='String'>&quot;not ok&quot;</span> <span class='Brace'>}</span>
+<p>Destructuring with a header is quite limited, only allowing matching structure and data with exact equality. A predicate, written with <code><span class='Head'>?</span></code>, allows you to test an arbitrary property before evaluating the rest of the body, and also serves as a limited kind of control flow. It can be thought of as an extension to a header, so that for example the following function requires the argument to have two elements and for the first to be less than the second before using the first body. Otherwise it moves to the next body, which is unconditional.</p>
+<a class="replLink" title="Open in the REPL" target="_blank" href="https://mlochbaum.github.io/BQN/try.html#code=Q2hlY2tQYWlyIOKGkCB7IPCdlYrin6hhLGLin6k6IGE8Yj8gIm9rIiA7ICJub3Qgb2siIH0KCkNoZWNrUGFpciDin6gzLDjin6kgICAgIyBGYWlscyBkZXN0cnVjdHVyaW5nCkNoZWNrUGFpciDin6gxLDQsNeKfqSAgIyBOb3QgYSBwYWlyCkNoZWNrUGFpciDin6gzLMKvMeKfqSAgICMgTm90IGFzY2VuZGluZw==">↗️</a><pre>    <span class='Function'>CheckPair</span> <span class='Gets'>←</span> <span class='Brace'>{</span> <span class='Function'>𝕊</span><span class='Bracket'>⟨</span><span class='Value'>a</span><span class='Separator'>,</span><span class='Value'>b</span><span class='Bracket'>⟩</span><span class='Head'>:</span> <span class='Value'>a</span><span class='Function'>&lt;</span><span class='Value'>b</span><span class='Head'>?</span> <span class='String'>&quot;ok&quot;</span> <span class='Head'>;</span> <span class='String'>&quot;not ok&quot;</span> <span class='Brace'>}</span>
 
     <span class='Function'>CheckPair</span> <span class='Bracket'>⟨</span><span class='Number'>3</span><span class='Separator'>,</span><span class='Number'>8</span><span class='Bracket'>⟩</span>    <span class='Comment'># Fails destructuring
 </span>"ok"
@@ -224,12 +224,12 @@
     <span class='Function'>CheckPair</span> <span class='Bracket'>⟨</span><span class='Number'>3</span><span class='Separator'>,</span><span class='Number'>¯1</span><span class='Bracket'>⟩</span>   <span class='Comment'># Not ascending
 </span>"not ok"
 </pre>
-<p>The body where the predicate appears doesn't need to start with a header, and there can be other statements before it. In fact, <code><span class='Value'>?</span></code> functions just like a separator (like <code><span class='Separator'>⋄</span></code> or <code><span class='Separator'>,</span></code>) with a side effect.</p>
-<a class="replLink" title="Open in the REPL" target="_blank" href="https://mlochbaum.github.io/BQN/try.html#code=eyBy4oaQ4oy98J2VqSDii4QgJ3QnPeKKkXIgPyByIDsg8J2VqSB9wqggInRlc3Qi4oC/InRoaXMi">↗️</a><pre>    <span class='Brace'>{</span> <span class='Value'>r</span><span class='Gets'>←</span><span class='Function'>⌽</span><span class='Value'>𝕩</span> <span class='Separator'>⋄</span> <span class='String'>'t'</span><span class='Function'>=⊑</span><span class='Value'>r</span> <span class='Value'>?</span> <span class='Value'>r</span> <span class='Value'>;</span> <span class='Value'>𝕩</span> <span class='Brace'>}</span><span class='Modifier'>¨</span> <span class='String'>&quot;test&quot;</span><span class='Ligature'>‿</span><span class='String'>&quot;this&quot;</span>
+<p>The body where the predicate appears doesn't need to start with a header, and there can be other statements before it. In fact, <code><span class='Head'>?</span></code> functions just like a separator (like <code><span class='Separator'>⋄</span></code> or <code><span class='Separator'>,</span></code>) with a side effect.</p>
+<a class="replLink" title="Open in the REPL" target="_blank" href="https://mlochbaum.github.io/BQN/try.html#code=eyBy4oaQ4oy98J2VqSDii4QgJ3QnPeKKkXIgPyByIDsg8J2VqSB9wqggInRlc3Qi4oC/InRoaXMi">↗️</a><pre>    <span class='Brace'>{</span> <span class='Value'>r</span><span class='Gets'>←</span><span class='Function'>⌽</span><span class='Value'>𝕩</span> <span class='Separator'>⋄</span> <span class='String'>'t'</span><span class='Function'>=⊑</span><span class='Value'>r</span> <span class='Head'>?</span> <span class='Value'>r</span> <span class='Head'>;</span> <span class='Value'>𝕩</span> <span class='Brace'>}</span><span class='Modifier'>¨</span> <span class='String'>&quot;test&quot;</span><span class='Ligature'>‿</span><span class='String'>&quot;this&quot;</span>
 ⟨ "tset" "this" ⟩
 </pre>
-<p>So <code><span class='Value'>r</span></code> is the reversed argument, and if its first character (the last one in <code><span class='Value'>𝕩</span></code>) is <code><span class='String'>'t'</span></code> then it returns <code><span class='Value'>r</span></code>, and otherwise we abandon that line of reasoning and return <code><span class='Value'>𝕩</span></code>. This sounds a lot like an if statement. And <code><span class='Brace'>{</span> <span class='Value'>a</span><span class='Function'>&lt;</span><span class='Value'>b</span> <span class='Value'>?</span> <span class='Value'>a</span> <span class='Value'>;</span> <span class='Value'>b</span> <span class='Brace'>}</span></code>, which computes <code><span class='Value'>a</span><span class='Function'>⌊</span><span class='Value'>b</span></code> the hard way, shows how the syntax can be similar to a ternary operator. This is an immediate block with multiple bodies, something that makes sense with predicates but not headers. But <code><span class='Value'>?;</span></code> offers more possibilities. It can support any number of options, with multiple tests for each one—the structure below is &quot;if _ and _ then _; else if _ then _; else _&quot;.</p>
-<a class="replLink" title="Open in the REPL" target="_blank" href="https://mlochbaum.github.io/BQN/try.html#code=VGhpbmcg4oaQIHsg8J2VqeKJpTM/IPCdlaniiaQ4PyAyfPCdlakgOyDwnZWpPTA/IEAgOyDiiJ4gfQoKKOKKoiDiiY0gVGhpbmfCqCkg4oaVMTAgICMgVGFibGUgb2YgYXJndW1lbnRzIGFuZCByZXN1bHRz">↗️</a><pre>    <span class='Function'>Thing</span> <span class='Gets'>←</span> <span class='Brace'>{</span> <span class='Value'>𝕩</span><span class='Function'>≥</span><span class='Number'>3</span><span class='Value'>?</span> <span class='Value'>𝕩</span><span class='Function'>≤</span><span class='Number'>8</span><span class='Value'>?</span> <span class='Number'>2</span><span class='Function'>|</span><span class='Value'>𝕩</span> <span class='Value'>;</span> <span class='Value'>𝕩</span><span class='Function'>=</span><span class='Number'>0</span><span class='Value'>?</span> <span class='String'>@</span> <span class='Value'>;</span> <span class='Number'>∞</span> <span class='Brace'>}</span>
+<p>So <code><span class='Value'>r</span></code> is the reversed argument, and if its first character (the last one in <code><span class='Value'>𝕩</span></code>) is <code><span class='String'>'t'</span></code> then it returns <code><span class='Value'>r</span></code>, and otherwise we abandon that line of reasoning and return <code><span class='Value'>𝕩</span></code>. This sounds a lot like an if statement. And <code><span class='Brace'>{</span> <span class='Value'>a</span><span class='Function'>&lt;</span><span class='Value'>b</span> <span class='Head'>?</span> <span class='Value'>a</span> <span class='Head'>;</span> <span class='Value'>b</span> <span class='Brace'>}</span></code>, which computes <code><span class='Value'>a</span><span class='Function'>⌊</span><span class='Value'>b</span></code> the hard way, shows how the syntax can be similar to a ternary operator. This is an immediate block with multiple bodies, something that makes sense with predicates but not headers. But <code><span class='Head'>?;</span></code> offers more possibilities. It can support any number of options, with multiple tests for each one—the structure below is &quot;if _ and _ then _; else if _ then _; else _&quot;.</p>
+<a class="replLink" title="Open in the REPL" target="_blank" href="https://mlochbaum.github.io/BQN/try.html#code=VGhpbmcg4oaQIHsg8J2VqeKJpTM/IPCdlaniiaQ4PyAyfPCdlakgOyDwnZWpPTA/IEAgOyDiiJ4gfQoKKOKKoiDiiY0gVGhpbmfCqCkg4oaVMTAgICMgVGFibGUgb2YgYXJndW1lbnRzIGFuZCByZXN1bHRz">↗️</a><pre>    <span class='Function'>Thing</span> <span class='Gets'>←</span> <span class='Brace'>{</span> <span class='Value'>𝕩</span><span class='Function'>≥</span><span class='Number'>3</span><span class='Head'>?</span> <span class='Value'>𝕩</span><span class='Function'>≤</span><span class='Number'>8</span><span class='Head'>?</span> <span class='Number'>2</span><span class='Function'>|</span><span class='Value'>𝕩</span> <span class='Head'>;</span> <span class='Value'>𝕩</span><span class='Function'>=</span><span class='Number'>0</span><span class='Head'>?</span> <span class='String'>@</span> <span class='Head'>;</span> <span class='Number'>∞</span> <span class='Brace'>}</span>
 
     <span class='Paren'>(</span><span class='Function'>⊢</span> <span class='Function'>≍</span> <span class='Function'>Thing</span><span class='Modifier'>¨</span><span class='Paren'>)</span> <span class='Function'>↕</span><span class='Number'>10</span>  <span class='Comment'># Table of arguments and results
 </span>┌─                     
@@ -237,8 +237,8 @@
   @ ∞ ∞ 1 0 1 0 1 0 ∞  
                       ┘
 </pre>
-<p>This structure is still constrained by the rules of block bodies: each instance of <code><span class='Value'>;</span></code> is a separate scope, so that variables defined before a <code><span class='Value'>?</span></code> don't survive past the <code><span class='Value'>;</span></code>.</p>
-<a class="replLink" title="Open in the REPL" target="_blank" href="https://mlochbaum.github.io/BQN/try.html#code=eyAwPW7ihpDiiaDwnZWpID8g4oieIDsgbiB9ICJhYmMi">↗️</a><pre>    <span class='Brace'>{</span> <span class='Number'>0</span><span class='Function'>=</span><span class='Value'>n</span><span class='Gets'>←</span><span class='Function'>≠</span><span class='Value'>𝕩</span> <span class='Value'>?</span> <span class='Number'>∞</span> <span class='Value'>;</span> <span class='Value'>n</span> <span class='Brace'>}</span> <span class='String'>&quot;abc&quot;</span>
+<p>This structure is still constrained by the rules of block bodies: each instance of <code><span class='Head'>;</span></code> is a separate scope, so that variables defined before a <code><span class='Head'>?</span></code> don't survive past the <code><span class='Head'>;</span></code>.</p>
+<a class="replLink" title="Open in the REPL" target="_blank" href="https://mlochbaum.github.io/BQN/try.html#code=eyAwPW7ihpDiiaDwnZWpID8g4oieIDsgbiB9ICJhYmMi">↗️</a><pre>    <span class='Brace'>{</span> <span class='Number'>0</span><span class='Function'>=</span><span class='Value'>n</span><span class='Gets'>←</span><span class='Function'>≠</span><span class='Value'>𝕩</span> <span class='Head'>?</span> <span class='Number'>∞</span> <span class='Head'>;</span> <span class='Value'>n</span> <span class='Brace'>}</span> <span class='String'>&quot;abc&quot;</span>
 <span class='Error'>Error: Undefined identifier</span>
 </pre>
-<p>This is the main drawback of predicates relative to guards in APL dfns (also written with <code><span class='Value'>?</span></code>), while the advantage is that it allows multiple expressions, or extra conditions, after a <code><span class='Value'>?</span></code>. It's not how I would have designed it if I just wanted to make a syntax for if statements, but it's a natural fit for the header system.</p>
+<p>This is the main drawback of predicates relative to guards in APL dfns (also written with <code><span class='Head'>?</span></code>), while the advantage is that it allows multiple expressions, or extra conditions, after a <code><span class='Head'>?</span></code>. It's not how I would have designed it if I just wanted to make a syntax for if statements, but it's a natural fit for the header system.</p>
diff --git a/docs/doc/control.html b/docs/doc/control.html
index 5abfa166..b4426630 100644
--- a/docs/doc/control.html
+++ b/docs/doc/control.html
@@ -10,26 +10,26 @@
 <p>The surfeit of ways to write control structures could be a bit of an issue for reading BQN. My hope is that the community can eventually settle on a smaller set of standard forms to recommend so that you won't have to recognize all the variants given here. On the other hand, the cost of using specialized control structures is lower in a large project without too many contributors. In this case BQN's flexibility allows developers to adapt to the project's particular demands (for example, some programs use switch/case statements heavily but most do not).</p>
 <p>The useful control structures introduced here are collected as shortened definitions below. <code><span class='Function'>While</span></code> uses the slightly more complicated implementation that avoids stack overflow, and <code><span class='Function'>DoWhile</span></code> and <code><span class='Function'>For</span></code> are written in terms of it in order to share this property. The more direct versions with linear stack use appear in the main text.</p>
 <pre><span class='Function'>If</span>      <span class='Gets'>←</span> <span class='Brace'>{</span><span class='Function'>𝕏</span><span class='Modifier2'>⍟</span><span class='Function'>𝕎</span><span class='String'>@</span><span class='Brace'>}</span><span class='Modifier'>´</span>                 <span class='Comment'># Also Repeat
-</span><span class='Function'>IfElse</span>  <span class='Gets'>←</span> <span class='Brace'>{</span><span class='Value'>c</span><span class='Ligature'>‿</span><span class='Function'>T</span><span class='Ligature'>‿</span><span class='Function'>F</span><span class='Value'>:</span> <span class='Value'>c</span><span class='Modifier2'>◶</span><span class='Function'>F</span><span class='Ligature'>‿</span><span class='Function'>T</span><span class='String'>@</span><span class='Brace'>}</span>
+</span><span class='Function'>IfElse</span>  <span class='Gets'>←</span> <span class='Brace'>{</span><span class='Value'>c</span><span class='Ligature'>‿</span><span class='Function'>T</span><span class='Ligature'>‿</span><span class='Function'>F</span><span class='Head'>:</span> <span class='Value'>c</span><span class='Modifier2'>◶</span><span class='Function'>F</span><span class='Ligature'>‿</span><span class='Function'>T</span><span class='String'>@</span><span class='Brace'>}</span>
 <span class='Function'>While</span>   <span class='Gets'>←</span> <span class='Brace'>{</span><span class='Value'>𝕩</span><span class='Brace'>{</span><span class='Function'>𝔽</span><span class='Modifier2'>⍟</span><span class='Function'>𝔾</span><span class='Modifier2'>∘</span><span class='Function'>𝔽</span><span class='Modifier2'>_𝕣_</span><span class='Function'>𝔾</span><span class='Modifier2'>∘</span><span class='Function'>𝔽</span><span class='Modifier2'>⍟</span><span class='Function'>𝔾</span><span class='Value'>𝕩</span><span class='Brace'>}</span><span class='Value'>𝕨</span><span class='String'>@</span><span class='Brace'>}</span><span class='Modifier'>´</span>  <span class='Comment'># While 1‿{... to run forever
 </span><span class='Function'>DoWhile</span> <span class='Gets'>←</span> <span class='Brace'>{</span><span class='Function'>𝕏</span><span class='String'>@</span> <span class='Separator'>⋄</span> <span class='Function'>While</span> <span class='Value'>𝕨</span><span class='Ligature'>‿</span><span class='Value'>𝕩</span><span class='Brace'>}</span><span class='Modifier'>´</span>
-<span class='Function'>For</span>     <span class='Gets'>←</span> <span class='Brace'>{</span><span class='Function'>I</span><span class='Ligature'>‿</span><span class='Function'>C</span><span class='Ligature'>‿</span><span class='Function'>P</span><span class='Ligature'>‿</span><span class='Function'>A</span><span class='Value'>:</span> <span class='Function'>I</span><span class='String'>@</span> <span class='Separator'>⋄</span> <span class='Function'>While</span><span class='Bracket'>⟨</span><span class='Function'>C</span><span class='Separator'>,</span><span class='Function'>P</span><span class='Modifier2'>∘</span><span class='Function'>A</span><span class='Bracket'>⟩</span><span class='Brace'>}</span>
+<span class='Function'>For</span>     <span class='Gets'>←</span> <span class='Brace'>{</span><span class='Function'>I</span><span class='Ligature'>‿</span><span class='Function'>C</span><span class='Ligature'>‿</span><span class='Function'>P</span><span class='Ligature'>‿</span><span class='Function'>A</span><span class='Head'>:</span> <span class='Function'>I</span><span class='String'>@</span> <span class='Separator'>⋄</span> <span class='Function'>While</span><span class='Bracket'>⟨</span><span class='Function'>C</span><span class='Separator'>,</span><span class='Function'>P</span><span class='Modifier2'>∘</span><span class='Function'>A</span><span class='Bracket'>⟩</span><span class='Brace'>}</span>
 
 <span class='Comment'># Switch/case statements have many variations; these are a few
 </span><span class='Function'>Match</span>   <span class='Gets'>←</span> <span class='Brace'>{</span><span class='Function'>𝕏</span><span class='Value'>𝕨</span><span class='Brace'>}</span><span class='Modifier'>´</span>
 <span class='Function'>Select</span>  <span class='Gets'>←</span> <span class='Brace'>{</span><span class='Paren'>(</span><span class='Function'>⊑</span><span class='Value'>𝕩</span><span class='Paren'>)</span><span class='Modifier2'>◶</span><span class='Paren'>(</span><span class='Number'>1</span><span class='Function'>↓</span><span class='Value'>𝕩</span><span class='Paren'>)</span><span class='String'>@</span><span class='Brace'>}</span>
 <span class='Function'>Switch</span>  <span class='Gets'>←</span> <span class='Brace'>{</span><span class='Value'>c</span><span class='Gets'>←</span><span class='Function'>⊑</span><span class='Value'>𝕩</span> <span class='Separator'>⋄</span> <span class='Value'>m</span><span class='Ligature'>‿</span><span class='Value'>a</span><span class='Gets'>←</span><span class='Function'>&lt;</span><span class='Modifier'>˘</span><span class='Function'>⍉</span><span class='Modifier2'>∘</span><span class='Ligature'>‿</span><span class='Number'>2</span><span class='Function'>⥊</span><span class='Number'>1</span><span class='Function'>↓</span><span class='Value'>𝕩</span> <span class='Separator'>⋄</span> <span class='Paren'>(</span><span class='Function'>⊑</span><span class='Value'>a</span><span class='Function'>⊐C</span><span class='Paren'>)</span><span class='Modifier2'>◶</span><span class='Value'>m</span><span class='String'>@</span><span class='Brace'>}</span>
-<span class='Function'>Test</span>    <span class='Gets'>←</span> <span class='Brace'>{</span><span class='Value'>fn</span><span class='Gets'>←</span><span class='Brace'>{</span><span class='Function'>C</span><span class='Ligature'>‿</span><span class='Function'>A𝕊</span><span class='Value'>e:</span><span class='Function'>C</span><span class='Modifier2'>◶</span><span class='Function'>A</span><span class='Ligature'>‿</span><span class='Function'>E</span><span class='Brace'>}</span><span class='Modifier'>´</span><span class='Value'>𝕩</span><span class='Separator'>⋄</span><span class='Function'>Fn</span><span class='String'>@</span><span class='Brace'>}</span>
+<span class='Function'>Test</span>    <span class='Gets'>←</span> <span class='Brace'>{</span><span class='Value'>fn</span><span class='Gets'>←</span><span class='Brace'>{</span><span class='Function'>C</span><span class='Ligature'>‿</span><span class='Function'>A𝕊</span><span class='Value'>e</span><span class='Head'>:</span><span class='Function'>C</span><span class='Modifier2'>◶</span><span class='Function'>A</span><span class='Ligature'>‿</span><span class='Function'>E</span><span class='Brace'>}</span><span class='Modifier'>´</span><span class='Value'>𝕩</span><span class='Separator'>⋄</span><span class='Function'>Fn</span><span class='String'>@</span><span class='Brace'>}</span>
 </pre>
 <h2 id="blocks-and-functions"><a class="header" href="#blocks-and-functions">Blocks and functions</a></h2>
 <p>Control structures are generally defined to work with blocks of code, which they might skip, or execute one or more times. This might sound like a BQN immediate block, which also consists of a sequence of code to execute, but immediate blocks are always executed as soon as they are encountered and can't be manipulated the way that blocks in imperative languages can. They're intended to be used with <a href="lexical.html">lexical scoping</a> as a tool for encapsulation. Instead, the main tool we will use to get control structures is the block function.</p>
 <p>Using functions as blocks is a little outside their intended purpose, and the fact that they have to be passed an argument and are expected to use it will be a minor annoyance. The following conventions signal a function that ignores its argument and is called purely for the side effects:</p>
 <ul>
 <li>Pass <code><span class='String'>@</span></code> to a function that ignores its argument. It's a nice signal that nothing is happening and is easy to type.</li>
-<li>A headerless function that doesn't use an argument will be interpreted as an immediate block by default. Start it with the line <code><span class='Value'>𝕤</span></code> to avoid this (it's an instruction to navel gaze: the function contemplates its self, but does nothing about it). Other options like <code><span class='Function'>𝕊</span><span class='Value'>:</span></code>, <code><span class='Function'>F</span><span class='Value'>:</span></code>, or <code><span class='Value'>𝕩</span></code> also work, but are more visually distracting.</li>
+<li>A headerless function that doesn't use an argument will be interpreted as an immediate block by default. Start it with the line <code><span class='Value'>𝕤</span></code> to avoid this (it's an instruction to navel gaze: the function contemplates its self, but does nothing about it). Other options like <code><span class='Function'>𝕊</span><span class='Head'>:</span></code>, <code><span class='Function'>F</span><span class='Head'>:</span></code>, or <code><span class='Value'>𝕩</span></code> also work, but are more visually distracting.</li>
 </ul>
 <p>Even with these workarounds, BQN's &quot;niladic&quot; function syntax is quite lightweight, comparing favorably to a low-boilerplate language like Javascript.</p>
-<pre><span class='Value'>fn</span> <span class='Function'>=</span> <span class='Paren'>()</span><span class='Function'>=&gt;</span><span class='Brace'>{</span><span class='Value'>m</span><span class='Function'>+=</span><span class='Number'>1</span><span class='Value'>;n*</span><span class='Function'>=</span><span class='Number'>2</span><span class='Brace'>}</span><span class='Value'>;</span> <span class='Value'>fn</span><span class='Paren'>()</span>
+<pre><span class='Value'>fn</span> <span class='Function'>=</span> <span class='Paren'>()</span><span class='Function'>=&gt;</span><span class='Brace'>{</span><span class='Value'>m</span><span class='Function'>+=</span><span class='Number'>1</span><span class='Head'>;</span><span class='Value'>n*</span><span class='Function'>=</span><span class='Number'>2</span><span class='Brace'>}</span><span class='Head'>;</span> <span class='Value'>fn</span><span class='Paren'>()</span>
 <span class='Function'>Fn</span> <span class='Gets'>←</span> <span class='Brace'>{</span><span class='Value'>𝕤</span><span class='Separator'>⋄</span>  <span class='Value'>m</span><span class='Function'>+</span><span class='Gets'>↩</span><span class='Number'>1</span><span class='Separator'>,</span><span class='Value'>n</span><span class='Function'>×</span><span class='Gets'>↩</span><span class='Number'>2</span><span class='Brace'>}</span><span class='Separator'>,</span> <span class='Function'>Fn</span> <span class='String'>@</span>
 </pre>
 <p>Control structures are called &quot;statements&quot; below to match common usage, but they are actually expressions, and return a value that might be used later.</p>
@@ -49,7 +49,7 @@
 </pre>
 <p>The result of any of these if statements is the result of the action if it's performed, and otherwise it's whatever argument was passed to the statement, which is <code><span class='String'>@</span></code> or <code><span class='Number'>10</span></code> here.</p>
 <p>BQN's syntax for a pure if statement isn't so good, but predicates handle <a href="#if-else">if-else</a> statements nicely. So in most cases you'd forego the definitions above in favor of an if-else with nothing in the else branch:</p>
-<pre><span class='Brace'>{</span> <span class='Value'>a</span><span class='Function'>&lt;</span><span class='Number'>10</span> <span class='Value'>?</span> <span class='Value'>a</span><span class='Function'>+</span><span class='Gets'>↩</span><span class='Number'>10</span> <span class='Value'>;</span> <span class='String'>@</span> <span class='Brace'>}</span>
+<pre><span class='Brace'>{</span> <span class='Value'>a</span><span class='Function'>&lt;</span><span class='Number'>10</span> <span class='Head'>?</span> <span class='Value'>a</span><span class='Function'>+</span><span class='Gets'>↩</span><span class='Number'>10</span> <span class='Head'>;</span> <span class='String'>@</span> <span class='Brace'>}</span>
 </pre>
 <h2 id="repeat"><a class="header" href="#repeat">Repeat</a></h2>
 <p>There's no reason the condition in an if statement from the previous section has to be boolean: it could be any natural number, causing the action to be repeated that many times. If the action is never performed, the result is the statement's argument, and otherwise it's the result of the last time the action was performed.</p>
@@ -57,14 +57,14 @@
 <h2 id="if-else"><a class="header" href="#if-else">If-Else</a></h2>
 <p>In most cases, the easy way to write an if-else statement is with <a href="block.html#predicates">predicates</a>:</p>
 <pre><span class='Brace'>{</span>
-  <span class='Value'>threshold</span> <span class='Function'>&lt;</span> <span class='Number'>6</span> <span class='Value'>?</span>
-  <span class='Value'>a</span> <span class='Gets'>↩</span> <span class='Function'>Small</span> <span class='Value'>threshold</span> <span class='Value'>;</span>  <span class='Comment'># If predicate was true
+  <span class='Value'>threshold</span> <span class='Function'>&lt;</span> <span class='Number'>6</span> <span class='Head'>?</span>
+  <span class='Value'>a</span> <span class='Gets'>↩</span> <span class='Function'>Small</span> <span class='Value'>threshold</span> <span class='Head'>;</span>  <span class='Comment'># If predicate was true
 </span>  <span class='Value'>b</span> <span class='Gets'>↩</span> <span class='Number'>1</span> <span class='Function'>Large</span> <span class='Value'>threshold</span>  <span class='Comment'># If it wasn't
 </span><span class='Brace'>}</span>
 </pre>
 <p>We might also think of an if-else statement as a kind of <a href="#switch-case">switch-case</a> statement, where the two cases are true (<code><span class='Number'>1</span></code>) and false (<code><span class='Number'>0</span></code>). As a result, we can implement it either with Choose (<code><span class='Modifier2'>◶</span></code>) or with <a href="block.html#case-headers">case headers</a> of <code><span class='Number'>1</span></code> and <code><span class='Number'>0</span></code>.</p>
 <p>When using Choose, note that the natural ordering places the false case before the true one to match list index ordering. To get the typical if-else order, the condition should be negated or the statements reversed. Here's a function to get an if-else statement by swapping the conditions, and two ways its application might be written.</p>
-<pre><span class='Function'>IfElse</span> <span class='Gets'>←</span> <span class='Brace'>{</span><span class='Value'>cond</span><span class='Ligature'>‿</span><span class='Function'>True</span><span class='Ligature'>‿</span><span class='Function'>False</span><span class='Value'>:</span> <span class='Value'>cond</span><span class='Modifier2'>◶</span><span class='Function'>False</span><span class='Ligature'>‿</span><span class='Function'>True</span> <span class='String'>@</span><span class='Brace'>}</span>
+<pre><span class='Function'>IfElse</span> <span class='Gets'>←</span> <span class='Brace'>{</span><span class='Value'>cond</span><span class='Ligature'>‿</span><span class='Function'>True</span><span class='Ligature'>‿</span><span class='Function'>False</span><span class='Head'>:</span> <span class='Value'>cond</span><span class='Modifier2'>◶</span><span class='Function'>False</span><span class='Ligature'>‿</span><span class='Function'>True</span> <span class='String'>@</span><span class='Brace'>}</span>
 
 <span class='Function'>IfElse</span> <span class='Bracket'>⟨</span><span class='Value'>𝕩</span><span class='Function'>&lt;</span><span class='Value'>mid</span><span class='Function'>⊑</span><span class='Value'>𝕨</span>
   <span class='Brace'>{</span><span class='Value'>𝕤</span><span class='Separator'>⋄</span> <span class='Value'>hi</span><span class='Gets'>↩</span><span class='Value'>mid</span><span class='Brace'>}</span>
@@ -79,22 +79,22 @@
 </pre>
 <p>Case headers have similar syntax, but the two cases are labelled explicitly. In this form, the two actions are combined in a single function, which could be assigned to call it on various conditions.</p>
 <pre><span class='Brace'>{</span><span class='Function'>𝕏</span><span class='Value'>𝕨</span><span class='Brace'>}</span><span class='Modifier'>´</span> <span class='Paren'>(</span><span class='Value'>𝕩</span><span class='Function'>&lt;</span><span class='Value'>mid</span><span class='Function'>⊑</span><span class='Value'>𝕨</span><span class='Paren'>)</span><span class='Ligature'>‿</span><span class='Brace'>{</span>
-  <span class='Number'>1</span><span class='Value'>:</span> <span class='Value'>hi</span><span class='Gets'>↩</span><span class='Value'>mid</span>
-<span class='Value'>;</span>
-  <span class='Number'>0</span><span class='Value'>:</span> <span class='Value'>lo</span><span class='Gets'>↩</span><span class='Value'>mid</span>
+  <span class='Number'>1</span><span class='Head'>:</span> <span class='Value'>hi</span><span class='Gets'>↩</span><span class='Value'>mid</span>
+<span class='Head'>;</span>
+  <span class='Number'>0</span><span class='Head'>:</span> <span class='Value'>lo</span><span class='Gets'>↩</span><span class='Value'>mid</span>
 <span class='Brace'>}</span>
 </pre>
 <p>The result of an if-else statement is just the result of whichever branch was used; chained if-else and switch-case statements will work the same way.</p>
 <h3 id="chained-if-else"><a class="header" href="#chained-if-else">Chained If-Else</a></h3>
 <p>One pattern in imperative languages is to check one condition and apply an action if it succeeds, but check a different condition if it fails, in sequence until some condition succeeds or every one has been checked. Languages might make this pattern easier by making if-else right associative, so that the programmer can write an <code><span class='Value'>if</span></code> statement followed by a sequence of <code><span class='Value'>else</span> <span class='Value'>if</span></code> &quot;statements&quot;, or might just provide a unified <code><span class='Value'>elif</span></code> keyword that works similarly. BQN's predicates work really well for this structure:</p>
 <pre><span class='Brace'>{</span>
-  <span class='Value'>a</span><span class='Function'>&lt;</span><span class='Value'>b</span> <span class='Value'>?</span> <span class='Value'>a</span><span class='Function'>+</span><span class='Gets'>↩</span><span class='Number'>1</span> <span class='Value'>;</span>
-  <span class='Value'>a</span><span class='Function'>&lt;</span><span class='Value'>c</span> <span class='Value'>?</span> <span class='Value'>c</span><span class='Function'>-</span><span class='Gets'>↩</span><span class='Number'>1</span> <span class='Value'>;</span>
+  <span class='Value'>a</span><span class='Function'>&lt;</span><span class='Value'>b</span> <span class='Head'>?</span> <span class='Value'>a</span><span class='Function'>+</span><span class='Gets'>↩</span><span class='Number'>1</span> <span class='Head'>;</span>
+  <span class='Value'>a</span><span class='Function'>&lt;</span><span class='Value'>c</span> <span class='Head'>?</span> <span class='Value'>c</span><span class='Function'>-</span><span class='Gets'>↩</span><span class='Number'>1</span> <span class='Head'>;</span>
         <span class='Value'>a</span><span class='Function'>-</span><span class='Gets'>↩</span><span class='Number'>2</span>
 <span class='Brace'>}</span>
 </pre>
 <p>For a function-based approach, it's possible to nest <code><span class='Function'>IfElse</span></code> expressions, but it's also possible to write a control structure that chains them all at one level. For this statement the input will be a sequence of <code><span class='Bracket'>⟨</span><span class='Function'>Test</span><span class='Separator'>,</span><span class='Function'>Action</span><span class='Bracket'>⟩</span></code> pairs, followed by a final action to perform if no test succeeds. The first test is always performed; other tests should be wrapped in blocks because otherwise they'll be executed even if an earlier test succeeded.</p>
-<pre><span class='Function'>Test</span> <span class='Gets'>←</span> <span class='Brace'>{</span><span class='Value'>fn</span><span class='Gets'>←</span><span class='Brace'>{</span><span class='Function'>Cond</span><span class='Ligature'>‿</span><span class='Function'>Act</span> <span class='Function'>𝕊</span> <span class='Value'>else:</span> <span class='Function'>Cond</span><span class='Modifier2'>◶</span><span class='Function'>Else</span><span class='Ligature'>‿</span><span class='Function'>Act</span><span class='Brace'>}</span><span class='Modifier'>´</span><span class='Value'>𝕩</span> <span class='Separator'>⋄</span> <span class='Function'>Fn</span><span class='String'>@</span><span class='Brace'>}</span>
+<pre><span class='Function'>Test</span> <span class='Gets'>←</span> <span class='Brace'>{</span><span class='Value'>fn</span><span class='Gets'>←</span><span class='Brace'>{</span><span class='Function'>Cond</span><span class='Ligature'>‿</span><span class='Function'>Act</span> <span class='Function'>𝕊</span> <span class='Value'>else</span><span class='Head'>:</span> <span class='Function'>Cond</span><span class='Modifier2'>◶</span><span class='Function'>Else</span><span class='Ligature'>‿</span><span class='Function'>Act</span><span class='Brace'>}</span><span class='Modifier'>´</span><span class='Value'>𝕩</span> <span class='Separator'>⋄</span> <span class='Function'>Fn</span><span class='String'>@</span><span class='Brace'>}</span>
 
 <span class='Function'>Test</span> <span class='Bracket'>⟨</span>
   <span class='Paren'>(</span>  <span class='Value'>a</span><span class='Function'>&lt;</span><span class='Value'>b</span><span class='Paren'>)</span><span class='Ligature'>‿</span><span class='Brace'>{</span><span class='Value'>𝕤</span><span class='Separator'>⋄</span><span class='Value'>a</span><span class='Function'>+</span><span class='Gets'>↩</span><span class='Number'>1</span><span class='Brace'>}</span>
@@ -107,11 +107,11 @@
 <pre><span class='Function'>Match</span> <span class='Gets'>←</span> <span class='Brace'>{</span><span class='Function'>𝕏</span><span class='Value'>𝕨</span><span class='Brace'>}</span><span class='Modifier'>´</span>
 
 <span class='Function'>Match</span> <span class='Value'>value</span><span class='Ligature'>‿</span><span class='Brace'>{</span>
-  <span class='Number'>0</span><span class='Ligature'>‿</span><span class='Value'>b:</span> <span class='Value'>n</span><span class='Function'>-</span><span class='Gets'>↩</span><span class='Value'>b</span>
-<span class='Value'>;</span>
-  <span class='Value'>a</span><span class='Ligature'>‿</span><span class='Value'>b:</span> <span class='Value'>n</span><span class='Function'>+</span><span class='Gets'>↩</span><span class='Value'>a</span><span class='Function'>-</span><span class='Value'>b</span>
-<span class='Value'>;</span>
-  <span class='Value'>𝕩:</span> <span class='Value'>n</span><span class='Function'>∾</span><span class='Gets'>↩</span><span class='Value'>𝕩</span>
+  <span class='Number'>0</span><span class='Ligature'>‿</span><span class='Value'>b</span><span class='Head'>:</span> <span class='Value'>n</span><span class='Function'>-</span><span class='Gets'>↩</span><span class='Value'>b</span>
+<span class='Head'>;</span>
+  <span class='Value'>a</span><span class='Ligature'>‿</span><span class='Value'>b</span><span class='Head'>:</span> <span class='Value'>n</span><span class='Function'>+</span><span class='Gets'>↩</span><span class='Value'>a</span><span class='Function'>-</span><span class='Value'>b</span>
+<span class='Head'>;</span>
+  <span class='Value'>𝕩</span><span class='Head'>:</span> <span class='Value'>n</span><span class='Function'>∾</span><span class='Gets'>↩</span><span class='Value'>𝕩</span>
 <span class='Brace'>}</span>
 </pre>
 <p>A simplified version of a switch-case statement is possible if the cases are natural numbers <code><span class='Number'>0</span></code>, <code><span class='Number'>1</span></code>, and so on. The Choose (<code><span class='Modifier2'>◶</span></code>) modifier does just what we want. The <code><span class='Function'>Select</span></code> statement below generalizes <code><span class='Function'>IfElse</span></code>, except that it doesn't rearrange the cases relative to Choose while <code><span class='Function'>IfElse</span></code> swaps them.</p>
@@ -144,7 +144,7 @@
 <span class='Brace'>}</span> <span class='Value'>arg</span>
 </pre>
 <p>To convert this to a control structure format, we want to take an action <code><span class='Function'>A</span></code>, and produce a function that runs <code><span class='Function'>A</span></code>, then runs itself. Finally we want to call that function on some argument, say <code><span class='String'>@</span></code>. The argument is a single function, so to call Forever, we need to convert that function to a subject role.</p>
-<pre><span class='Function'>Forever</span> <span class='Gets'>←</span> <span class='Brace'>{</span><span class='Function'>𝕊</span><span class='Value'>a:</span><span class='Brace'>{</span><span class='Function'>𝕊A</span><span class='Value'>𝕩</span><span class='Brace'>}</span><span class='String'>@</span><span class='Brace'>}</span>
+<pre><span class='Function'>Forever</span> <span class='Gets'>←</span> <span class='Brace'>{</span><span class='Function'>𝕊</span><span class='Value'>a</span><span class='Head'>:</span><span class='Brace'>{</span><span class='Function'>𝕊A</span><span class='Value'>𝕩</span><span class='Brace'>}</span><span class='String'>@</span><span class='Brace'>}</span>
 
 <span class='Function'>Forever</span> <span class='Number'>1</span><span class='Function'>⊑</span><span class='String'>@</span><span class='Ligature'>‿</span><span class='Brace'>{</span><span class='Value'>𝕤</span>
   <span class='Comment'># Stuff to do forever
@@ -184,13 +184,13 @@
 </span><span class='Function'>Fn</span><span class='Modifier'>¨</span> <span class='Function'>⌽↕</span><span class='Value'>n</span>    <span class='Comment'># for (𝕩=n; --𝕩; )
 </span></pre>
 <p>Very well… a for loop is just a while loop with some extra pre- and post-actions.</p>
-<pre><span class='Function'>For</span> <span class='Gets'>←</span> <span class='Brace'>{</span><span class='Function'>Pre</span><span class='Ligature'>‿</span><span class='Function'>Cond</span><span class='Ligature'>‿</span><span class='Function'>Post</span><span class='Ligature'>‿</span><span class='Function'>Act</span><span class='Value'>:</span> <span class='Function'>Pre</span><span class='String'>@</span> <span class='Separator'>⋄</span> <span class='Brace'>{</span><span class='Function'>𝕊</span><span class='Modifier2'>∘</span><span class='Function'>Post</span><span class='Modifier2'>∘</span><span class='Function'>Act</span><span class='Modifier2'>⍟</span><span class='Function'>Cond</span> <span class='Value'>𝕩</span><span class='Brace'>}</span><span class='String'>@</span><span class='Brace'>}</span>
+<pre><span class='Function'>For</span> <span class='Gets'>←</span> <span class='Brace'>{</span><span class='Function'>Pre</span><span class='Ligature'>‿</span><span class='Function'>Cond</span><span class='Ligature'>‿</span><span class='Function'>Post</span><span class='Ligature'>‿</span><span class='Function'>Act</span><span class='Head'>:</span> <span class='Function'>Pre</span><span class='String'>@</span> <span class='Separator'>⋄</span> <span class='Brace'>{</span><span class='Function'>𝕊</span><span class='Modifier2'>∘</span><span class='Function'>Post</span><span class='Modifier2'>∘</span><span class='Function'>Act</span><span class='Modifier2'>⍟</span><span class='Function'>Cond</span> <span class='Value'>𝕩</span><span class='Brace'>}</span><span class='String'>@</span><span class='Brace'>}</span>
 
 <span class='Function'>For</span> <span class='Paren'>(</span><span class='Value'>c</span><span class='Gets'>←</span><span class='Number'>27</span><span class='Function'>⊣</span><span class='Value'>n</span><span class='Gets'>←</span><span class='Number'>0</span><span class='Paren'>)</span><span class='Ligature'>‿</span><span class='Brace'>{</span><span class='Value'>𝕤</span><span class='Separator'>⋄</span><span class='Number'>1</span><span class='Function'>&lt;</span><span class='Value'>c</span><span class='Brace'>}</span><span class='Ligature'>‿</span><span class='Brace'>{</span><span class='Value'>𝕤</span><span class='Separator'>⋄</span><span class='Value'>n</span><span class='Function'>+</span><span class='Gets'>↩</span><span class='Number'>1</span><span class='Brace'>}</span><span class='Ligature'>‿</span><span class='Brace'>{</span><span class='Value'>𝕤</span>
   <span class='Brace'>{</span><span class='Function'>𝕏</span><span class='Value'>𝕨</span><span class='Brace'>}</span><span class='Modifier'>´</span> <span class='Paren'>(</span><span class='Number'>2</span><span class='Function'>|</span><span class='Value'>c</span><span class='Paren'>)</span><span class='Ligature'>‿</span><span class='Brace'>{</span>
-    <span class='Number'>0</span><span class='Value'>:</span> <span class='Value'>c</span><span class='Function'>÷</span><span class='Gets'>↩</span><span class='Number'>2</span>
-  <span class='Value'>;</span>
-    <span class='Number'>1</span><span class='Value'>:</span> <span class='Value'>c</span><span class='Gets'>↩</span><span class='Number'>1</span><span class='Function'>+</span><span class='Number'>3</span><span class='Function'>×</span><span class='Value'>c</span>
+    <span class='Number'>0</span><span class='Head'>:</span> <span class='Value'>c</span><span class='Function'>÷</span><span class='Gets'>↩</span><span class='Number'>2</span>
+  <span class='Head'>;</span>
+    <span class='Number'>1</span><span class='Head'>:</span> <span class='Value'>c</span><span class='Gets'>↩</span><span class='Number'>1</span><span class='Function'>+</span><span class='Number'>3</span><span class='Function'>×</span><span class='Value'>c</span>
   <span class='Brace'>}</span>
 <span class='Brace'>}</span>
 </pre>
@@ -199,9 +199,9 @@
 <pre><span class='Value'>c</span><span class='Gets'>←</span><span class='Number'>27</span> <span class='Separator'>⋄</span> <span class='Value'>n</span><span class='Gets'>←</span><span class='Number'>0</span>
 <span class='Function'>While</span> <span class='Bracket'>⟨</span><span class='Brace'>{</span><span class='Value'>𝕤</span><span class='Separator'>⋄</span><span class='Number'>1</span><span class='Function'>&lt;</span><span class='Value'>c</span><span class='Brace'>}</span><span class='Separator'>,</span> <span class='Brace'>{</span><span class='Value'>𝕤</span><span class='Separator'>⋄</span><span class='Value'>n</span><span class='Function'>+</span><span class='Gets'>↩</span><span class='Number'>1</span><span class='Brace'>}{</span><span class='Function'>𝔾</span><span class='Modifier2'>∘</span><span class='Function'>𝔽</span><span class='Brace'>}{</span><span class='Value'>𝕤</span>
   <span class='Function'>Match</span> <span class='Paren'>(</span><span class='Number'>2</span><span class='Function'>|</span><span class='Value'>c</span><span class='Paren'>)</span><span class='Ligature'>‿</span><span class='Brace'>{</span>
-    <span class='Number'>0</span><span class='Value'>:</span> <span class='Value'>c</span><span class='Function'>÷</span><span class='Gets'>↩</span><span class='Number'>2</span>
-  <span class='Value'>;</span>
-    <span class='Number'>1</span><span class='Value'>:</span> <span class='Value'>c</span><span class='Gets'>↩</span><span class='Number'>1</span><span class='Function'>+</span><span class='Number'>3</span><span class='Function'>×</span><span class='Value'>c</span>
+    <span class='Number'>0</span><span class='Head'>:</span> <span class='Value'>c</span><span class='Function'>÷</span><span class='Gets'>↩</span><span class='Number'>2</span>
+  <span class='Head'>;</span>
+    <span class='Number'>1</span><span class='Head'>:</span> <span class='Value'>c</span><span class='Gets'>↩</span><span class='Number'>1</span><span class='Function'>+</span><span class='Number'>3</span><span class='Function'>×</span><span class='Value'>c</span>
   <span class='Brace'>}</span>
 <span class='Brace'>}</span><span class='Bracket'>⟩</span>
 </pre>
diff --git a/docs/doc/couple.html b/docs/doc/couple.html
index 5f9b8dd5..1f71bb19 100644
--- a/docs/doc/couple.html
+++ b/docs/doc/couple.html
@@ -78,5 +78,5 @@
 <p>A note on the topic of Solo and Couple applied to units. As always, one axis will be added, so that the result is a list (strangely, J's <a href="https://code.jsoftware.com/wiki/Vocabulary/commaco#dyadic">laminate</a> differs from Couple in this one case, as it will add an axis to get a shape <code><span class='Number'>2</span><span class='Ligature'>‿</span><span class='Number'>1</span></code> result). For Solo, this is interchangeable with <a href="reshape.html">Deshape</a> (<code><span class='Function'>⥊</span></code>), and either primitive might be chosen for stylistic reasons. For Couple, it is equivalent to <a href="join.html">Join-to</a> (<code><span class='Function'>∾</span></code>), but this is an irregular form of Join-to because it is the only case where Join-to adds an axis to both arguments instead of just one. Couple should be preferred in this case.</p>
 <p>The function <a href="pair.html">Pair</a> (<code><span class='Function'>⋈</span></code>) can be written <code><span class='Function'>≍</span><span class='Modifier2'>○</span><span class='Function'>&lt;</span></code>, while <code><span class='Function'>≍</span></code> in either valence is <code><span class='Function'>&gt;</span><span class='Modifier2'>∘</span><span class='Function'>⋈</span></code>. As an interesting consequence, <code><span class='Function'>≍</span> <span class='Gets'>←→</span> <span class='Function'>&gt;</span><span class='Modifier2'>∘</span><span class='Function'>≍</span><span class='Modifier2'>○</span><span class='Function'>&lt;</span></code>, and <code><span class='Function'>⋈</span> <span class='Gets'>←→</span> <span class='Function'>&gt;</span><span class='Modifier2'>∘</span><span class='Function'>⋈</span><span class='Modifier2'>○</span><span class='Function'>&lt;</span></code>. These two identities have the same form because adding <code><span class='Modifier2'>○</span><span class='Function'>&lt;</span></code> commutes with adding <code><span class='Function'>&gt;</span><span class='Modifier2'>∘</span></code>.</p>
 <h2 id="definitions"><a class="header" href="#definitions">Definitions</a></h2>
-<p>As discussed above, <code><span class='Function'>≍</span></code> is equivalent to <code><span class='Function'>&gt;</span><span class='Brace'>{</span><span class='Bracket'>⟨</span><span class='Value'>𝕩</span><span class='Bracket'>⟩</span><span class='Value'>;</span><span class='Bracket'>⟨</span><span class='Value'>𝕨</span><span class='Separator'>,</span><span class='Value'>𝕩</span><span class='Bracket'>⟩</span><span class='Brace'>}</span></code>. To complete the picture we should describe Merge fully. Merge is defined on an array argument <code><span class='Value'>𝕩</span></code> such that there's some shape <code><span class='Value'>s</span></code> satisfying <code><span class='Function'>∧</span><span class='Modifier'>´</span><span class='Function'>⥊</span><span class='Paren'>(</span><span class='Value'>s</span><span class='Function'>≡≢</span><span class='Paren'>)</span><span class='Modifier'>¨</span><span class='Value'>𝕩</span></code>. If <code><span class='Value'>𝕩</span></code> is empty then any shape satisfies this expression; <code><span class='Value'>s</span></code> should be chosen based on known type information for <code><span class='Value'>𝕩</span></code> or otherwise assumed to be <code><span class='Bracket'>⟨⟩</span></code>. If <code><span class='Value'>s</span></code> is empty then <code><span class='Value'>𝕩</span></code> is allowed to contain atoms as well as unit arrays, and these will be implicitly promoted to arrays by the <code><span class='Function'>⊑</span></code> indexing used later. We construct the result by combining the outer and inner axes of the argument with Table; since the outer axes come first they must correspond to the left argument and the inner axes must correspond to the right argument. <code><span class='Value'>𝕩</span></code> is a natural choice of left argument, and because no concrete array can be used, the right argument will be <code><span class='Function'>↕</span><span class='Value'>s</span></code>, the array of indices into any element of <code><span class='Value'>𝕩</span></code>. To get the appropriate element corresponding to a particular choice of index and element of <code><span class='Value'>𝕩</span></code> we should select using that index. The result of Merge is <code><span class='Value'>𝕩</span><span class='Function'>⊑</span><span class='Modifier'>˜⌜</span><span class='Function'>↕</span><span class='Value'>s</span></code>.</p>
+<p>As discussed above, <code><span class='Function'>≍</span></code> is equivalent to <code><span class='Function'>&gt;</span><span class='Brace'>{</span><span class='Bracket'>⟨</span><span class='Value'>𝕩</span><span class='Bracket'>⟩</span><span class='Head'>;</span><span class='Bracket'>⟨</span><span class='Value'>𝕨</span><span class='Separator'>,</span><span class='Value'>𝕩</span><span class='Bracket'>⟩</span><span class='Brace'>}</span></code>. To complete the picture we should describe Merge fully. Merge is defined on an array argument <code><span class='Value'>𝕩</span></code> such that there's some shape <code><span class='Value'>s</span></code> satisfying <code><span class='Function'>∧</span><span class='Modifier'>´</span><span class='Function'>⥊</span><span class='Paren'>(</span><span class='Value'>s</span><span class='Function'>≡≢</span><span class='Paren'>)</span><span class='Modifier'>¨</span><span class='Value'>𝕩</span></code>. If <code><span class='Value'>𝕩</span></code> is empty then any shape satisfies this expression; <code><span class='Value'>s</span></code> should be chosen based on known type information for <code><span class='Value'>𝕩</span></code> or otherwise assumed to be <code><span class='Bracket'>⟨⟩</span></code>. If <code><span class='Value'>s</span></code> is empty then <code><span class='Value'>𝕩</span></code> is allowed to contain atoms as well as unit arrays, and these will be implicitly promoted to arrays by the <code><span class='Function'>⊑</span></code> indexing used later. We construct the result by combining the outer and inner axes of the argument with Table; since the outer axes come first they must correspond to the left argument and the inner axes must correspond to the right argument. <code><span class='Value'>𝕩</span></code> is a natural choice of left argument, and because no concrete array can be used, the right argument will be <code><span class='Function'>↕</span><span class='Value'>s</span></code>, the array of indices into any element of <code><span class='Value'>𝕩</span></code>. To get the appropriate element corresponding to a particular choice of index and element of <code><span class='Value'>𝕩</span></code> we should select using that index. The result of Merge is <code><span class='Value'>𝕩</span><span class='Function'>⊑</span><span class='Modifier'>˜⌜</span><span class='Function'>↕</span><span class='Value'>s</span></code>.</p>
 <p>Given this definition we can also describe Rank (<code><span class='Modifier2'>⎉</span></code>) in terms of Each (<code><span class='Modifier'>¨</span></code>) and the simpler monadic function Enclose-Rank <code><span class='Function'>&lt;</span><span class='Modifier2'>⎉</span><span class='Value'>k</span></code>. We assume effective ranks <code><span class='Value'>j</span></code> for <code><span class='Value'>𝕨</span></code> (if present) and <code><span class='Value'>k</span></code> for <code><span class='Value'>𝕩</span></code> have been computed. Then the correspondence is <code><span class='Value'>𝕨</span><span class='Function'>F</span><span class='Modifier2'>⎉</span><span class='Value'>k𝕩</span> <span class='Gets'>←→</span> <span class='Function'>&gt;</span><span class='Paren'>(</span><span class='Function'>&lt;</span><span class='Modifier2'>⎉</span><span class='Value'>j𝕨</span><span class='Paren'>)</span><span class='Function'>F</span><span class='Modifier'>¨</span><span class='Paren'>(</span><span class='Function'>&lt;</span><span class='Modifier2'>⎉</span><span class='Value'>k𝕩</span><span class='Paren'>)</span></code>.</p>
diff --git a/docs/doc/embed.html b/docs/doc/embed.html
index bdd03679..b02342cc 100644
--- a/docs/doc/embed.html
+++ b/docs/doc/embed.html
@@ -9,16 +9,16 @@
 <p>There is only one mechanism to interface between the host language and BQN: the function <code><span class='Value'>bqn</span></code> evaluates a string containing a BQN program and returns the result. Doesn't sound like much, especially considering these programs can't share any state such as global variables (BQN doesn't have those). But taking first-class functions and closures into account, it's all you could ever need!</p>
 <h2 id="passing-closures"><a class="header" href="#passing-closures">Passing closures</a></h2>
 <p>Probably you can figure out the easy things like calling <code><span class='Value'>bqn</span><span class='Paren'>(</span><span class='String'>&quot;×´1+↕6&quot;</span><span class='Paren'>)</span></code> to compute six factorial. But how do you get JS and BQN to <em>talk</em> to each other, for example to compute the factorial of a number <code><span class='Value'>n</span></code>? Constructing a source string with <code><span class='Value'>bqn</span><span class='Paren'>(</span><span class='String'>&quot;×´1+↕&quot;</span><span class='Function'>+</span><span class='Value'>n</span><span class='Paren'>)</span></code> isn't the best way—in fact I would recommend you never use this strategy.</p>
-<p>Instead, return a function from BQN and call it: <code><span class='Value'>bqn</span><span class='Paren'>(</span><span class='String'>&quot;{×´1+↕𝕩}&quot;</span><span class='Paren'>)(</span><span class='Value'>n</span><span class='Paren'>)</span></code>. This strategy also has the advantage that you can store the function, so that it will only be compiled once. Define <code><span class='Value'>let</span> <span class='Value'>fact</span> <span class='Function'>=</span> <span class='Value'>bqn</span><span class='Paren'>(</span><span class='String'>&quot;{×´1+↕𝕩}&quot;</span><span class='Paren'>)</span><span class='Value'>;</span></code> at the top of your program and use it as a function elsewhere.</p>
+<p>Instead, return a function from BQN and call it: <code><span class='Value'>bqn</span><span class='Paren'>(</span><span class='String'>&quot;{×´1+↕𝕩}&quot;</span><span class='Paren'>)(</span><span class='Value'>n</span><span class='Paren'>)</span></code>. This strategy also has the advantage that you can store the function, so that it will only be compiled once. Define <code><span class='Value'>let</span> <span class='Value'>fact</span> <span class='Function'>=</span> <span class='Value'>bqn</span><span class='Paren'>(</span><span class='String'>&quot;{×´1+↕𝕩}&quot;</span><span class='Paren'>)</span><span class='Head'>;</span></code> at the top of your program and use it as a function elsewhere.</p>
 <p>BQN can also call JS functions, to use functionality that isn't native to BQN or interact with a program written in JS. For example, <code><span class='Value'>bqn</span><span class='Paren'>(</span><span class='String'>&quot;{𝕏'a'+↕26}&quot;</span><span class='Paren'>)(</span><span class='Value'>alert</span><span class='Paren'>)</span></code> calls the argument <code><span class='Value'>alert</span></code> from within BQN. The displayed output isn't quite right here, because a BQN string is stored as a JS array, not a string. See the next section for more information.</p>
 <p>Cool, but none of these examples really use closures, just self-contained functions. <a href="lexical.html#closures">Closures</a> are functions that use outside state, which is maintained over the course of the program. Here's an example program that defines <code><span class='Value'>i</span></code> and then returns a function that manipulates <code><span class='Value'>i</span></code> and returns its new value.</p>
 <pre><span class='Value'>let</span> <span class='Value'>push</span> <span class='Function'>=</span> <span class='Value'>bqn</span><span class='Paren'>(</span><span class='Modifier'>`</span>
     <span class='Value'>i</span><span class='Gets'>←</span><span class='Number'>4</span><span class='Function'>⥊</span><span class='Number'>0</span>
     <span class='Brace'>{</span><span class='Value'>i</span><span class='Function'>+</span><span class='Gets'>↩</span><span class='Value'>𝕩</span><span class='Function'>»</span><span class='Value'>i</span><span class='Brace'>}</span>
-<span class='Modifier'>`</span><span class='Paren'>)</span><span class='Value'>;</span>
-<span class='Value'>push</span><span class='Paren'>(</span><span class='Number'>3</span><span class='Paren'>)</span><span class='Value'>;</span>    <span class='Function'>//</span> <span class='Value'>[</span><span class='Number'>3</span><span class='Separator'>,</span><span class='Number'>0</span><span class='Separator'>,</span><span class='Number'>0</span><span class='Separator'>,</span><span class='Number'>0</span><span class='Value'>]</span>
-<span class='Value'>push</span><span class='Paren'>(</span><span class='Function'>-</span><span class='Number'>2</span><span class='Paren'>)</span><span class='Value'>;</span>   <span class='Function'>//</span> <span class='Value'>[</span><span class='Number'>1</span><span class='Separator'>,</span><span class='Number'>3</span><span class='Separator'>,</span><span class='Number'>0</span><span class='Separator'>,</span><span class='Number'>0</span><span class='Value'>]</span>
-<span class='Value'>push</span><span class='Paren'>(</span><span class='Number'>4</span><span class='Paren'>)</span><span class='Value'>;</span>    <span class='Function'>//</span> <span class='Value'>[</span><span class='Number'>5</span><span class='Separator'>,</span><span class='Number'>4</span><span class='Separator'>,</span><span class='Number'>3</span><span class='Separator'>,</span><span class='Number'>0</span><span class='Value'>]</span>
+<span class='Modifier'>`</span><span class='Paren'>)</span><span class='Head'>;</span>
+<span class='Value'>push</span><span class='Paren'>(</span><span class='Number'>3</span><span class='Paren'>)</span><span class='Head'>;</span>    <span class='Function'>//</span> <span class='Value'>[</span><span class='Number'>3</span><span class='Separator'>,</span><span class='Number'>0</span><span class='Separator'>,</span><span class='Number'>0</span><span class='Separator'>,</span><span class='Number'>0</span><span class='Value'>]</span>
+<span class='Value'>push</span><span class='Paren'>(</span><span class='Function'>-</span><span class='Number'>2</span><span class='Paren'>)</span><span class='Head'>;</span>   <span class='Function'>//</span> <span class='Value'>[</span><span class='Number'>1</span><span class='Separator'>,</span><span class='Number'>3</span><span class='Separator'>,</span><span class='Number'>0</span><span class='Separator'>,</span><span class='Number'>0</span><span class='Value'>]</span>
+<span class='Value'>push</span><span class='Paren'>(</span><span class='Number'>4</span><span class='Paren'>)</span><span class='Head'>;</span>    <span class='Function'>//</span> <span class='Value'>[</span><span class='Number'>5</span><span class='Separator'>,</span><span class='Number'>4</span><span class='Separator'>,</span><span class='Number'>3</span><span class='Separator'>,</span><span class='Number'>0</span><span class='Value'>]</span>
 </pre>
 <p>Note that this program doesn't have any outer braces. It's only run once, and it initializes <code><span class='Value'>i</span></code> and returns a function. Just putting braces around it wouldn't have any effect—it just changes it from a program that does something to a program that runs a block that does the same thing—but adding braces and using <code><span class='Value'>𝕨</span></code> or <code><span class='Value'>𝕩</span></code> inside them would turn it into a function that could be run multiple times to create different closures. For example, <code><span class='Value'>pushGen</span> <span class='Function'>=</span> <span class='Value'>bqn</span><span class='Paren'>(</span><span class='String'>&quot;{i←4⥊𝕩⋄{i+↩𝕩»i}}&quot;</span><span class='Paren'>)</span></code> causes <code><span class='Value'>pushGen</span><span class='Paren'>(</span><span class='Value'>n</span><span class='Paren'>)</span></code> to create a new closure with <code><span class='Value'>i</span></code> initialized to <code><span class='Number'>4</span><span class='Function'>⥊</span><span class='Value'>n</span></code>.</p>
 <p>The program also returns only one function, which can be limiting. But it's possible to get multiple closures out of the same program by returning a list of functions. For example, the following program defines three functions that manipulate a shared array in different ways.</p>
@@ -28,7 +28,7 @@
     <span class='Function'>RotY</span> <span class='Gets'>←</span> <span class='Brace'>{</span><span class='Value'>a</span><span class='Gets'>↩</span><span class='Value'>𝕩</span><span class='Function'>⌽</span><span class='Value'>a</span><span class='Brace'>}</span>
     <span class='Function'>Flip</span> <span class='Gets'>←</span> <span class='Brace'>{</span><span class='Value'>𝕤</span><span class='Separator'>⋄</span><span class='Value'>a</span><span class='Gets'>↩</span><span class='Function'>⍉</span><span class='Value'>a</span><span class='Brace'>}</span>
     <span class='Function'>RotX</span><span class='Ligature'>‿</span><span class='Function'>RotY</span><span class='Ligature'>‿</span><span class='Function'>Flip</span>
-<span class='Modifier'>`</span><span class='Paren'>)</span><span class='Value'>;</span>
+<span class='Modifier'>`</span><span class='Paren'>)</span><span class='Head'>;</span>
 </pre>
 <p>When defining closures for their side effects like this, make sure they are actually functions! For example, since <code><span class='Value'>flip</span></code> ignores its argument (you can call it with <code><span class='Value'>flip</span><span class='Paren'>()</span></code>, because a right argument of <code><span class='Value'>undefined</span></code> isn't valid but will just be ignored), it needs an extra <code><span class='Value'>𝕤</span></code> in the definition to be a function instead of an immediate block.</p>
 <p>You can also use an array to pass multiple functions or other values from JS into BQN all at once. However, a JS array can't be used directly in BQN because its shape isn't known. The function <code><span class='Value'>list</span><span class='Paren'>()</span></code> converts a JS array into a BQN list by using its length for the shape; the next section has a few more details.</p>
diff --git a/docs/doc/expression.html b/docs/doc/expression.html
index 8676b3d9..6b7f588c 100644
--- a/docs/doc/expression.html
+++ b/docs/doc/expression.html
@@ -22,7 +22,7 @@
 </thead>
 <tbody>
 <tr>
-<td><code><span class='Value'>w?</span></code></td>
+<td><code><span class='Value'>w</span><span class='Head'>?</span></code></td>
 <td><code><span class='Function'>F</span></code></td>
 <td><code><span class='Value'>x</span></code></td>
 <td>Subject</td>
@@ -30,7 +30,7 @@
 <td>RtL, looser</td>
 </tr>
 <tr>
-<td><code><span class='Function'>F</span><span class='Value'>?</span></code></td>
+<td><code><span class='Function'>F</span><span class='Head'>?</span></code></td>
 <td><code><span class='Function'>G</span></code></td>
 <td><code><span class='Function'>H</span></code></td>
 <td>Function</td>
@@ -56,7 +56,7 @@
 </tbody>
 </table>
 <p>The four roles (subject, function, two kinds of modifier) describe expressions, not values. When an expression is evaluated, the value's <a href="types.html">type</a> doesn't have to correspond to its role, and can even change from one evaluation to another. An expression's role is determined entirely by its source code, so it's fixed.</p>
-<p>In the table, <code><span class='Value'>?</span></code> marks an optional left argument. If there isn't a value in that position, or it's <a href="#nothing">Nothing</a> (<code><span class='Nothing'>·</span></code>), the middle function will be called with only one argument.</p>
+<p>In the table, <code><span class='Head'>?</span></code> marks an optional left argument. If there isn't a value in that position, or it's <a href="#nothing">Nothing</a> (<code><span class='Nothing'>·</span></code>), the middle function will be called with only one argument.</p>
 <p>If you're comfortable reading <a href="https://en.wikipedia.org/wiki/Backus%E2%80%93Naur_form">BNF</a> and want to understand things in more detail than described below, you might check the <a href="../spec/grammar.html">grammar specification</a> as well.</p>
 <h2 id="syntactic-role"><a class="header" href="#syntactic-role">Syntactic role</a></h2>
 <p><em>This issue is approached from a different angle in <a href="context.html">Context free grammar</a>.</em></p>
diff --git a/docs/doc/fromDyalog.html b/docs/doc/fromDyalog.html
index ac3d4974..1f256416 100644
--- a/docs/doc/fromDyalog.html
+++ b/docs/doc/fromDyalog.html
@@ -286,7 +286,7 @@
 <tr><td> <code><span class='Function'>!</span></code> </td><td><code><span class='Function'>×</span><span class='Modifier'>´</span><span class='Number'>1</span><span class='Function'>+↕</span></code>            </td><td> <code><span class='Function'>-</span><span class='Modifier'>˜</span><span class='Paren'>(</span><span class='Function'>+÷</span><span class='Modifier2'>○</span><span class='Paren'>(</span><span class='Function'>×</span><span class='Modifier'>´</span><span class='Paren'>)</span><span class='Function'>⊢</span><span class='Paren'>)</span><span class='Number'>1</span><span class='Function'>+↕</span><span class='Modifier2'>∘</span><span class='Function'>⊣</span></code></td></tr>
 <tr><td> <code><span class='Modifier2'>○</span></code> </td><td> <code><span class='Number'>π</span><span class='Modifier2'>⊸</span><span class='Function'>×</span></code>             </td><td> <code><span class='Value'>•math</span></code></td>    </tr>
 <tr><td> <code><span class='Value'>~</span></code> </td><td> <code><span class='Function'>¬</span></code>               </td><td> <code><span class='Function'>¬</span><span class='Modifier2'>∘</span><span class='Function'>∊/⊣</span></code></td>    </tr>
-<tr><td> <code><span class='Value'>?</span></code> </td><td> <code><span class='Value'>•rand.</span><span class='Function'>Range</span><span class='Modifier2'>⚇</span><span class='Number'>0</span></code>   </td><td> <code><span class='Value'>•rand.</span><span class='Function'>Deal</span></code></td></tr>
+<tr><td> <code><span class='Head'>?</span></code> </td><td> <code><span class='Value'>•rand.</span><span class='Function'>Range</span><span class='Modifier2'>⚇</span><span class='Number'>0</span></code>   </td><td> <code><span class='Value'>•rand.</span><span class='Function'>Deal</span></code></td></tr>
 <tr><td> <code><span class='Value'>⍲</span></code> </td><td>                              </td><td> <code><span class='Function'>¬</span><span class='Modifier2'>∘</span><span class='Function'>∧</span></code></td>      </tr>
 <tr><td> <code><span class='Value'>⍱</span></code> </td><td>                              </td><td> <code><span class='Function'>¬</span><span class='Modifier2'>∘</span><span class='Function'>∨</span></code></td>      </tr>
 <tr><td> <code><span class='Value'>⍴</span></code> </td><td> <code><span class='Function'>≢</span></code>               </td><td> <code><span class='Function'>⥊</span></code></td>        </tr>
diff --git a/docs/doc/fromJ.html b/docs/doc/fromJ.html
index a0dfde9e..524ec8d3 100644
--- a/docs/doc/fromJ.html
+++ b/docs/doc/fromJ.html
@@ -61,18 +61,18 @@
 <td><code><span class='String'>'</span></code> creates characters</td>
 </tr>
 <tr>
-<td><code><span class='Function'>=</span><span class='Value'>.</span></code> and <code><span class='Function'>=</span><span class='Value'>:</span></code></td>
+<td><code><span class='Function'>=</span><span class='Value'>.</span></code> and <code><span class='Function'>=</span><span class='Head'>:</span></code></td>
 <td><code><span class='Gets'>←</span></code> and <code><span class='Gets'>↩</span></code></td>
 <td><code><span class='Gets'>←</span></code> to define; <code><span class='Gets'>↩</span></code> to modify</td>
 </tr>
 <tr>
-<td><code><span class='Number'>3</span> <span class='Value'>:…</span></code> or <code><span class='Brace'>{{</span><span class='Value'>…</span><span class='Brace'>}}</span></code></td>
+<td><code><span class='Number'>3</span> <span class='Head'>:</span><span class='Value'>…</span></code> or <code><span class='Brace'>{{</span><span class='Value'>…</span><span class='Brace'>}}</span></code></td>
 <td><code><span class='Brace'>{</span><span class='Value'>…</span><span class='Brace'>}</span></code></td>
 <td></td>
 </tr>
 <tr>
-<td><code><span class='Value'>:</span></code></td>
-<td><code><span class='Value'>;</span></code></td>
+<td><code><span class='Head'>:</span></code></td>
+<td><code><span class='Head'>;</span></code></td>
 <td>To separate function cases</td>
 </tr>
 <tr>
@@ -96,7 +96,7 @@
 <td></td>
 </tr>
 <tr>
-<td><code><span class='Value'>[:</span></code></td>
+<td><code><span class='Value'>[</span><span class='Head'>:</span></code></td>
 <td><code><span class='Nothing'>·</span></code></td>
 <td>Cap</td>
 </tr>
@@ -133,11 +133,11 @@
 <td align="center"><code><span class='Value'>*</span></code></td>
 <td align="center"><code><span class='Value'>%</span></code></td>
 <td align="center"><code><span class='Value'>^</span></code></td>
-<td align="center"><code><span class='Value'>%:</span></code></td>
+<td align="center"><code><span class='Value'>%</span><span class='Head'>:</span></code></td>
 <td align="center"><code><span class='Function'>&lt;</span><span class='Value'>.</span></code></td>
 <td align="center"><code><span class='Function'>&gt;</span><span class='Value'>.</span></code></td>
-<td align="center"><code><span class='Function'>&lt;</span><span class='Value'>:</span></code></td>
-<td align="center"><code><span class='Function'>&gt;</span><span class='Value'>:</span></code></td>
+<td align="center"><code><span class='Function'>&lt;</span><span class='Head'>:</span></code></td>
+<td align="center"><code><span class='Function'>&gt;</span><span class='Head'>:</span></code></td>
 <td align="center"><code><span class='Value'>[</span></code></td>
 <td align="center"><code><span class='Value'>]</span></code></td>
 </tr>
@@ -156,10 +156,10 @@
 <tbody>
 <tr>
 <td align="center">J</td>
-<td align="center"><code><span class='Separator'>,</span><span class='Value'>:</span></code></td>
-<td align="center"><code><span class='Separator'>,</span><span class='Value'>&amp;:</span><span class='Function'>&lt;</span></code></td>
+<td align="center"><code><span class='Separator'>,</span><span class='Head'>:</span></code></td>
+<td align="center"><code><span class='Separator'>,</span><span class='Value'>&amp;</span><span class='Head'>:</span><span class='Function'>&lt;</span></code></td>
 <td align="center"><code><span class='Function'>|</span><span class='Value'>.</span></code></td>
-<td align="center"><code><span class='Function'>|</span><span class='Value'>:</span></code></td>
+<td align="center"><code><span class='Function'>|</span><span class='Head'>:</span></code></td>
 </tr>
 </tbody>
 </table>
@@ -181,15 +181,15 @@
 <tbody>
 <tr>
 <td align="center">Monad</td>
-<td align="center"><code><span class='Function'>/</span><span class='Value'>:~</span></code></td>
-<td align="center"><code><span class='Value'>\:~</span></code></td>
+<td align="center"><code><span class='Function'>/</span><span class='Head'>:</span><span class='Value'>~</span></code></td>
+<td align="center"><code><span class='Value'>\</span><span class='Head'>:</span><span class='Value'>~</span></code></td>
 <td align="center"><code><span class='Function'>-</span><span class='Value'>.</span></code></td>
 <td align="center"><code><span class='Comment'>#@$</span></code></td>
 <td align="center"><code><span class='Comment'>#</span></code></td>
 <td align="center"><code><span class='Function'>L</span><span class='Value'>.</span></code></td>
 <td align="center"><code><span class='Value'>$</span></code></td>
 <td align="center"><code><span class='Separator'>,</span></code></td>
-<td align="center"><code><span class='Value'>;</span></code></td>
+<td align="center"><code><span class='Head'>;</span></code></td>
 </tr>
 <tr>
 <td align="center">Dyad</td>
@@ -197,9 +197,9 @@
 <td align="center"><code><span class='Function'>+</span><span class='Value'>.</span></code></td>
 <td align="center"><code><span class='Function'>+-</span><span class='Value'>.</span></code></td>
 <td align="center"><code><span class='Function'>=</span></code></td>
-<td align="center"><code><span class='Value'>~:</span></code></td>
-<td align="center"><code><span class='Function'>-</span><span class='Value'>:</span></code></td>
-<td align="center"><code><span class='Function'>-</span><span class='Value'>.</span><span class='String'>@</span><span class='Function'>-</span><span class='Value'>:</span></code></td>
+<td align="center"><code><span class='Value'>~</span><span class='Head'>:</span></code></td>
+<td align="center"><code><span class='Function'>-</span><span class='Head'>:</span></code></td>
+<td align="center"><code><span class='Function'>-</span><span class='Value'>.</span><span class='String'>@</span><span class='Function'>-</span><span class='Head'>:</span></code></td>
 <td align="center"><code><span class='Value'>$</span></code></td>
 <td align="center"><code><span class='Separator'>,</span></code></td>
 </tr>
@@ -256,22 +256,22 @@
 <tbody>
 <tr>
 <td align="center">Monad</td>
-<td align="center"><code><span class='Function'>/</span><span class='Value'>:</span></code></td>
-<td align="center"><code><span class='Function'>/</span><span class='Value'>:</span></code></td>
+<td align="center"><code><span class='Function'>/</span><span class='Head'>:</span></code></td>
+<td align="center"><code><span class='Function'>/</span><span class='Head'>:</span></code></td>
 <td align="center"><code><span class='Brace'>{</span><span class='Value'>.</span></code></td>
-<td align="center"><code><span class='Number'>0</span><span class='Brace'>{</span><span class='Value'>::</span><span class='Separator'>,</span></code></td>
+<td align="center"><code><span class='Number'>0</span><span class='Brace'>{</span><span class='Head'>::</span><span class='Separator'>,</span></code></td>
 <td align="center"><code><span class='Value'>i.~~.</span></code></td>
 <td align="center"><code><span class='Value'>…</span></code></td>
-<td align="center"><code><span class='Value'>~:</span></code></td>
+<td align="center"><code><span class='Value'>~</span><span class='Head'>:</span></code></td>
 <td align="center"><code><span class='Value'>~.</span></code></td>
 <td align="center"><code><span class='Function'>&lt;/</span><span class='Value'>.i.</span><span class='String'>@</span><span class='Comment'>#</span></code></td>
 </tr>
 <tr>
 <td align="center">Dyad</td>
 <td align="center"><code><span class='Function'>I</span><span class='Value'>.</span></code></td>
-<td align="center"><code><span class='Function'>I</span><span class='Value'>.&amp;:</span><span class='Function'>-</span></code></td>
+<td align="center"><code><span class='Function'>I</span><span class='Value'>.&amp;</span><span class='Head'>:</span><span class='Function'>-</span></code></td>
 <td align="center"><code><span class='Brace'>{</span></code></td>
-<td align="center"><code><span class='Brace'>{</span><span class='Value'>::</span></code></td>
+<td align="center"><code><span class='Brace'>{</span><span class='Head'>::</span></code></td>
 <td align="center"><code><span class='Value'>i.</span></code></td>
 <td align="center"><code><span class='Value'>…</span></code></td>
 <td align="center"><code><span class='Value'>e.</span></code></td>
@@ -300,12 +300,12 @@
 <td align="center">J</td>
 <td align="center"><code><span class='String'>&quot;</span><span class='Modifier2'>_</span></code></td>
 <td align="center"><code><span class='Value'>~</span></code></td>
-<td align="center"><code><span class='String'>@</span><span class='Value'>:</span></code></td>
-<td align="center"><code><span class='Value'>&amp;:</span></code></td>
-<td align="center"><code><span class='Value'>&amp;.:</span></code></td>
-<td align="center"><code><span class='Value'>:</span></code></td>
+<td align="center"><code><span class='String'>@</span><span class='Head'>:</span></code></td>
+<td align="center"><code><span class='Value'>&amp;</span><span class='Head'>:</span></code></td>
+<td align="center"><code><span class='Value'>&amp;.</span><span class='Head'>:</span></code></td>
+<td align="center"><code><span class='Head'>:</span></code></td>
 <td align="center"><code><span class='String'>@</span><span class='Value'>.</span></code></td>
-<td align="center"><code><span class='Value'>::</span></code></td>
+<td align="center"><code><span class='Head'>::</span></code></td>
 </tr>
 </tbody>
 </table>
@@ -336,9 +336,9 @@
 <td align="center"><code><span class='Function'>/</span><span class='Value'>\</span></code></td>
 <td align="center"><code><span class='String'>&quot;</span><span class='Modifier'>_1</span></code></td>
 <td align="center"><code><span class='String'>&quot;</span></code></td>
-<td align="center"><code><span class='Function'>L</span><span class='Value'>:</span></code></td>
-<td align="center"><code><span class='Value'>^:</span></code></td>
-<td align="center"><code><span class='Value'>^:</span><span class='Modifier'>_1</span></code></td>
+<td align="center"><code><span class='Function'>L</span><span class='Head'>:</span></code></td>
+<td align="center"><code><span class='Value'>^</span><span class='Head'>:</span></code></td>
+<td align="center"><code><span class='Value'>^</span><span class='Head'>:</span><span class='Modifier'>_1</span></code></td>
 </tr>
 </tbody>
 </table>
@@ -357,13 +357,13 @@
 <td><code><span class='String'>@</span><span class='Function'>+↕</span><span class='Number'>256</span></code></td>
 </tr>
 <tr>
-<td><code><span class='Value'>a:</span></code></td>
+<td><code><span class='Value'>a</span><span class='Head'>:</span></code></td>
 <td><code><span class='Function'>&lt;↕</span><span class='Number'>0</span></code></td>
 </tr>
 </tbody>
 </table>
 <p>Functions <code><span class='Function'>+</span></code> <code><span class='Function'>-</span></code> <code><span class='Function'>|</span></code> <code><span class='Function'>&lt;</span></code> <code><span class='Function'>&gt;</span></code> are the same in both languages.</p>
-<p>Some other primitives are essentially the same in J and BQN, but with different spellings (but <a href="transpose.html">transpose</a> behaves differently; J's dyadic <code><span class='Function'>|</span><span class='Value'>:</span></code> is more like <code><span class='Function'>⍉</span><span class='Modifier'>⁼</span></code>):</p>
+<p>Some other primitives are essentially the same in J and BQN, but with different spellings (but <a href="transpose.html">transpose</a> behaves differently; J's dyadic <code><span class='Function'>|</span><span class='Head'>:</span></code> is more like <code><span class='Function'>⍉</span><span class='Modifier'>⁼</span></code>):</p>
 <table>
 <thead>
 <tr>
@@ -372,13 +372,13 @@
 <th align="center"><code><span class='Value'>%</span></code></th>
 <th align="center"><code><span class='Value'>^</span></code></th>
 <th align="center"><code><span class='Value'>^.</span></code></th>
-<th align="center"><code><span class='Value'>%:</span></code></th>
+<th align="center"><code><span class='Value'>%</span><span class='Head'>:</span></code></th>
 <th align="center"><code><span class='Function'>&lt;</span><span class='Value'>.</span></code></th>
 <th align="center"><code><span class='Function'>&gt;</span><span class='Value'>.</span></code></th>
 <th align="center"><code><span class='Value'>[</span></code></th>
 <th align="center"><code><span class='Value'>]</span></code></th>
 <th align="center"><code><span class='Function'>|</span><span class='Value'>.</span></code></th>
-<th align="center"><code><span class='Function'>|</span><span class='Value'>:</span></code></th>
+<th align="center"><code><span class='Function'>|</span><span class='Head'>:</span></code></th>
 </tr>
 </thead>
 <tbody>
@@ -403,14 +403,14 @@
 <tr>
 <th align="center">J</th>
 <th align="center"><code><span class='Value'>~</span></code></th>
-<th align="center"><code><span class='String'>@</span><span class='Value'>:</span></code></th>
-<th align="center"><code><span class='Value'>&amp;:</span></code></th>
-<th align="center"><code><span class='Value'>&amp;.:</span></code></th>
-<th align="center"><code><span class='Value'>:</span></code></th>
+<th align="center"><code><span class='String'>@</span><span class='Head'>:</span></code></th>
+<th align="center"><code><span class='Value'>&amp;</span><span class='Head'>:</span></code></th>
+<th align="center"><code><span class='Value'>&amp;.</span><span class='Head'>:</span></code></th>
+<th align="center"><code><span class='Head'>:</span></code></th>
 <th align="center"><code><span class='String'>&quot;</span></code></th>
-<th align="center"><code><span class='Function'>L</span><span class='Value'>:</span></code></th>
-<th align="center"><code><span class='Value'>^:</span></code></th>
-<th align="center"><code><span class='Value'>::</span></code></th>
+<th align="center"><code><span class='Function'>L</span><span class='Head'>:</span></code></th>
+<th align="center"><code><span class='Value'>^</span><span class='Head'>:</span></code></th>
+<th align="center"><code><span class='Head'>::</span></code></th>
 </tr>
 </thead>
 <tbody>
@@ -444,12 +444,12 @@
 <td><code><span class='Function'>=</span></code></td>
 </tr>
 <tr>
-<td><code><span class='Function'>&lt;</span><span class='Value'>:</span></code></td>
+<td><code><span class='Function'>&lt;</span><span class='Head'>:</span></code></td>
 <td><code><span class='Function'>-</span><span class='Modifier2'>⟜</span><span class='Number'>1</span></code></td>
 <td><code><span class='Function'>≤</span></code></td>
 </tr>
 <tr>
-<td><code><span class='Function'>&gt;</span><span class='Value'>:</span></code></td>
+<td><code><span class='Function'>&gt;</span><span class='Head'>:</span></code></td>
 <td><code><span class='Number'>1</span><span class='Modifier2'>⊸</span><span class='Function'>+</span></code></td>
 <td><code><span class='Function'>≥</span></code></td>
 </tr>
@@ -459,7 +459,7 @@
 <td><code><span class='Function'>∨</span></code></td>
 </tr>
 <tr>
-<td><code><span class='Function'>+</span><span class='Value'>:</span></code></td>
+<td><code><span class='Function'>+</span><span class='Head'>:</span></code></td>
 <td><code><span class='Number'>2</span><span class='Modifier2'>⊸</span><span class='Function'>×</span></code></td>
 <td><code><span class='Function'>¬∨</span></code></td>
 </tr>
@@ -469,7 +469,7 @@
 <td><code><span class='Function'>∧</span></code></td>
 </tr>
 <tr>
-<td><code><span class='Value'>*:</span></code></td>
+<td><code><span class='Value'>*</span><span class='Head'>:</span></code></td>
 <td><code><span class='Function'>×</span><span class='Modifier'>˜</span></code></td>
 <td><code><span class='Function'>¬∧</span></code></td>
 </tr>
@@ -479,7 +479,7 @@
 <td><code><span class='Function'>¬</span><span class='Modifier2'>∘</span><span class='Function'>∊/⊣</span></code></td>
 </tr>
 <tr>
-<td><code><span class='Function'>-</span><span class='Value'>:</span></code></td>
+<td><code><span class='Function'>-</span><span class='Head'>:</span></code></td>
 <td><code><span class='Function'>÷</span><span class='Modifier2'>⟜</span><span class='Number'>2</span></code></td>
 <td><code><span class='Function'>≡</span></code></td>
 </tr>
@@ -499,7 +499,7 @@
 <td></td>
 </tr>
 <tr>
-<td><code><span class='Value'>~:</span></code></td>
+<td><code><span class='Value'>~</span><span class='Head'>:</span></code></td>
 <td><code><span class='Function'>∊</span></code></td>
 <td><code><span class='Function'>≠</span></code></td>
 </tr>
@@ -514,12 +514,12 @@
 <td><code><span class='Function'>∾</span><span class='Modifier'>˘</span></code></td>
 </tr>
 <tr>
-<td><code><span class='Separator'>,</span><span class='Value'>:</span></code></td>
+<td><code><span class='Separator'>,</span><span class='Head'>:</span></code></td>
 <td><code><span class='Function'>≍</span></code></td>
 <td></td>
 </tr>
 <tr>
-<td><code><span class='Value'>;</span></code></td>
+<td><code><span class='Head'>;</span></code></td>
 <td><code><span class='Function'>∾</span></code></td>
 <td><code><span class='Function'>∾</span><span class='Modifier2'>⟜</span><span class='Paren'>(</span><span class='Function'>&lt;</span><span class='Modifier2'>⍟</span><span class='Paren'>(</span><span class='Number'>1</span><span class='Function'>≥≡</span><span class='Paren'>))</span></code></td>
 </tr>
@@ -544,12 +544,12 @@
 <td><code><span class='Function'>-</span><span class='Modifier'>˜</span><span class='Paren'>(</span><span class='Function'>+÷</span><span class='Modifier2'>○</span><span class='Paren'>(</span><span class='Function'>×</span><span class='Modifier'>´</span><span class='Paren'>)</span><span class='Function'>⊢</span><span class='Paren'>)</span><span class='Number'>1</span><span class='Function'>+↕</span><span class='Modifier2'>∘</span><span class='Function'>⊣</span></code></td>
 </tr>
 <tr>
-<td><code><span class='Function'>/</span><span class='Value'>:</span></code></td>
+<td><code><span class='Function'>/</span><span class='Head'>:</span></code></td>
 <td><code><span class='Function'>⍋</span></code></td>
 <td><code><span class='Function'>⍋</span><span class='Modifier2'>⊸</span><span class='Function'>⊏</span></code></td>
 </tr>
 <tr>
-<td><code><span class='Value'>\:</span></code></td>
+<td><code><span class='Value'>\</span><span class='Head'>:</span></code></td>
 <td><code><span class='Function'>⍒</span></code></td>
 <td><code><span class='Function'>⍒</span><span class='Modifier2'>⊸</span><span class='Function'>⊏</span></code></td>
 </tr>
@@ -564,12 +564,12 @@
 <td><code><span class='Function'>↑</span></code></td>
 </tr>
 <tr>
-<td><code><span class='Brace'>{</span><span class='Value'>:</span></code></td>
+<td><code><span class='Brace'>{</span><span class='Head'>:</span></code></td>
 <td><code><span class='Function'>⊢</span><span class='Modifier'>˝</span></code></td>
 <td></td>
 </tr>
 <tr>
-<td><code><span class='Brace'>{</span><span class='Value'>::</span></code></td>
+<td><code><span class='Brace'>{</span><span class='Head'>::</span></code></td>
 <td></td>
 <td><code><span class='Function'>⊑</span></code></td>
 </tr>
@@ -579,7 +579,7 @@
 <td><code><span class='Function'>↓</span></code></td>
 </tr>
 <tr>
-<td><code><span class='Brace'>}</span><span class='Value'>:</span></code></td>
+<td><code><span class='Brace'>}</span><span class='Head'>:</span></code></td>
 <td><code><span class='Number'>¯1</span><span class='Modifier2'>⊸</span><span class='Function'>↓</span></code></td>
 <td></td>
 </tr>
@@ -589,12 +589,12 @@
 <td></td>
 </tr>
 <tr>
-<td><code><span class='String'>&quot;</span><span class='Value'>:</span></code></td>
+<td><code><span class='String'>&quot;</span><span class='Head'>:</span></code></td>
 <td><code><span class='Function'>•Fmt</span></code></td>
 <td></td>
 </tr>
 <tr>
-<td><code><span class='Value'>?</span></code></td>
+<td><code><span class='Head'>?</span></code></td>
 <td><code><span class='Value'>•rand.</span><span class='Function'>Range</span><span class='Modifier2'>⚇</span><span class='Number'>0</span></code></td>
 <td><code><span class='Value'>•rand.</span><span class='Function'>Deal</span></code></td>
 </tr>
@@ -614,7 +614,7 @@
 <td><code><span class='Function'>⊐</span></code></td>
 </tr>
 <tr>
-<td><code><span class='Value'>i:</span></code></td>
+<td><code><span class='Value'>i</span><span class='Head'>:</span></code></td>
 <td><code><span class='Brace'>{</span><span class='Value'>𝕩</span><span class='Function'>-</span><span class='Modifier'>˜</span><span class='Function'>↕</span><span class='Number'>1</span><span class='Function'>+</span><span class='Number'>2</span><span class='Function'>×</span><span class='Value'>𝕩</span><span class='Brace'>}</span></code></td>
 <td><code><span class='Function'>≠</span><span class='Modifier2'>∘</span><span class='Function'>⊣-</span><span class='Number'>1</span><span class='Function'>+⌽</span><span class='Modifier2'>⊸</span><span class='Function'>⊐</span></code></td>
 </tr>
@@ -673,11 +673,11 @@
 <td><code><span class='Value'>x</span> <span class='Function'>F</span><span class='Modifier'>˝</span><span class='Modifier2'>∘</span><span class='Function'>G</span><span class='Modifier2'>⎉</span><span class='Number'>1</span><span class='Ligature'>‿</span><span class='Number'>∞</span> <span class='Value'>y</span></code></td>
 </tr>
 <tr>
-<td><code><span class='Function'>F</span> <span class='Value'>:.</span> <span class='Function'>G</span></code></td>
-<td><code><span class='Brace'>{</span><span class='Function'>𝕊</span><span class='Value'>:</span> <span class='Value'>𝕨</span><span class='Function'>F</span><span class='Value'>𝕩;</span> <span class='Function'>𝕊</span><span class='Modifier'>⁼</span><span class='Value'>:</span> <span class='Value'>𝕨</span><span class='Function'>G</span><span class='Value'>𝕩</span><span class='Brace'>}</span></code></td>
+<td><code><span class='Function'>F</span> <span class='Head'>:</span><span class='Value'>.</span> <span class='Function'>G</span></code></td>
+<td><code><span class='Brace'>{</span><span class='Function'>𝕊</span><span class='Head'>:</span> <span class='Value'>𝕨</span><span class='Function'>F</span><span class='Value'>𝕩</span><span class='Head'>;</span> <span class='Function'>𝕊</span><span class='Modifier'>⁼</span><span class='Head'>:</span> <span class='Value'>𝕨</span><span class='Function'>G</span><span class='Value'>𝕩</span><span class='Brace'>}</span></code></td>
 </tr>
 <tr>
-<td><code><span class='Function'>&lt;</span><span class='Value'>;.</span><span class='Modifier'>_1</span></code></td>
+<td><code><span class='Function'>&lt;</span><span class='Head'>;</span><span class='Value'>.</span><span class='Modifier'>_1</span></code></td>
 <td><code><span class='Paren'>((</span><span class='Number'>1</span><span class='Function'>-</span><span class='Modifier'>˜</span><span class='Function'>¬×+</span><span class='Modifier'>`</span><span class='Paren'>)</span><span class='Function'>=</span><span class='Modifier2'>⟜</span><span class='Function'>⊏</span><span class='Modifier2'>⊘</span><span class='Function'>⊣</span><span class='Paren'>)</span><span class='Function'>⊔⊢</span></code></td>
 </tr>
 <tr>
diff --git a/docs/doc/glossary.html b/docs/doc/glossary.html
index 1220fa6c..75048532 100644
--- a/docs/doc/glossary.html
+++ b/docs/doc/glossary.html
@@ -139,8 +139,8 @@
 <li><strong>Block modifier</strong>: A block defining a 1- or 2-modifier.</li>
 <li><strong>Immediate modifier</strong>: A modifier that's evaluated as soon as it receives its operands.</li>
 <li><strong>Deferred modifier</strong>: The opposite of an immediate modifier, one that's only evaluated when called with operands and arguments.</li>
-<li><a href="block.html#block-headers"><strong>Header</strong></a>: A preface to a body in a block function or modifier indicating possible inputs, which is followed by a colon <code><span class='Value'>:</span></code>.</li>
+<li><a href="block.html#block-headers"><strong>Header</strong></a>: A preface to a body in a block function or modifier indicating possible inputs, which is followed by a colon <code><span class='Head'>:</span></code>.</li>
 <li><a href="block.html#short-headers"><strong>Label</strong></a>: A header consisting of a single name.</li>
-<li><strong>Body</strong>: One sequence of statements in a block. Bodies, possibly preceded by headers, are separated by semicolons <code><span class='Value'>;</span></code>.</li>
+<li><strong>Body</strong>: One sequence of statements in a block. Bodies, possibly preceded by headers, are separated by semicolons <code><span class='Head'>;</span></code>.</li>
 <li><strong>Tacit</strong>: Code that defines functions or modifiers without using blocks.</li>
 </ul>
diff --git a/docs/doc/oop.html b/docs/doc/oop.html
index af0daaa2..66df070f 100644
--- a/docs/doc/oop.html
+++ b/docs/doc/oop.html
@@ -71,7 +71,7 @@
   <span class='Function'>View</span> <span class='Gets'>⇐</span> <span class='Brace'>{</span><span class='Value'>𝕤</span>
     <span class='Value'>l</span>
   <span class='Brace'>}</span>
-  <span class='Function'>Move</span> <span class='Gets'>⇐</span> <span class='Brace'>{</span><span class='Value'>from</span><span class='Ligature'>‿</span><span class='Value'>to:</span>
+  <span class='Function'>Move</span> <span class='Gets'>⇐</span> <span class='Brace'>{</span><span class='Value'>from</span><span class='Ligature'>‿</span><span class='Value'>to</span><span class='Head'>:</span>
     <span class='Value'>l</span> <span class='Gets'>↩</span> <span class='Function'>Transfer</span><span class='Modifier'>´</span><span class='Modifier2'>⌾</span><span class='Paren'>(</span><span class='Value'>𝕩</span><span class='Modifier2'>⊸</span><span class='Function'>⊏</span><span class='Paren'>)</span><span class='Modifier2'>⍟</span><span class='Paren'>(</span><span class='Function'>≠</span><span class='Modifier'>´</span><span class='Value'>𝕩</span><span class='Paren'>)</span> <span class='Value'>l</span>
   <span class='Brace'>}</span>
   <span class='Comment'># Move a disk from 𝕨 to 𝕩
@@ -137,7 +137,7 @@
   <span class='Function'>Undo</span> <span class='Gets'>⇐</span> <span class='Value'>t.</span><span class='Function'>Move</span><span class='Modifier2'>∘</span><span class='Function'>⌽</span><span class='Modifier2'>∘</span><span class='Function'>Pop</span>
 <span class='Brace'>}</span>
 </pre>
-<p>This class composes a Tower of Hanoi with an undo stack that stores previous moves. To undo a move from <code><span class='Value'>a</span></code> to <code><span class='Value'>b</span></code>, it moves from <code><span class='Value'>b</span></code> to <code><span class='Value'>a</span></code>, although if you felt really fancy you might define <code><span class='Function'>Move</span><span class='Modifier'>⁼</span></code> in <code><span class='Value'>towerOfHanoi</span></code> instead with <code><span class='Function'>𝕊</span><span class='Modifier'>⁼</span><span class='Value'>𝕩:</span> <span class='Function'>𝕊⌽</span><span class='Value'>𝕩</span></code>.</p>
+<p>This class composes a Tower of Hanoi with an undo stack that stores previous moves. To undo a move from <code><span class='Value'>a</span></code> to <code><span class='Value'>b</span></code>, it moves from <code><span class='Value'>b</span></code> to <code><span class='Value'>a</span></code>, although if you felt really fancy you might define <code><span class='Function'>Move</span><span class='Modifier'>⁼</span></code> in <code><span class='Value'>towerOfHanoi</span></code> instead with <code><span class='Function'>𝕊</span><span class='Modifier'>⁼</span><span class='Value'>𝕩</span><span class='Head'>:</span> <span class='Function'>𝕊⌽</span><span class='Value'>𝕩</span></code>.</p>
 <p>It's also possible to copy several variables and only export some of them, with an export statement. For example, if I wasn't going to make another method called <code><span class='Function'>Move</span></code>, I might have written <code><span class='Function'>View</span><span class='Ligature'>‿</span><span class='Function'>Move</span> <span class='Gets'>←</span> <span class='Value'>towerOfHanoi</span></code> and then <code><span class='Function'>View</span><span class='Gets'>⇐</span></code>. In fact, depending on your personal style and how complicated your classes are, you might prefer to avoid inline <code><span class='Gets'>⇐</span></code> exports entirely, and declare all the exports at the top.</p>
 <h2 id="self-reference"><a class="header" href="#self-reference">Self-reference</a></h2>
 <p>An object's class is given by <code><span class='Function'>𝕊</span></code>. Remember, a class is an ordinary BQN function! It might be useful for an object to produce another object of the same class (particularly if it's immutable), and an object might also expose a field <code><span class='Value'>class</span><span class='Gets'>⇐</span><span class='Value'>𝕤</span></code> to test whether an object <code><span class='Value'>o</span></code> belongs to a class <code><span class='Value'>c</span></code> with <code><span class='Value'>o.class</span> <span class='Function'>=</span> <span class='Value'>c</span></code>.</p>
diff --git a/docs/doc/pair.html b/docs/doc/pair.html
index a4bf9b75..12165060 100644
--- a/docs/doc/pair.html
+++ b/docs/doc/pair.html
@@ -62,4 +62,4 @@
 <a class="replLink" title="Open in the REPL" target="_blank" href="https://mlochbaum.github.io/BQN/try.html#code=NCDihpEgImEi4oC/NSDii4ggImIi4oC/Nw==">↗️</a><pre>    <span class='Number'>4</span> <span class='Function'>↑</span> <span class='String'>&quot;a&quot;</span><span class='Ligature'>‿</span><span class='Number'>5</span> <span class='Function'>⋈</span> <span class='String'>&quot;b&quot;</span><span class='Ligature'>‿</span><span class='Number'>7</span>
 ⟨ ⟨ "a" 5 ⟩ ⟨ "b" 7 ⟩ ⟨ " " 0 ⟩ ⟨ " " 0 ⟩ ⟩
 </pre>
-<p>This means that <code><span class='Function'>⋈</span></code> may always behave the same as the obvious implementation <code><span class='Brace'>{</span><span class='Bracket'>⟨</span><span class='Value'>𝕩</span><span class='Bracket'>⟩</span><span class='Value'>;</span><span class='Bracket'>⟨</span><span class='Value'>𝕨</span><span class='Separator'>,</span><span class='Value'>𝕩</span><span class='Bracket'>⟩</span><span class='Brace'>}</span></code>. However, <code><span class='Function'>≍</span><span class='Modifier2'>○</span><span class='Function'>&lt;</span></code> and even <code><span class='Function'>&gt;</span><span class='Modifier2'>∘</span><span class='Brace'>{</span><span class='Bracket'>⟨</span><span class='Value'>𝕩</span><span class='Bracket'>⟩</span><span class='Value'>;</span><span class='Bracket'>⟨</span><span class='Value'>𝕨</span><span class='Separator'>,</span><span class='Value'>𝕩</span><span class='Bracket'>⟩</span><span class='Brace'>}</span><span class='Modifier2'>○</span><span class='Function'>&lt;</span></code> compute the result fill as <code><span class='Function'>⋈</span></code> does and are identical implementations.</p>
+<p>This means that <code><span class='Function'>⋈</span></code> may always behave the same as the obvious implementation <code><span class='Brace'>{</span><span class='Bracket'>⟨</span><span class='Value'>𝕩</span><span class='Bracket'>⟩</span><span class='Head'>;</span><span class='Bracket'>⟨</span><span class='Value'>𝕨</span><span class='Separator'>,</span><span class='Value'>𝕩</span><span class='Bracket'>⟩</span><span class='Brace'>}</span></code>. However, <code><span class='Function'>≍</span><span class='Modifier2'>○</span><span class='Function'>&lt;</span></code> and even <code><span class='Function'>&gt;</span><span class='Modifier2'>∘</span><span class='Brace'>{</span><span class='Bracket'>⟨</span><span class='Value'>𝕩</span><span class='Bracket'>⟩</span><span class='Head'>;</span><span class='Bracket'>⟨</span><span class='Value'>𝕨</span><span class='Separator'>,</span><span class='Value'>𝕩</span><span class='Bracket'>⟩</span><span class='Brace'>}</span><span class='Modifier2'>○</span><span class='Function'>&lt;</span></code> compute the result fill as <code><span class='Function'>⋈</span></code> does and are identical implementations.</p>
diff --git a/docs/doc/primitive.html b/docs/doc/primitive.html
index 05cb3dbc..2f39dda5 100644
--- a/docs/doc/primitive.html
+++ b/docs/doc/primitive.html
@@ -468,7 +468,7 @@
 <tr>
 <td><code><span class='Modifier2'>⊘</span></code></td>
 <td>Valences</td>
-<td><code><span class='Brace'>{</span><span class='Function'>𝔽</span><span class='Value'>𝕩;𝕨</span><span class='Function'>𝔾</span><span class='Value'>𝕩</span><span class='Brace'>}</span></code></td>
+<td><code><span class='Brace'>{</span><span class='Function'>𝔽</span><span class='Value'>𝕩</span><span class='Head'>;</span><span class='Value'>𝕨</span><span class='Function'>𝔾</span><span class='Value'>𝕩</span><span class='Brace'>}</span></code></td>
 <td>Apply <code><span class='Function'>𝔽</span></code> if there's one argument but <code><span class='Function'>𝔾</span></code> if there are two</td>
 </tr>
 <tr>
diff --git a/docs/doc/rebqn.html b/docs/doc/rebqn.html
index 81a00418..932a647f 100644
--- a/docs/doc/rebqn.html
+++ b/docs/doc/rebqn.html
@@ -75,4 +75,4 @@
 ⟨ 0 1 2 0 ⟩
 </pre>
 <p>Above, <code><span class='Value'>^</span></code> becomes a 1-modifier, so that it modifies <code><span class='Value'>%</span></code> rather than being called directly on <code><span class='Number'>1</span><span class='Ligature'>‿</span><span class='Number'>2</span></code> as a function.</p>
-<p>The glyph can be any character that's not being used by BQN already. Characters like <code><span class='Value'>c</span></code> or <code><span class='Bracket'>⟩</span></code> or <code><span class='Value'>:</span></code> will result in an error, as they'd break BQN syntax. Other than that, the sky's the limit! Or rather, the Unicode consortium is the limit. If they don't recognize your symbol, you're going to have to petition to make it an emoji or something. Oh well.</p>
+<p>The glyph can be any character that's not being used by BQN already. Characters like <code><span class='Value'>c</span></code> or <code><span class='Bracket'>⟩</span></code> or <code><span class='Head'>:</span></code> will result in an error, as they'd break BQN syntax. Other than that, the sky's the limit! Or rather, the Unicode consortium is the limit. If they don't recognize your symbol, you're going to have to petition to make it an emoji or something. Oh well.</p>
diff --git a/docs/doc/syntax.html b/docs/doc/syntax.html
index 6eed337e..460fc460 100644
--- a/docs/doc/syntax.html
+++ b/docs/doc/syntax.html
@@ -69,15 +69,15 @@
 <td><a href="#blocks">Block</a> such as a function definition</td>
 </tr>
 <tr>
-<td><code><span class='Value'>:</span></code></td>
+<td><code><span class='Head'>:</span></code></td>
 <td><a href="block.html#block-headers">Block header</a></td>
 </tr>
 <tr>
-<td><code><span class='Value'>;</span></code></td>
+<td><code><span class='Head'>;</span></code></td>
 <td><a href="block.html#multiple-bodies">Block body separator</a></td>
 </tr>
 <tr>
-<td><code><span class='Value'>?</span></code></td>
+<td><code><span class='Head'>?</span></code></td>
 <td><a href="block.html#predicates">Predicate</a></td>
 </tr>
 <tr>
@@ -140,7 +140,7 @@
 <tbody>
 <tr>
 <td><code><span class='Function'>↕</span> <span class='Number'>10</span></code></td>
-<td><code><span class='Value'>w?</span></code></td>
+<td><code><span class='Value'>w</span><span class='Head'>?</span></code></td>
 <td><code><span class='Function'>F</span></code></td>
 <td><code><span class='Value'>x</span></code></td>
 <td>Subject</td>
@@ -149,7 +149,7 @@
 </tr>
 <tr>
 <td><code><span class='Function'>+</span> <span class='Function'>⋈</span> <span class='Function'>-</span></code></td>
-<td><code><span class='Function'>F</span><span class='Value'>?</span></code></td>
+<td><code><span class='Function'>F</span><span class='Head'>?</span></code></td>
 <td><code><span class='Function'>G</span></code></td>
 <td><code><span class='Function'>H</span></code></td>
 <td>Function</td>
diff --git a/docs/doc/undo.html b/docs/doc/undo.html
index f2082a10..3a2ddcba 100644
--- a/docs/doc/undo.html
+++ b/docs/doc/undo.html
@@ -45,8 +45,8 @@
 <h2 id="undo-headers"><a class="header" href="#undo-headers">Undo headers</a></h2>
 <p>Of course BQN will never be able to invert all the functions you could write (if it could you could earn a <em>lot</em> of bitcoins, among other feats). But it does recognize some <a href="block.html#block-headers">header</a> forms that you can use to specify the inverse of a block function. BQN will trust you and won't verify the results your specified inverse gives.</p>
 <pre><span class='Brace'>{</span>
-  <span class='Function'>𝕊</span><span class='Value'>𝕩:</span>  <span class='Value'>𝕩</span><span class='Function'>÷</span><span class='Number'>1</span><span class='Function'>+</span><span class='Value'>𝕩</span> <span class='Value'>;</span>
-  <span class='Function'>𝕊</span><span class='Modifier'>⁼</span><span class='Value'>𝕩:</span> <span class='Value'>𝕩</span><span class='Function'>÷</span><span class='Number'>1</span><span class='Function'>-</span><span class='Value'>𝕩</span>
+  <span class='Function'>𝕊</span><span class='Value'>𝕩</span><span class='Head'>:</span>  <span class='Value'>𝕩</span><span class='Function'>÷</span><span class='Number'>1</span><span class='Function'>+</span><span class='Value'>𝕩</span> <span class='Head'>;</span>
+  <span class='Function'>𝕊</span><span class='Modifier'>⁼</span><span class='Value'>𝕩</span><span class='Head'>:</span> <span class='Value'>𝕩</span><span class='Function'>÷</span><span class='Number'>1</span><span class='Function'>-</span><span class='Value'>𝕩</span>
 <span class='Brace'>}</span>
 </pre>
 <p>The above function could also be defined with the automatically invertible <code><span class='Number'>1</span><span class='Modifier2'>⊸</span><span class='Function'>+</span><span class='Modifier2'>⌾</span><span class='Function'>÷</span></code>, but maybe there's a numerical reason to use the definition above. Like a normal header, an undo header reflects the normal use, but it includes <code><span class='Modifier'>⁼</span></code> and possibly <code><span class='Modifier'>˜</span></code> addition to the function and arguments.</p>