Add infoboxes to introduce glyphs in tutorials

2 files changed, 196 insertions, 0 deletions

diff --git a/docs/tutorial/expression.html b/docs/tutorial/expression.html
index 7669df1a..bb5fc9d6 100644
--- a/docs/tutorial/expression.html
+++ b/docs/tutorial/expression.html
@@ -15,6 +15,21 @@
     <span class='Function'>-</span> <span class='Number'>1.5</span>
 ¯1.5
 </pre>
+<table class='primitives'>
+  <tr>
+    <td><span class='Function'>+</span></td>
+    <td></td>
+    <td></td>
+    <td>Add</td>
+  </tr>
+  <tr>
+    <td><span class='Function'>-</span></td>
+    <td></td>
+    <td>Negate</td>
+    <td>Subtract</td>
+  </tr>
+</table>
+
 <p>Shown above are a few arithmetic operations. BQN manages to pass as a normal programming language for three lines so far. That's a big accomplishment for BQN! Earth's a confusing place!</p>
 <p>The number of spaces between <em>primitive functions</em> like <code><span class='Function'>+</span></code> and <code><span class='Function'>-</span></code> and their <em>arguments</em> doesn't matter: you can use as much or as little as you like. No spaces inside numbers, of course.</p>
 <a class="replLink" title="Open in the REPL" target="_blank" href="https://mlochbaum.github.io/BQN/try.html#code=MiDDlyDPgAo5IMO3IDIKw7cg4oie&run">↗️</a><pre>    <span class='Number'>2</span> <span class='Function'>×</span> <span class='Number'>π</span>
@@ -24,6 +39,31 @@
     <span class='Function'>÷</span> <span class='Number'>∞</span>
 0
 </pre>
+<table class='primitives'>
+  <tr>
+    <td><span class='Function'>×</span></td>
+    <td><kbd>\=</kbd></td>
+    <td></td>
+    <td>Multiply</td>
+  </tr>
+  <tr>
+    <td><span class='Function'>÷</span></td>
+    <td><kbd>\-</kbd></td>
+    <td>Reciprocal</td>
+    <td>Divide</td>
+  </tr>
+  <tr>
+    <td><span class='Number'>π</span></td>
+    <td><kbd>\p</kbd></td>
+    <td colspan='2'>Pi</td>
+  </tr>
+  <tr>
+    <td><span class='Number'>∞</span></td>
+    <td><kbd>\8</kbd></td>
+    <td colspan='2'>Infinity</td>
+  </tr>
+</table>
+
 <p>Okay, now BQN looks like normal (grade-school) mathematics, which is sort of like looking normal. Pi (<code><span class='Number'>π</span></code>) represents <a href="https://en.wikipedia.org/wiki/Pi">that real famous number</a> and Infinity (<code><span class='Number'>∞</span></code>) is also part of the number system (the BQN spec allows an implementation to choose its number system, and all existing implementations use double-precision floats, like Javascript or Lua). In analogy with the one-argument form of Minus (<code><span class='Function'>-</span></code>) giving the negation of a number, Divide (<code><span class='Function'>÷</span></code>) with only one argument gives its reciprocal.</p>
 <p>A number can be raised to the power of another with Power, written <code><span class='Function'>⋆</span></code>. That's a star rather than an asterisk; BQN doesn't use the asterisk symbol. If it's called without a left argument, then <code><span class='Function'>⋆</span></code> uses a base of <a href="https://en.wikipedia.org/wiki/E_(mathematical_constant)">Euler's number</a> <em>e</em> and is called Exponential.</p>
 <a class="replLink" title="Open in the REPL" target="_blank" href="https://mlochbaum.github.io/BQN/try.html#code=MiDii4YgMwozIOKLhiAyCuKLhiAxICAgIyBUaGVyZSdzIG5vIGNvbnN0YW50IGZvciBlIGJ1dCB5b3UgY2FuIGdldCBpdCB0aGlzIHdheQrii4YgMi4z&run">↗️</a><pre>    <span class='Number'>2</span> <span class='Function'>⋆</span> <span class='Number'>3</span>
@@ -35,6 +75,21 @@
     <span class='Function'>⋆</span> <span class='Number'>2.3</span>
 9.97418245481472
 </pre>
