| description | Reference for Hoon's Nock runes, including scrying with .^ and basic Nock operations like increment. | |||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| layout |
|
Anything Nock can do, Hoon can do also. These runes are used for carrying out Nock operations in Hoon.
Load from the Arvo namespace (scry) with a fake Nock instruction: Nock 12.
Two arguments, with the second optionally split into an arbitrary number of elements.
While this rune technically takes a fixed number of arguments, .q is usually split into at least two parts, and the tall form of this rune must be terminated with a ==. Note also that the == does not make the arguments into a list as you might expect, so .q must be explicitly null-terminated if its elements are specified separately.
{% tabs %}
{% tab title="Tall form" %}
.^ p
q1
q2
q3
qn
=={% endtab %}
{% tab title="Wide form" %}
.^(p q1 q2){% endtab %}
{% tab title="Irregular form" %}
None
{% endtab %}
{% endtabs %}
[%dtkt p=spec q=hoon]The noun .q, cast to the type .p.
Nock has no 12 instruction! But the virtual Nock used to run userspace code does. Nock 12 loads from a typed immutable namespace defined by its virtual context.
Ordinarily a Hoon expression has access to no information but whatever can be found in the subject. The one exception is with the .^ rune. It essentially allows you to request information from one of the Arvo vanes (modules).
.^ checks that the type of the value retrieved from Arvo nests under .p. .q is a $path which includes information about which vane is being queried, and what sort of information is requested.
In principle .^ takes two subexpressions, but in practice .q is often given in two parts: the first part includes the vane to be queried (e.g., %a for Ames, %b for Behn, %c for Clay, etc.) and the kind of request. The second part is a path that corresponds to the kind of request.
In the dojo we can ask Clay -- the Arvo filesystem -- for a listing of the files at our current path, %:
> .^(arch %cy %)
[ fil=~
dir
{ [p=~.app q=~]
[p=~.sur q=~]
[p=~.gen q=~]
[p=~.lib q=~]
[p=~.mar q=~]
[p=~.ted q=~]
[p=~.desk q=~]
[p=~.sys q=~]
}
]
The "c" in %cy is for Clay, and the "y" is for the request type. $arch is the type of the listing. See /gen/cat.hoon to see how this information is printed more prettily.
The % is for the current path in the dojo:
> `path`%
/~zod/base/~2018.9.20..23.05.35..0231
You can modify the time of the file listing quite simply and ask for a listing from 5 hours ago. (Remember that Clay is a revision-controlled file system.)
> .^(arch %cy /(scot %p our)/base/(scot %da (sub now ~h5)))
[ fil=~
dir
{ [p=~.app q=~]
[p=~.sur q=~]
[p=~.gen q=~]
[p=~.lib q=~]
[p=~.mar q=~]
[p=~.ted q=~]
[p=~.desk q=~]
[p=~.sys q=~]
}
]
our is the value for your ship's name.
Increment an atom with Nock 4.
| Wide form | Tall form | Irregular form |
|---|---|---|
.+ p |
.+(p) |
+(p) |
[%dtls p=hoon].p plus 1 if .p is an atom; otherwise, crashes. The product atom has no aura.
> .+(6)
7
> +(6)
7
> +(%foo)
7.303.015
> +([1 2])
nest-fail
Evaluate with Nock 2.
Nock of formula .q and subject .p, with type %noun.
Two arguments, fixed.
{% tabs %}
{% tab title="Tall form" %}
.* p
q{% endtab %}
{% tab title="Wide form" %}
.*(p q){% endtab %}
{% tab title="Irregular form" %}
None.
{% endtab %}
{% endtabs %}
[%dttr p=hoon q=hoon].*(p q) is used to run Nock formula .q on the subject .p from within Hoon.
Keep in mind that .p and .q can be arbitrary Hoon expressions, as long as they evaluate to the appropriate nouns for Nock evaluation.
Note also that .* ("dottar") can be used to bypass the type system. It's therefore possible to use Hoon as a typeless language.
> .*([20 30] [0 2])
20
> .*(33 [4 0 1])
34
> .*(|.(50) [9 2 0 1])
50
> .*(12 [7 [`1 [4 `1]] [`2 `3 `2]])
[12 13 12]
> .*(~ [5 1^4 [4 1^3]])
0
> .*(~ [5 1^5 [4 1^3]])
1
Test for equality with Nock 5.
Two arguments, fixed.
{% tabs %}
{% tab title="Tall form" %}
.= p
q{% endtab %}
{% tab title="Wide form" %}
.=(p q){% endtab %}
{% tab title="Irregular form" %}
=(p q){% endtab %}
{% endtabs %}
[%dtts p=hoon q=hoon]%.y if .p equals .q; otherwise %.n.
Like Nock equality, .= ("dottis") tests whether two nouns are the same, ignoring invisible pointer structure. Because in a conventional noun implementation each noun has a lazy short hash, comparisons are fast unless the hash needs to be computed, or we are comparing separate copies of identical nouns. (Comparing large duplicates is a common cause of performance bugs.)
> .=(0 0)
%.y
> =(0 0)
%.y
> .=(1 2)
%.n
> =(1 2)
%.n
> =(12 [12 14])
%.n
Test for cell or atom with Nock 3.
One argument, fixed.
| Tall form | Wide form | Irregular form |
|---|---|---|
.? p |
.?(p) |
None |
[%dtwt p=hoon]%.y if .p is a cell; otherwise %.n.
> .?(42)
%.n
> .?([42 43])
%.y