@@ -22,7 +22,7 @@ maps poorly onto its semantics. For example, although Hoon is a
2222typed language, the term "type" is not formally defined in Hoon.
2323"Type" is a great word, but Hoon has three separate concepts
2424which could comfortably claim it. We say "type" all the time; we
25−mean `span`, or `mold`, or `mark`, or possibly all three.
25+mean [`span`](#span), or `mold`, or `mark`, or possibly all three.
2626
2727Other common programming concepts used only informally in Hoon
2828are "function," "object," "event," "expression," "variable,"
@@ -38,8 +38,8 @@ a few new words is a small price for avoiding this pain point.
3838## Concepts
3939
4040A few major Hoon concepts: `noun` (data), `nock` (interpreter),
41−`mint` (compiler), `span` (type), `twig` (expression), `gate`
42−(function), `mold` (constructor), `core` (object), `mark`
41+[`mint`](#mint) (compiler), [`span`](#span) (type), [`twig`](#twig) (expression),
42+`gate` (function), `mold` (constructor), `core` (object), `mark`
4343(protocol).
4444
4545### `noun` (data value)
@@ -82,11 +82,11 @@ it's still fun and useful to [learn more](../../nock).
8282
8383## Compilation concepts
8484
85−### `mint` (compiler)
85+### <a name="mint">`mint`</a> (compiler)
8686
87−[`mint`](mint) is the Hoon compiler. It maps a cell `{span twig}` to a
88−cell `{span nock}`, where a `span` is a type, a `twig` is a compiled
89−expression (AST), and a `nock` is a Nock formula. `mint` accepts
87+[`mint`](#mint) is the Hoon compiler. It maps a cell `{span twig}` to a
88+cell `{span nock}`, where a [`span`](#span) is a type, a [`twig`](#twig)
89+is a compiled expression (AST), and a `nock` is a Nock formula. `mint` accepts
9090a subject type and a source expression; it produces a product type
9191and an executable formula.
9292
@@ -105,9 +105,9 @@ which makes your program more readable anyway. Also, the dumber
105105the compiler, the easier it is for a dumb human to understand
106106what the compiler is thinking.
107107
108−### `twig` (expression)
108+### <a name="twig">`twig`</a> (expression)
109109
110−A [`twig`](twig) is a Hoon AST node, the result of parsing a
110+A [`twig`](../reference) is a Hoon AST node, the result of parsing a
111111source expression. A Hoon source file encodes one twig.
112112
113113As the noun that the parser produces, a twig is a tagged union of
@@ -146,12 +146,12 @@ or the tall rune syntax (here on one line, with double spaces):
146146%- a b
147147```
148148
149−### `span` (type, as range)
149+### <a name="span">`span`</a> (type, as range)
150150
151−A [`span`](span) is a Hoon type. It defines a set (finite or
151+A `span` is a Hoon type. It defines a set (finite or
152152infinite) of nouns and ascribes some semantics to it. There is
153153no syntax for spans; they are always defined by inference (ie, by
154−`mint`), usually using a constructor (`mold`).
154+[`mint`](#mint)), usually using a constructor (`mold`).
155155
156156### `gate` (function)
157157
@@ -179,7 +179,7 @@ A `mold` is a constructor function (`gate`). Its sample is any
179179noun; its product is a structured noun. A mold is idempotent;
180180`(mold (mold x))` always equals `(mold x)`.
181181
182−Since there's no such thing as a span declaration, we use molds
182+Since there's no such thing as a [`span`](#span) declaration, we use molds
183183to define useful spans by example; we also use them to validate
184184untrusted network input.
185185
@@ -193,19 +193,19 @@ The Hoon equivalent is `:var foo atom`. But Hoon has a
193193homoiconic heap; there is no inscrutable scope or environment.
194194There is just the subject, which is one noun. To "declare a
195195variable" is to make a cell `[variable old-subject]`, and use it
196−as the subject of the twig below.
196+as the subject of the [`twig`](#twig) below.
197197
198−So the label `foo` isn't a key in a symbol table; it's in the
199−type (`span`) of the new value. It's not a variable named `foo`,
198+So the labe[`twig`](#twig)l `foo` isn't a key in a symbol table; it's in the
199+type ([`span`](#span)) of the new value. It's not a variable named `foo`,
200200whose value is of type `atom`; it's a subtree of type `foo:atom`.
201201
202−### `limb` (attribute or variable reference)
202+### <a name="limb">`limb`</a> (attribute or variable reference)
203203
204204A [`limb`](../twig/limb/limb), like `foo`, is Hoon's equivalent of a variable
205−reference. A limb is a twig; given a subject span, `mint`
206−resolves it to a Nock formula and a product span.
205+reference. A limb is a [`twig`](#twig); given a subject [`span`](#span),
206+[`mint`](#mint) resolves it to a Nock formula and a product [`span`](#span).
207207
208−To resolve limb `foo`, `mint` searches the subject depth-first,
208+To resolve limb `foo`, [`mint`](#mint) searches the subject depth-first,
209209head-first for either a `face` named `foo`, or a `core` with the
210210arm `foo`. If it finds a face, the product is a *leg*, or
211211subtree of the subject. If it finds a core, it computes the arm
@@ -213,7 +213,7 @@ formula with that core as the subject.
213213
214214A limb can also be a slot (direct tree address), like `+15`.
215215
216−### `wing` (limb path)
216+### `wing` ([`limb`](#limb) path)
217217
218218A [wing](../twig/limb/wing) is a list of limbs. Like attribute references in a
219219conventional language, it uses the syntax `a.b.c`, but inside