+<table class='primitives'>
+  <tr>
+    <td><span class='Function'>⋆</span></td>
+    <td><kbd>\+</kbd></td>
+    <td>Exponential</td>
+    <td>Power</td>
+  </tr>
+  <tr>
+    <td><span class='Function'>√</span></td>
+    <td><kbd>\_</kbd></td>
+    <td>Square Root</td>
+    <td>Root</td>
+  </tr>
+</table>
+
 <p>You could use Power to take square roots and <em>n</em>-th roots, but BQN also provides the primitive <code><span class='Function'>√</span></code> for this purpose. If no left argument is provided, then it is the Square Root function; with a left argument it is called Root and raises the right argument to the power of one divided by the left argument.</p>
 <a class="replLink" title="Open in the REPL" target="_blank" href="https://mlochbaum.github.io/BQN/try.html#code=4oiaIDIKMyDiiJogMjc=&run">↗️</a><pre>    <span class='Function'>√</span> <span class='Number'>2</span>
 1.4142135623731
@@ -208,6 +263,19 @@
     <span class='String'>@</span> <span class='Function'>+</span> <span class='Number'>97</span>
 'a'
 </pre>
+<table class='primitives'>
+  <tr>
+    <td><span class='String'>'</span></td>
+    <td></td>
+    <td colspan='2'>Character</td>
+  </tr>
+  <tr>
+    <td><span class='String'>@</span></td>
+    <td></td>
+    <td colspan='2'>Null character</td>
+  </tr>
+</table>
+
 <p>It's a convenient way to write non-printing characters without having to include them in your source code: for example <code><span class='String'>@</span><span class='Function'>+</span><span class='Number'>10</span></code> is the newline character.</p>
 <p>Addition and subtraction with affine characters have all the same algebraic properties that they do with numbers. One way to see this is to think of values as a combination of &quot;characterness&quot; (0 for numbers and 1 for characters) and either numeric value or code point. Addition and subtraction are done element-wise on these pairs of numbers, and are allowed if the result is a valid value, that is, its characterness is 0 or 1 and its value is a valid code point if the characterness is 1. However, because the space of values is no longer closed under addition and subtraction, certain rearrangements of valid computations might not be valid, if one of the values produced in the middle isn't legal.</p>
 <h2 id="modifiers">Modifiers</h2>
@@ -224,6 +292,25 @@
 16
 </pre>
 <p>What's wrong with <code><span class='Number'>4</span><span class='Function'>⋆</span><span class='Number'>2</span></code>? Depends on the context. Because of the way evaluation flows from right to left, it's usually best if the right argument to a function is the one that's being manipulated directly while the left argument is sort of a &quot;control value&quot; that describes how to manipulate it. That way several manipulations can be done in a row without any parentheses required. <code><span class='Function'>⋆</span></code> can go either way, but if &quot;squaring&quot; is the operation being done then the <em>left</em> argument is one being squared, so it's the active value. The Swap modifier allows us to put it on the right instead.</p>
