To make Nock make sense, let's work through the spec line by line. First the data model:
A noun is an atom or a cell. An atom is any natural number. A cell is any ordered pair of nouns.
Nouns are the dumbest data model ever. Nouns make JSON look like XML and XML look like ASN.1. It may also remind you of Lisp's S-expressions - you can think of nouns as "S-expressions without the S."
To be exact, a noun is an S-expression, except that classic S-expressions have multiple atom types ("S" is for "symbol"). Since Nock is designed to be used with a higher-level type system (such as Hoon's), it does not need low-level types. An atom is just an unsigned integer of any size.
For instance, it's common to represent strings (or even whole
text files) as atoms, arranging them LSB first - so "foo" becomes
0x6f6f66. How do we know to print this as "foo", not
We need external information - such as a Hoon type. Similarly,
other common atomic types - signed integers, floating point, etc
- are all straightforward to map into atoms.
It's also important to note that, unlike Lisp, Nock cannot create
cyclical data structures. It is normal and common for nouns in a
Nock runtime system to have acyclic structure - shared subtrees.
But there is no Nock computation that can make a child point to
its parent. One consequence: Nock has no garbage collector.
(Nor can dag structure be detected, as with Lisp
There is also no single syntax for nouns. If you have nouns you have Nock; if you have Nock you have Hoon; if you have Hoon, you can write whatever parser you like.
It's important to recognize that the pseudocode of the Nock spec is just that: pseudocode. It looks a little like Hoon. It isn't Hoon - it's just pseudocode. Or in other words, just English. At the bottom of every formal system is a system of axioms, which can only be written in English. (Why pseudocode, not Hoon? Since Hoon is defined in Nock, this would only give a false impression of nonexistent precision.)
The logic of this pseudocode is a pattern-matching reduction, matching from the top down. To compute Nock, repeatedly reduce with the first line that matches. Let's jump right in!
Nock is a pure (stateless) function from noun to noun. In our
pseudocode (and only in our pseudocode) we express this with the
This function is defined for every noun, but on many nouns it
does nothing useful. For instance, if
a is an atom,
*a. In theory, this means that Nock spins
forever in an infinite loop. In other words, Nock produces no
result - and in practice, your interpreter will stop.
(Another way to see this is that Nock has "crash-only" semantics.
There is no exception mechanism. The only way to catch Nock
errors is to simulate Nock in a higher-level virtual Nock -
which, in fact, we do all the time. A simulator (or a practical
low-level interpreter) can report, out of band, that Nock would
not terminate. It cannot recognize all infinite loops, of
course, but it can catch the obvious ones - like
nock(a) is a cell
[s f], or as we say
Intuitively, the formula is your function and the subject is
its argument. We call them something different because Hoon,
or any other high-level language built on Nock, will build its
own function calling convention which does not map directly
[a b c] [a [b c]]
Ie, brackets (in our pseudocode, as in Hoon) associate to the right. For those with Lisp experience, it's important to note that Nock and Hoon use tuples or "improper lists" much more heavily than Lisp. The list terminator, normally 0, is never automatic. So the Lisp list
(a b c)
becomes the Nock noun
[a b c 0]
which is equivalent to
[a [b [c 0]]]
Note that we can and do use unnecessary brackets anyway, for emphasis. Let's move on to the axiomatic functions:
?[a b] 0 ?a 1 +[a b] +[a b] +a 1 + a =[a a] 0 =[a b] 1
Here we define more pseudocode operators, which we'll use in
reductions further down. So far we have four built-in functions:
* meaning Nock itself,
? testing whether a noun is a cell or
+ incrementing an atom, and
= testing for equality.
Again, no rocket science here.
We should note that in Nock and Hoon,
0 (pronounced "yes") is
1 ("no") is false. Why? As in Unix, using zero for
success generalizes smoothly to multiple error codes. And it's
strange for success not to equal truth. Or at least, this is
our official excuse.
/[1 a] a /[2 a b] a /[3 a b] b /[(a + a) b] /[2 /[a b]] /[(a + a + 1) b] /[3 /[a b]]
Slightly more interesting is our tree numbering. Every noun is
of course a tree. The
/ operator - pronounced "slot" - imposes
an address space on that tree, mapping every nonzero atom to a
1 is the root. The head of every node
2n; the tail is
2n+1. Thus a simple tree:
1 2 3 4 5 6 7 14 15
If the value of every leaf is its tree address, this tree is
[[4 5] [6 14 15]]
and, for some examples of addressing:
/[1 [[4 5] [6 14 15]]]
[[4 5] [6 14 15]]
/[2 [[4 5] [6 14 15]]]
/[3 [[4 5] [6 14 15]]]
[6 14 15], and
/[7 [[4 5] [6 14 15]]]
Hopefully this isn't terribly hard to follow.
Editing a Noun,
#[1 a b] a #[(a + a) b c] #[a [b /[(a + a + 1) c]] c] #[(a + a + 1) b c] #[a [/[(a + a) c] b] c]
# operator replaces part of a noun with another noun.
#[x y z] replaces address
z with the noun
Take some noun, say,
[22 33 44 55]. Let's replace part of it with another noun,
[123 456]. We can replace the entire original noun as follows:
#[1 [123 456] [22 33 44 55]]
If we only want to replace the value at address
#[2 [123 456] [22 33 44 55]]
[[123 456] 33 44 55]
And we can replace address
#[3 [123 456] [22 33 44 55]]
[22 123 456]
These rules define Nock itself - ie, the
*[a 0 b] /[b a]
0 is Nock's tree-addressing instruction. Let's try it out
from the Arvo command line.
Note that we're using Hoon syntax here. Since we do not use Nock
from Hoon all that often (it's sort of like embedding assembly in
C), we've left it a little cumbersome. In Hoon, instead of
*[a 0 b], we write
.*(a [0 b])
So, to reuse our slot example, let's try the interpreter:
~zod:dojo> .*([[4 5] [6 14 15]] [0 7])
*[a 1 b] b
1 is the constant instruction. It produces its argument without
reference to the subject. So
~zod:dojo> .*(42 [1 153 218])
2 is the Nock instruction:
*[a 2 b c] *[*[a b] *[a c]]
If you can compute a subject and a
formula, you can evaluate them in the interpreter. In most
fundamental languages, like Lisp,
eval is a curiosity. But
Nock has no
apply - so all our work gets done with
Let's convert the previous example into a stupid use of
with constant subject and formula:
~zod:dojo> .*(77 [2 [1 42] [1 1 153 218]])
This gives the same
5, axiomatic functions
*[a 3 b] ?*[a b] *[a 4 b] +*[a b] *[a 5 b c] =[*[a b] *[a c]]
These are axiomatic functions:
For instance, if
x is a formula that calculates some product,
[4 x] calculates that product plus one. Hence:
~zod:dojo> .*(57 [0 1]) 57 ~zod:dojo> .*(57 [4 0 1]) 58
~zod:dojo> .*([132 19] [0 3]) 19 ~zod:dojo> .*([132 19] [4 0 3]) 20
*[a [b c] d] [*[a b c] *[a d]]
Since Nock of an atom just crashes, the practical domain of the Nock function is always a cell. Conventionally, the head of this cell is the "subject," the tail is the "formula," and the result of Nocking it is the "product." Basically, the subject is your data and the formula is your code.
We could write this line less formally:
*[subject [formula-x formula-y]] => [*[subject formula-x] *[subject formula-y]]
In other words, if you have two Nock formulas
formula that computes the pair of them is just
[x y]. We can
recognize this because no atom is a valid formula, and
every formula that does not use distribution has an atomic head.
If you know Lisp, you can think of this feature as a sort of
"implicit cons." Where in Lisp you would write
(cons x y),
in Nock you write
~zod:dojo> .*(42 [4 0 1])
42 is the subject (data) and
[4 0 1] is the formula
(code), happens to evaluate to
~zod:dojo> .*(42 [3 0 1])
1. So if we evaluate
~zod:dojo> .*(42 [[4 0 1] [3 0 1]])
Except for the crash defaults, we've actually completed all the essential aspects of Nock. The instructions up through 5 provide all necessary computational functionality. Nock, though very simple, is actually much more complex than it formally needs to be.
Operators 6 through 11 are sugar. They exist because Nock is not a toy, but a practical interpreter. Let's see them all together:
*[a 6 b c d] *[a *[[c d] 0 *[[2 3] 0 *[a 4 4 b]]]] *[a 7 b c] *[*[a b] c] *[a 8 b c] *[[*[a b] a] c] *[a 9 b c] *[*[a c] 2 [0 1] 0 b] *[a 10 [b c] d] #[b *[a c] *[a d]] *[a 11 [b c] d] *[[*[a c] *[a d]] 0 3] *[a 11 b c] *[a c]
Let's try to figure out what these do, simplest first:
*[a 11 b c] *[a c]
x is an atom and
y is a formula, the formula
[11 x y]
appears to be equivalent to...
y. For instance:
.*([132 19] [11 37 [4 0 3]])
Why would we want to do this?
11 is actually a hint instruction.
37 in this example is discarded information - it is not
used, formally, in the computation. It may help the interpreter
compute the expression more efficiently, however.
Every Nock computes the same result - but not all at the same speed. What hints are supported? What do they do? Hints are a higher-level convention which do not, and should not, appear in the Nock spec. Some are defined in Hoon. Indeed, a naive Nock interpreter not optimized for Hoon will run Hoon quite poorly. When it gets the product, however, the product will be right.
There is another instruction
*[a 11 [b c] d] *[[*[a c] *[a d]] 0 3]
This complex hint
throws away an arbitrary
b, but computes the formula
against the subject and... throws away the product. This formula
is simply equivalent to
d. Of course, in practice the product
c will be put to some sordid and useful use. It could even
wind up as a side effect.
(Why do we even care that
c is computed? Because
crash. A correct Nock cannot simply ignore it, and treat both
11 as equivalent.)
*[a 7 b c] *[*[a b] c]
Suppose we have two formulas,
c. What is the formula
[7 b c]? This example will show you:
~zod:dojo> .*(42 [7 [4 0 1] [4 0 1]]) 44
Good old composition, on Nock formulas. It's easy to see how
this is a variant of Nock
2. The data to evaluate is simply
and the formula is
*[a 8 b c] *[[*[a b] a] c]
7, except that the subject for
c is not simply the
b, but the ordered pair of the product of
the original subject. Hence:
.*(42 [8 [4 0 1] [0 1]]) [43 42]
~zod:dojo> .*(42 [8 [4 0 1] [4 0 3]]) 43
Why would we want to do this? Imagine a higher-level language
in which the programmer declares a variable. This language is
likely to generate an
8, because the variable is computed
against the present subject, and used in a calculation which
depends both on the original subject and the new variable.
9 is a calling convention:
*[a 9 b c] *[*[a c] 2 [0 1] 0 b]
c, we produce a noun which contains both code and data - a
core. We use this core as the subject, and evaluate the
formula within it at slot
This looks much scarier than it is:
*[a 6 b c d] *[a *[[c d] 0 *[[2 3] 0 *[a 4 4 b]]]]
b evaluates to
0, we produce
b evaluates to
d; otherwise, we crash.
~zod:dojo> .*(42 [6 [1 0] [4 0 1] [1 233]]) 43 ~zod:dojo> .*(42 [6 [1 1] [4 0 1] [1 233]]) 233
In real life, of course, the Nock implementor knows that
"if" and implements it as such. There is no practical sense in
reducing through this macro, or any of the others. We could have
defined "if" as a built-in function, like increment - except that
we can write "if" as a macro. If a funky macro.
We can actually simplify the semantics of
6, at the expense of
breaking the system a little, by creating a macro that works as
"if" only if
b is a proper boolean and produces
Perhaps we have a higher-level type system which checks this.
This simpler "if" would be:
*[a 6 b c d] *[a [2 [0 1] [2 [1 c d] [[1 0] [4 4 b]]]]]
Or without so many unnecessary brackets:
*[a 6 b c d] *[a 2 [0 1] 2 [1 c d] [1 0] [4 4 b]]
How does this work? We've replaced
[6 b c d] with the formula
[2 [0 1] [2 [1 c d] [[1 0] [4 4 b]]]]. We see two uses of
our evaluation instruction - an outer and an inner.
Call the inner one
i. So we have
[2 [0 1] i]. Which means
that, to calculate our product, we use
[0 1] - that is, the
original subject - as the subject; and the product of
Okay, cool. So
[2 [1 c d] [[1 0] [4 4 b]]]. We compute
Nock with subject
[1 c d], formula
[[1 0] [4 4 b]].
[1 c d] produces just
[c d] - that is, the ordered
pair of the "then" and "else" formulas.
[[1 0] [4 4 b]] is a
line 19 cell - its head is
[1 0], producing just
0, its tail
[4 4 b], producing... what? Well, if
[4 b] is
[4 4 b] is
We're assuming that
b produces either
[4 4 b]
[[1 0] [4 4 b]] is either
[0 2] or
[0 3]. Applied to the subject
[c d], this gives us either
d - the product of our inner evaluation
i. This is
applied to the original subject, and the result is "if."
But we need the full power of the funk, because if
7, all kinds of weirdness will result. We'd really like
6 to just crash if the test product is not a boolean. How can
we accomplish this? This is an excellent way to prove to
yourself that you understand Nock: figure out what the real
does. Or you could just agree that
6 is "if," and move on.
(It's worth noting that in practical, compiler-generated Nock, we
never do anything as funky as these
6 macro internals. There's
no reason we couldn't build formulas at runtime, but we have no
reason to and we don't - except when actually metaprogramming.
As in most languages, normally code is code and data is data.)