Nock
Rules
*[a 0 b] -> /[b a]
Rule zero is an addressing rule, reducing to the noun at address b in a (/ is a slot operator). A noun is a value- an atom or a cell.
*[a 1 b] -> b
Rule one is a constant reduction returning the value b
*[a 2 b c] -> *[*[a b] *[a c]]
Rule two applies both b and c to the subject a and then computes the result of b as the subject of formula c.
*[a 3 b] -> ?*[a b]
Rule three is a test on whether b is a cell... ? produces 0/True if a cell is true and 1/False otherwise
*[a 4 b] -> +*[a b]
Rule four is an increment operation on b
[a 5 b c] -> =[*[a b] *[a c]]
Rule five tests for equality on the products of b and c after computing them against a
*[a 6 b c d] -> *[a *[[c d] 0 *[[2 3] 0 *[a 4 4 b]]]]
Rule 6 is an if-then-else statement.
*[a 7 b c] -> *[*[a b] c]
Rule 7 is like rule 2, but there's no requirement to make c run against a subject. It's trivial, but removes syntactic sugar.
*[a 8 b c] -> *[[*[a b] a] c]
Rule 8 prepends some a-based variable to the subject then calls that new subject against c, allowing us to 'pin' some values
*[a 9 b c] -> *[*[a c] 2 [0 1] 0 b]
Rule 9 computes c against subject a, extracts the address at b, and runs the new formula against the new subject
*[ 10 [b c] d] -> #[b *[a c] *[a d]]
Rule 10 Rule ten replaces slot b in *[a d] with *[a c]
TODO!!! Finish this
Structure and Execution
In the Urbit terminal, Nock is called via
.* (SUBJECT FORMULA)
Both subject and formula are program trees. Addressing follows tree order.
Incremental Examples
.*([5 [44 43]] [0 1]) -> [5 [44 43]]
.*([5 [44 43]] [0 2]) -> 5
.*([5 [44 43]] [0 5]) -> 43
.*([5 [44 43]] [4 0 5]) -> +*[[5 [44 43]] [0 5]] -> +/[[5 44 43] 5] -> +43 -> 44
.*(5 [4 4 0 1]) -> +*(5 [4 0 1]) -> ++*(5 [0 1]) ... -> 7
The implicit cons means that we can produce lists of things easily, the subject is 'carried through'
.*(50 [[0 1] [1 203] [0 1] [1 19] [1 76]]) -> [50 203 50 19 76]
.*(5 [3 4 0 1]) -> > ?6 -> 1
.*(5 [3 [0 1] 4 0 1]) -> > ?[5 6] -> 0
.*(5 [3 [0 1] [4 0 1]]) -> > ?[5 6] -> 0
.*([50 51] [4 3 0 1]) -> +?[50 51] -> 1
.*([50 51] [5 [0 2] [0 2]]) -> =[50 50] -> 0
.*([50 51] [5 [0 2] [0 3]]) -> =[50 51] -> 1
.*([4 5] [6 [3 0 1] [0 2] [0 1]]) -> 4
If *[5 [3 0 1]] then *[5 [0 2]] else *[5 [0 1]]...
.*(5 [6 [3 0 1] [0 2] [0 1]]) -> *[5 [0 1]] -> 5
This is how we can change the subject.
.*([50 51] [2 [0 3] [1 [4 0 1]]]) -> [51 [4 0 1]] -> 52
.*([5 [3 0 1] [0 2] [0 1]] [2 [0 2] [0 6]]) -> *[5 [3 0 1]] -> 1
Compare the following two, one using opcode 2, and one using opcode 7, and see that 7 is just syntactic sugar
.*([23 45] [2 [0 3] [1 4 0 1]]) -> 46
.*([23 45] [7 [0 3] [4 0 1]]) -> 46
.*([67 39] [8 [1 0] [4 0 2]) -> *[[*[[67 39] [1 0]] [67 39]] [4 0 2]] -> *[[0 [67 39]] [4 0 2]] -> 1
Opcode 9 can be thought of as 'set up a new subject using c, then pull the procedure at b from that new subject and execute against the new subject
.*(45 [9 2 [1 4 0 3] 0 1])
-> *[*[45 [1 4 0 3] 0 1] 2 [0 1] 0 2]
-> *[[[4 0 3] 45] 2 [0 1] 0 2]
-> *[*[[[4 0 3] 45] [0 1]] *[[[4 0 3] 45] [0 2]]]
-> *[[[4 0 3] 45] [4 0 3]] -> +45 -> 46
.*(50 [10 [2 [0 1]] [1 8 9 10]]) -> #[2 *[50 0 1] *[50 1 8 9 10]] -> #[2 50 [8 9 10]] -> [50 9 10]
Design Patterns
The basic Nock pattern is to set up a core to run everything
*[subject 2 formula-to-set-up-core formula-to-set-up-to-run-against-that-core]
Since opcode 9 works well with arms and cores naturally, it's often used for this purpose. Nock can be quite complex to write, but Hoon and the Urbit terminal offer some tools to make it easier.
In addition to this guide, there are a series of articles by Timluc Miptev
And a good breakdown of Nock by one of the Anoma lead authors.