+<table class='primitives'>
+  <tr>
+    <td><span class='Modifier'>˜</span></td>
+    <td><kbd>\`</kbd></td>
+    <td>Swap</td>
+    <td>Self</td>
+  </tr>
+  <tr>
+    <td><span class='Modifier'>⁼</span></td>
+    <td><kbd>\3</kbd></td>
+    <td colspan='2'>Undo</td>
+  </tr>
+  <tr>
+    <td><span class='Modifier'>˙</span></td>
+    <td><kbd>\"</kbd></td>
+    <td colspan='2'>Constant</td>
+  </tr>
+</table>
+
 <p>Another 1-modifier is Undo (<code><span class='Modifier'>⁼</span></code>). BQN has just enough computer algebra facilities to look like a tool for Neanderthals next to a real computer algebra system, and among them is the ability to invert some primitives. In general you can't be sure when Undo will work (it might even be undecidable), but the examples I'll give here are guaranteed by <a href="../spec/inferred.html#undo">the spec</a> to always work in the same way. Starting with a <em>third</em> way to square a number:</p>
 <a class="replLink" title="Open in the REPL" target="_blank" href="https://mlochbaum.github.io/BQN/try.html#code=4oia4oG8IDQ=&run">↗️</a><pre>    <span class='Function'>√</span><span class='Modifier'>⁼</span> <span class='Number'>4</span>
 16
@@ -251,6 +338,14 @@
     <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='Number'>5</span>  <span class='Comment'># Negative square of 5
 </span>¯25
 </pre>
+<table class='primitives'>
+  <tr>
+    <td><span class='Modifier2'>∘</span></td>
+    <td><kbd>\j</kbd></td>
+    <td colspan='2'>Atop</td>
+  </tr>
+</table>
+
 <p>It's past time we covered how the syntax for modifiers works. Remember how I told you you hated learning the order of operations? No? Good. Modifiers bind more tightly than functions, so they are called on their operands before their operands can be used. As the parentheses above suggest, modifiers also associate from left to right, the opposite order as functions. For example, the first expression above is evaluated in the order shown below. First we construct the square function <code><span class='Function'>×</span><span class='Modifier'>˜</span></code>, then compose it with <code><span class='Function'>+</span></code>, and finally apply the result to some arguments.</p>
 <pre> <span class='Function'>=</span>    <span class='Function'>×</span><span class='Modifier'>˜</span>
         <span class='Modifier2'>∘</span><span class='Function'>+</span>
diff --git a/docs/tutorial/list.html b/docs/tutorial/list.html
index 3a389d42..deae0f11 100644
--- a/docs/tutorial/list.html
+++ b/docs/tutorial/list.html
@@ -18,6 +18,34 @@
 <p>There are three kinds of list notation in BQN. Every one has a subject role, even though expressions used inside it might have other roles. First, a <em>string</em> is a list of characters, and is written by placing those characters in double quotes.</p>
 <pre><span class='String'>&quot;Text!&quot;</span>
 </pre>
+<table class='primitives'>
+  <tr>
+    <td><span class='String'>"</span></td>
+    <td></td>
+    <td colspan='2'>String</td>
+  </tr>
+  <tr>
+    <td><span class='Bracket'>⟨</span></td>
+    <td><kbd>\(</kbd></td>
+    <td colspan='2'>Start list</td>
+  </tr>
+  <tr>
+    <td><span class='Bracket'>⟩</span></td>
+    <td><kbd>\)</kbd></td>
+    <td colspan='2'>End list</td>
+  </tr>
+  <tr>
+    <td><span class='Separator'>⋄</span></td>
+    <td><kbd>\;</kbd></td>
+    <td colspan='2'>Separator</td>
+  </tr>
+  <tr>
+    <td><span class='Separator'>,</span></td>
+    <td></td>
+    <td colspan='2'>Separator</td>
+  </tr>
+</table>
+
 <p>Only one character needs to be escaped to place it in a string: the double quote, which is escaped by writing it twice. Any other character, including a newline, can be placed directly in a string.</p>
 <p>Second, <em>list notation</em> uses angle brackets <code><span class='Bracket'>⟨⟩</span></code>. The <em>elements</em> in the list are kept apart with one of the three <em>separator</em> characters: <code><span class='Separator'>,</span></code>, <code><span class='Separator'>⋄</span></code>, and newline. Anything can be used as an element, even a function, or a modifier like <code><span class='Modifier2'>∘</span></code>. Here's a list containing a number, a 2-modifier, a string, and a non-string list:</p>
 <pre><span class='Bracket'>⟨</span> <span class='Number'>π</span><span class='Separator'>,</span> <span class='Modifier2'>∘</span><span class='Separator'>,</span> <span class='String'>&quot;element&quot;</span> <span class='Separator'>⋄</span> <span class='Bracket'>⟨</span><span class='String'>'l'</span><span class='Separator'>,</span><span class='Number'>1</span><span class='Separator'>,</span><span class='Number'>5</span><span class='Separator'>,</span><span class='String'>'t'</span><span class='Bracket'>⟩</span> <span class='Bracket'>⟩</span>
@@ -32,6 +60,19 @@
 </span>  <span class='String'>&quot;lines&quot;</span>
 <span class='Bracket'>⟩</span>
 </pre>
+<table class='primitives'>
+  <tr>
+    <td><span class='Comment'>#</span></td>
+    <td></td>
+    <td colspan='2'>Comment</td>
+  </tr>
+  <tr>
+    <td><span class='Ligature'>‿</span></td>
+    <td><kbd>\ </kbd></td>
+    <td colspan='2'>Strand</td>
+  </tr>
+</table>
+
 <p>Finally, <em>strand notation</em> is a shortcut for simple lists like a few numbers. It's written with the <em>ligature</em> <code><span class='Ligature'>‿</span></code>, which has a higher precedence than either functions or operators. A sequence of values joined with ligatures becomes a list, so that for example the following two expressions are equivalent:</p>
 <pre><span class='Bracket'>⟨</span><span class='Number'>2</span><span class='Separator'>,</span><span class='Function'>+</span><span class='Separator'>,</span><span class='Function'>-</span><span class='Bracket'>⟩</span>
 <span class='Number'>2</span><span class='Ligature'>‿</span><span class='Function'>+</span><span class='Ligature'>‿</span><span class='Function'>-</span>
@@ -92,6 +133,27 @@
 ⟨ ⟨ 11 12 ⟩ ⟨ 23 33 ⟩ ⟩
 </pre>
 <h2 id="some-list-functions">Some list functions</h2>
+<table class='primitives'>
+  <tr>
+    <td><span class='Function'>≍</span></td>
+    <td><kbd>\.</kbd></td>
+    <td>Solo</td>
+    <td>Couple</td>
+  </tr>
+  <tr>
+    <td><span class='Function'>∾</span></td>
+    <td><kbd>\,</kbd></td>
+    <td></td>
+    <td>Join To</td>
+  </tr>
+  <tr>
+    <td><span class='Function'>⌽</span></td>
+    <td><kbd>\q</kbd></td>
+    <td>Reverse</td>
+    <td>Rotate</td>
+  </tr>
+</table>
+
 <p>Let's introduce a few primitives to work with lists.</p>
 <p>Make one or two atom arguments into a list with <code><span class='Function'>≍</span></code>, pronounced Solo in the one-argument case and Couple in the two-argument case. This might not seem to merit a symbol but there's more to come. Don't call it on lists and ponder the results, igniting a hunger for ever more dimensions.</p>
 <a class="replLink" title="Open in the REPL" target="_blank" href="https://mlochbaum.github.io/BQN/try.html#code=4omNIDQKCjIg4omNIDQ=&run">↗️</a><pre>    <span class='Function'>≍</span> <span class='Number'>4</span>
@@ -122,6 +184,25 @@
 "abcde"
 </pre>
 <h3 id="and-modifiers">…and modifiers</h3>
+<table class='primitives'>
+  <tr>
+    <td><span class='Modifier'>¨</span></td>
+    <td><kbd>\1</kbd></td>
+    <td colspan='2'>Each</td>
+  </tr>
+  <tr>
+    <td><span class='Modifier'>´</span></td>
+    <td><kbd>\5</kbd></td>
+    <td colspan='2'>Fold</td>
+  </tr>
+  <tr>
+    <td><span class='Function'>∾</span></td>
+    <td><kbd>\,</kbd></td>
+    <td>Join</td>
+    <td>Join To</td>
+  </tr>
+</table>
+
 <p>The 1-modifier Each (<code><span class='Modifier'>¨</span></code>) applies its operand to every element of a list argument: it's the same as <code><span class='Value'>map</span></code> in a functional programming language. With two list arguments (which have to have the same length), Each pairs the corresponding elements from each, a bit like a <code><span class='Value'>zip</span></code> function. If one argument is a list and one's an atom, the atom is reused every time instead.</p>
 <a class="replLink" title="Open in the REPL" target="_blank" href="https://mlochbaum.github.io/BQN/try.html#code=4oy9wqggImFiY2Qi4oC/IkFCQ0RFRiLigL8iMDEiCgoic3RyaW5nIuKAvyJsaXN0IuKAvyJhcnJheSIg4oi+wqggJ3MnCgoiYWJjIiDiiY3CqCDijL0gImFiYyI=&run">↗️</a><pre>    <span class='Function'>⌽</span><span class='Modifier'>¨</span> <span class='String'>&quot;abcd&quot;</span><span class='Ligature'>‿</span><span class='String'>&quot;ABCDEF&quot;</span><span class='Ligature'>‿</span><span class='String'>&quot;01&quot;</span>
 ⟨ "dcba" "FEDCBA" "10" ⟩
@@ -156,6 +237,21 @@
 </pre>
 <h2 id="example-base-decoding">Example: base decoding</h2>
 <p>Some people like to imagine that robots or other techno-beings speak entirely in binary-encoded ASCII, like for instance &quot;01001110 01100101 01110010 01100100 00100001&quot;. This is dumb for a lot of reasons, and the encoded text probably just says something inane, but you're a slave to curiosity and can't ignore it. Are one and a half tutorials of BQN enough to clear your conscience?</p>
+<table class='primitives'>
+  <tr>
+    <td><span class='Function'>↕</span></td>
+    <td><kbd>\d</kbd></td>
+    <td>Range</td>
+    <td></td>
+  </tr>
+  <tr>
+    <td><span class='Modifier2'>⊸</span></td>
+    <td><kbd>\h</kbd></td>
+    <td>Bind?</td>
+    <td></td>
+  </tr>
+</table>
+
 <p>Almost. It's really close. There are just two things missing, so I'll cover those and can we agree one and three-quarters is pretty good? First is Range (<code><span class='Function'>↕</span></code>), which is called on a number to give all the natural numbers less than it:</p>
 <a class="replLink" title="Open in the REPL" target="_blank" href="https://mlochbaum.github.io/BQN/try.html#code=4oaVIDg=&run">↗️</a><pre>    <span class='Function'>↕</span> <span class='Number'>8</span>
 ⟨ 0 1 2 3 4 5 6 7 ⟩
@@ -275,6 +371,11 @@ ERROR</pre>
 <td>Rotate</td>
 </tr>
 <tr>
+<td><code><span class='Function'>↕</span></code></td>
+<td></td>
+<td>Range</td>
+</tr>
+<tr>
 <td><code><span class='Modifier'>¨</span></code></td>
 <td>Each</td>
 <td>Each</td>