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

1 files changed, 28 insertions, 28 deletions

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>