. dot · Nock

Anything Nock can do, Hoon can do also. These runes are used for carrying out Nock operations in Hoon.

.^ "dotket"

Load from the Arvo namespace (scry) with a fake Nock instruction: Nock 12.

Syntax

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.

Tall form

.^  p
  q1
  q2
  q3
  qn
==

Wide form

.^(p q1 q2)

Irregular form

None

AST

[%dtkt p=spec q=hoon]

Produces

The noun .q, cast to the type .p.

Discussion

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.

Examples

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.

---

.+ "dotlus"

Increment an atom with Nock 4.

Syntax

Wide form	Tall form	Irregular form
.+ p	.+(p)	+(p)

AST

[%dtls p=hoon]

Produces

.p plus 1 if .p is an atom; otherwise, crashes. The product atom has no aura.

Examples

> .+(6)
7

> +(6)
7

> +(%foo)
7.303.015

> +([1 2])
nest-fail

---

.* "dottar"

Evaluate with Nock 2.

Produces

Nock of formula .q and subject .p, with type %noun.

Syntax

Two arguments, fixed.

Tall form

.*  p
q

Wide form

.*(p q)

Irregular form

None.

AST

[%dttr p=hoon q=hoon]

Discussion

.*(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.

Examples

> .*([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

---

.= "dottis"

Test for equality with Nock 5.

Syntax

Two arguments, fixed.

Tall form

.=  p
q

Wide form

.=(p q)

Irregular form

  =(p q)

AST

[%dtts p=hoon q=hoon]

Produces

%.y if .p equals .q; otherwise %.n.

Discussion

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.)

Examples

> .=(0 0)
%.y

> =(0 0)
%.y

> .=(1 2)
%.n

> =(1 2)
%.n

> =(12 [12 14])
%.n

---

.? "dotwut"

Test for cell or atom with Nock 3.

Syntax

One argument, fixed.

Tall form	Wide form	Irregular form
.? p	.?(p)	None

AST

[%dtwt p=hoon]

Produces

%.y if .p is a cell; otherwise %.n.

Examples

> .?(42)
%.n

> .?([42 43])
%.y