volume 1, Hoon Structures
=========================
------------------------------------------------------------------------
++abel
++ abel typo :: original sin: type
Biblical names in hoon are primarily aliases for the compiler.
See also: `++typo`
~zod/try=> *abel
%void
------------------------------------------------------------------------
++axis
++ axis ,@ :: tree address
A Nock axis inside a noun. After the leading 1, in binary, a 1 signfies
right and 0 left.
See also: `++clue`, `++limb`, `++slot`, `++peg`, and Section 2fC
~zod/try=> *axis
0
~zod/try=> :: 0 is not actually a valid axis
~zod/try=> [[4 5] 6 7]
[[4 5] 6 7]
~zod/try=> `axis`0b110
6
------------------------------------------------------------------------
++also
++ also ,[p=term q=wing r=type] :: alias
XX unused?
------------------------------------------------------------------------
++base
++ base ?([%atom p=odor] %noun %cell %bean %null) :: axils, @ * ^ ? ~
A base type that nouns are built from. Either a noun, a cell, loobean or
null labelled with an odor.
See also: `++tile`, `++twig`
~zod/try=> *base
%null
~zod/try=> (ream '=|(^ !!)')
[%tsbr p=[%axil p=%cell] q=[%zpzp ~]]
~zod/try=> :: p.p is a ++base
~zod/try=> (ream '=|(@t !!)')
[%tsbr p=[%axil p=[%atom p=~.t]] q=[%zpzp ~]]
~zod/try=> (ream '=|(? !!)')
[%tsbr p=[%axil p=%bean] q=[%zpzp ~]]
------------------------------------------------------------------------
++bean
++ bean ,? :: 0=&=yes, 1=|=no
The Urbit version of a boolean, which we call a loobean. 0 or & is
"yes", 1 or | is "no".
~zod/try=> *bean
%.y
~zod/try=> `bean`&
%.y
~zod/try=> `bean`|
%.n
------------------------------------------------------------------------
++beer
++ beer $|(@ [~ p=twig]) :: simple embed
Used to build tapes internally.
See also: `++phax`, `++scat`, section 2fD
~zod/try=> `beer`'as'
29.537
~zod/try=> `beer`[~ (ream 'lan')]
[~ p=[%cnzz p=~[%lan]]]
------------------------------------------------------------------------
++beet
++ beet $| @ :: advanced embed
$% [%a p=twig] :: take tape
[%b p=twig] :: take manx
[%c p=twig] :: take marl
[%d p=twig] :: take $+(marl marl)
[%e p=twig q=(list tuna)] :: element literal
== ::
Cases for XML interpolation. Used internally.
See also: `++sail`, section 2fD
------------------------------------------------------------------------
++bloq
++ bloq ,@ :: blockclass
Atom representing a blocksize, by convention expressed as a power of 2.
See also: section 2cA
~zod/try=> :: ++met measures how many bloqs long an atom is
~zod/try=> (met 3 256)
2
~zod/try=> :: 256 is 2 bloqs of 2^3
------------------------------------------------------------------------
++calf
++ calf ,[p=(map ,@ud wine) q=wine] ::
Encodes cyclical backreferences in types. Used in pretty printing.
See also: `++wine`, `++dole`, `++doge`, `++dish`, section 2fC
~zod/try=> `calf`[~ %atom %ta]
[p={} q=[%atom p=%ta]]
~zod/try=> `calf`~(dole ut p:!>(*^))
[p={} q=[%plot p=~[%noun %noun]]]
~zod/try=> `calf`~(dole ut p:!>($:|-(?(~ [* $]))))
[ p={[p=1 q=[%pick p=~[[%pear p=%n q=0] [%plot p=~[%noun [%stop p=1]]]]]]}
q=[%stop p=1]
]
------------------------------------------------------------------------
++char
++ char ,@tD :: UTF-8 byte
A single character. Odor `@tD` designates a single Unicode byte. All
parsers consume `++tape` (a list of `++char`).
See also: `++tape`, `++lust`, `++just`, `++mask`, chapter 2f
~zod/try=> *char
~~
~zod/try=> (char 97)
~~a
------------------------------------------------------------------------
++chub
++ chub :: registered battery
$: p=(pair chum tyre) :: definition
q=* :: battery
r=(unit (pair axis chub)) :: parent
== ::
Used by the compiler (implicitly by `%sgcn`) to attach jets.
See also: Section 2fB.
------------------------------------------------------------------------
++chum
++ chum $? lef=term :: jet name
[std=term kel=@] :: kelvin version
[ven=term pro=term kel=@] :: vendor and product
[ven=term pro=term ver=@ kel=@] :: all of the above
== ::
Jet hint information that must be present in the body of a \~/ or \~%
rune. A `++chum` can optionally contain a kelvin version, jet vendor,
and major.minor version number.
XX there's a ++chum in zuse that's politely causing this not to work
See also: `++twig`, `++clue`
~zod/try=> `chum`'hi'
lef=%hi
~zod/try=> (ream '~/(%lob.314 !!)')
[%sgfs p=[std=%lob kel=314] q=[%zpzp ~]]
------------------------------------------------------------------------
++clue
++ clue ,[p=axis q=chum r=tyre] :: battery definition
Used by compiler to attach jets.
XX implementation does not currenlty match docs
See also: section 2fB
------------------------------------------------------------------------
++coil
++ coil $: p=?(%gold %iron %lead %zinc) :: core type
q=type ::
r=[p=?(~ ^) q=(map term foot)] ::
== ::
Core information tuple: variance, subject type, optional compiled nock,
and arms. Used as an intermediate step within Section 2fB. Converted by
`++core` to %core type.
See also: `++core`, Section 2fB
------------------------------------------------------------------------
++coin
++ coin $% [%$ p=dime] ::
[%blob p=*] ::
[%many p=(list coin)] ::
== ::
Noun literal syntax cases: atoms, jammed nouns, and nestable tuples.
Parsed and printed using `++so` and `++co` cores in Section 2eL
respectively.
See also: `++so`, `++co`, Section 2eL, `++dime`
~zod/try=> `coin`(need (slay '~s1'))
[%$ p=[p=~.dr q=18.446.744.073.709.551.616]]
~zod/try=> `coin`(need (slay '0x2b59'))
[%$ p=[p=~.ux q=11.097]]
~zod/try=> ~(rend co [%many ~[[%$ %ud 1] [%$ %tas 'a'] [%$ %s -2]]])
"._1_a_-2__"
~zod/try=> ._1_a_-2__
[1 %a -2]
~zod/try=> `@uv`(jam [3 4])
0v2cd1
~zod/try=> (slay '~02cd1')
[~ [%blob p=[3 4]]]
~zod/try=> ~02cd1
[3 4]
------------------------------------------------------------------------
++cord
++ cord ,@t :: text atom (UTF-8)
One of Hoon's two string types (the other being `++tape`). A cord is an
atom of UTF-8 text. `++trip` and `++crip` convert between cord and
`++tape`
Odor `@t` designates a Unicode atom, little-endian: the first character
in the text is the low byte.
See also: `++trip`, `++crip`, Section 2eJ
~zod/try=> `@ux`'foobar'
0x7261.626f.6f66
~zod/try=> `@`'urbit'
499.984.265.845
~zod/try=> (cord 499.984.265.845)
'urbit'
------------------------------------------------------------------------
++date
++ date ,[[a=? y=@ud] m=@ud t=tarp] :: parsed date
A point in time. A loobean designating AD or BC, a year atom, a month
atom, and a `++tarp`, which is a day atom and a time.
See also: `++year`, `++yore`, Section 2cH, `++stud`, `++dust`, Section
3bc
~zod/try=> `date`(yore ~2014.6.6..21.09.15..0a16)
[[a=%.y y=2.014] m=6 t=[d=6 h=21 m=9 s=15 f=~[0xa16]]]
------------------------------------------------------------------------
++dime
++ dime ,[p=@ta q=@] ::
Odor-atom pair, used in `++coin`.
Convenience methods `++scot` and `++scow` (in Section 2eL) print dimes
as cords/tapes, `++slat`, `++slav`, and `++slaw` are used to parse atoms
of specific odor.
See also: `++so`, `++co`, Section 2eL, `++coin`
~zod/try=> +>:(slay '0x123')
p=[p=~.ux q=291]
------------------------------------------------------------------------
++dram
++ dram $% [| p=(map ,@tas dram)] :: simple unix dir
[& p=@ud q=@] ::
== ::
The structure of a unix filesystem tree. A `++dram` is one of two cases:
`|` a directory - a map of names to deeper tree structures, `&` a file -
a numbered atom of data.
XX Unused
------------------------------------------------------------------------
++each
++ each |*([a=$+(* *) b=$+(* *)] $%([& p=a] [| p=b])) :: either a or b
Tile generator: produces a dicriminated fork between two types.
~zod/try=> :type; *(each cord time)
[%.y p='']
{[%.y p=@t] [%.n p=@da]}
------------------------------------------------------------------------
++edge
++ edge ,[p=hair q=(unit ,[p=* q=nail])] :: parsing output
Parsing location metadata: optional result and parsing continuation.
See also: Section 2eD, `++rule`
~zod/try=> *edge
[p=[p=0 q=0] q=~]
~zod/try=> (tall:vast [1 1] "a b")
[p=[p=1 q=2] q=[~ [p=[%cnzz p=~[%a]] q=[p=[p=1 q=2] q=" b"]]]]
------------------------------------------------------------------------
++ foot $% [%ash p=twig] :: dry arm, geometric
[%elm p=twig] :: wet arm, generic
[%oak ~] :: XX not used
[%yew p=(map term foot)] :: XX not used
== ::
Cases of arms by variance model.
See also: `++ap`, `++ut`, Section 2fB, Section 2fC
~zod/try=> *foot
[%yew p={}]
~zod/try=> (ream '|% ++ $ foo --')
[%brcn p={[p=%$ q=[%ash p=[%cnzz p=~[%foo]]]]}]
~zod/try=> +<+:(ream '|% ++ $ foo --')
t=~[%ash %cnzz %foo]
~zod/try=> (foot +<+:(ream '|% ++ $ foo --'))
[%ash p=[%cnzz p=~[%foo]]]
~zod/try=> (foot +<+:(ream '|% +- $ foo --'))
[%elm p=[%cnzz p=~[%foo]]]
------------------------------------------------------------------------
++gate
++ gate $+(* *) :: general gate
An core with one arm, `$`, which transforms a sample noun into a product
noun. If used dryly as a type, subject must have a sample type of `*`.
See also: `++lift`, `++cork`, Core Language Doc
~zod/try=> *gate
<1|mws [* <101.jzo 1.ypj %164>]>
~zod/try=> `gate`|=(* 0)
<1|mws [* <101.jzo 1.ypj %164>]>
~zod/try=> (|=(a=* [a 'b']) 'c')
[99 'b']
~zod/try=> (`gate`|=(a=* [a 'b']) 'c')
[99 98]
------------------------------------------------------------------------
++hair
++ hair ,[p=@ud q=@ud] :: parsing trace
A pair of two `@ud` used in parsing indicating line and column number.
See also: `++last`, Section 2eB
~zod/try=> *hair
[p=0 q=0]
~zod/try=> `hair`[1 1] :: parsing starts at [1 1] as a convention.
[p=1 q=1]
~zod/try=> ((plus ace) [1 1] " --")
[p=[p=1 q=4] q=[~ u=[p=[~~. " "] q=[p=[p=1 q=4] q="--"]]]]
~zod/try=> `hair`p:((plus ace) [1 1] " --")
[p=1 q=4]
------------------------------------------------------------------------
++like
++ like |* a=_,* :: generic edge
|= b=_`*`[(hair) ~] ::
:- p=(hair -.b) ::
^= q ::
?@ +.b ~ ::
:- ~ ::
u=[p=(a +>-.b) q=[p=(hair -.b) q=(tape +.b)]] ::
Tile generator for an `++edge`. `++like` generates an `++edge` with a
parsed result set to a specific type.
See also: `++easy`, `++just`/`++jest`, `++knee`, `++mask`, `++shim`,
`++stir`, `++stun`, Section 2eC
~zod/try=> *(like char)
[p=[p=0 q=0] q=~]
~zod/try=> (ace [1 1] " a")
[p=[p=1 q=2] q=[~ [p=~~. q=[p=[p=1 q=2] q="a"]]]]
~zod/try=> `(like char)`(ace [1 1] " a")
[p=[p=1 q=2] q=[~ [p=~~. q=[p=[p=1 q=2] q="a"]]]]
~zod/try=> `(like ,@)`(ace [1 1] " a")
[p=[p=1 q=2] q=[~ [p=32 q=[p=[p=1 q=2] q="a"]]]]
------------------------------------------------------------------------
++limb
++ limb $|(term $%([%& p=axis] [%| p=@ud q=term])) ::
XX move to `++ut`
Reference into subject by name/axis
See also: section 2fC-2fD
~zod/try=> (ream '^^$')
[%cnzz p=~[[%.n p=2 q=%$]]]
~zod/try=> (limb &2:(ream '^^$'))
[%.n p=2 q=%$]
~zod/try=> (limb &2:(ream '^^^$'))
[%.n p=3 q=%$]
------------------------------------------------------------------------
++line
++ line ,[p=[%leaf p=odor q=@] q=tile] :: %kelp case
XX move to `++ut`
Dicriminated union unionee XX
Used in compilation and grammar, section 2fC-2fD
~zod/try=> (ream '$%([1 a] [%2 b])')
[ %bccm
p
[ %kelp
p
[ i=[p=[%leaf p=~.ud q=1] q=[%herb p=[%cnzz p=~[%a]]]]
t=~[[p=[%leaf p=~.ud q=2] q=[%herb p=[%cnzz p=~[%b]]]]]
]
]
]
~zod/try=> &3:(ream '$%([1 a] [%2 b])')
p=[p=[%leaf p=%ud q=1] q=[%herb p=[%cnzz p=~[%a]]]]
~zod/try=> (line &3:(ream '$%([1 a] [%2 b])'))
[p=[%leaf p=~.ud q=1] q=[%herb p=[%cnzz p=~[%a]]]]
------------------------------------------------------------------------
++list
++ list |* a=_,* :: null-term list
$|(~ [i=a t=(list a)]) ::
Tile generator. `++list` generates a tile of a null-termanated list of
homogenous type.
See also: `++turn`, `++snag`, section 2bB.
~zod/try=> *(list)
~
~zod/try=> `(list ,@)`"abc"
~[97 98 99]
~zod/try=> (snag 0 "abc")
~~a
------------------------------------------------------------------------
++lone
++ lone |*(a=$+(* *) ,p=a) :: just one thing
XX unused
Tile generator. `++lone` puts face of `p` on something.
------------------------------------------------------------------------
++mane
++ mane $|(@tas [@tas @tas]) :: XML name/space
An XML name (tag name or attribute name) with an optional namespace.
Parsed by `++name`:poxa, rendered by `++name`:poxo.
See also: `++sail` doc, Section 3bD
~zod/try=> *mane
%$
~zod/try=> `mane`n.g:`manx`;div:namespace;
%div
~zod/try=> `mane`n.g:`manx`;div_namespace;
[%div %namespace]
------------------------------------------------------------------------
++manx
++ manx ,[g=marx c=marl] :: XML node
XML node.
Parsed by `++apex`:poxa, rendered by `++poxo`, section 3bD
See also: `++sail` doc, Section 3bD
------------------------------------------------------------------------
++marl
++ marl (list manx) :: XML node list
List of XML nodes.
Parsed within `++apex`:poxa, rendered by `++many`:poxo, section 3bD
See also: `++sail` doc
------------------------------------------------------------------------
++mars
++ mars ,[t=[n=%$ a=[i=[n=%$ v=tape] t=~]] c=~] :: XML cdata
XML CDATA. Implicitly produced by `++chrd`:poxa
See also: `++sail` doc
------------------------------------------------------------------------
++mart
++ mart (list ,[n=mane v=tape]) :: XML attributes
List of XML attributes. Each `++mart` is a list of pairs of `++mane` and
`++tape`.
Parsed by `++attr`:poxa, rendered by `++attr`:poxo, section 3bD
See also: `++sail` doc
------------------------------------------------------------------------
++marx
++ marx ,[n=mane a=mart] :: XML tag
XML tag. A `++marx` is a pair of a tag name, `++mane` and a list of
attributes, `++mart`.
Parsed by `++head`:poxa, rendered within `++poxo`, section 3bD
See also: `++sail` doc
------------------------------------------------------------------------
++metl
++ metl ?(%gold %iron %zinc %lead) :: core variance
XX move to `++ut`
See also: `++coil`
------------------------------------------------------------------------
++noun
++ noun ,* :: any noun
Used nowhere XX
~zod/try=> `noun`~[1 2 3]
[1 2 3 0]
------------------------------------------------------------------------
++null
++ null ,~ :: null, nil, etc
Used nowhere XX
~zod/try=> :type; *null
~
%~
------------------------------------------------------------------------
++odor
++ odor ,@ta :: atom format
By convetion, a short name for a category of atom. `++odor` is
circularly defined, `@ta` being the `++odor` of the ASCII subset
commonly used in urbit.
See also: `++base`, odor reference
~zod/try=> `odor`%ux
~.ux
------------------------------------------------------------------------
++tarp
++ tarp ,[d=@ud h=@ud m=@ud s=@ud f=(list ,@ux)] :: parsed time
The remaining part of a `++date`: day, hour, minute, second and a list
of `@ux` for precision.
See also: `++date`, `++yell`/`++yule`, Section 2cH
~zod/try=> -<-
~2014.9.20..00.43.33..b52a
~zod/try=> :: the time is always in your context at -<-
~zod/try=> (yell -<-)
[d=106.751.991.820.278 h=0 m=43 s=39 f=~[0x54d1]]
~zod/try=> (yell ~d20)
[d=20 h=0 m=0 s=0 f=~]
------------------------------------------------------------------------
++time
++ time ,@da :: galactic time
The `@da` odor designates an absolute date atom.
See also: `++date`, odor reference
~zod/try=> `time`-<-
~2014.9.25..20.01.47..eeac
~zod/try=> :: the time is always in your context at -<-
~zod/try=> `time`~2014.1.1
~2014.1.1
------------------------------------------------------------------------
++tree
++ tree |* a=_,* :: binary tree
$|(~ [n=a l=(tree a) r=(tree a)]) ::
Tile generator. A `++tree` can be empty, or contain a node of a type and
left/right sub `++tree`s of the same type. Pretty-printed with `{}`.
~zod/try=> `(tree ,[@ tape])`[[1 "hi"] [[2 "bye"] ~ ~] ~]
{[2 "bye"] [1 "hi"]}
------------------------------------------------------------------------
++nail
++ nail ,[p=hair q=tape] :: parsing input
Location in parsed text, and remainder of it. Indicates parsing position
and remaining text to be parsed.
See also: `++roll`
~zod/try=> +<:;~(plug cab cab)
c=tub=[p=[p=0 q=0] q=""]
~zod/try=> :: tub is a ++nail
------------------------------------------------------------------------
++numb
++ numb ,@ :: just a number
Used nowhere XX
------------------------------------------------------------------------
++pair
++ pair |*([a=$+(* *) b=$+(* *)] ,[p=a q=b]) :: just a pair
Tile generator. Produces a tuple of two of the types passed in.
~zod/try=> *(pair bean cord)
[p=%.y q='']
------------------------------------------------------------------------
++pass
++ pass ,@ :: public key
Atom alias. Used primarily in crypto.
See also: `++acru`, `++crua`, `++crub`
------------------------------------------------------------------------
++path
++ path (list span) :: filesys location
A filesystem path. A `++path` is a list of `++span`, `@ta`. Used in
`%clay` and `%eyre` extensively.
~zod/try=> `path`"abc"
/a/b/c
------------------------------------------------------------------------
++pint
++ pint ,[p=[p=@ q=@] q=[p=@ q=@]] :: line/column range
A parsing range, mostly used for stacktraces. A `++pint` is a pair of
hairs indicating from - to.
~zod/try=> !:(!!)
! /~zod/try/~2014.9.20..01.22.04..52e3/:<[1 4].[1 6]>
~zod/try=> :: !! always produces a crash
~zod/try=> `pint`[[1 4] [1 6]]
[p=[p=1 q=4] q=[p=1 q=6]]
------------------------------------------------------------------------
++pole
++ pole |* a=_,* :: nameless list
$|(~ [a (pole a)]) ::
A `++list` without the faces. A `++pole` is a null-terminated typle
without the `i=` and `t=`.
~zod/try=> `(pole char)`"asdf"
[~~a [~~s [~~d [~~f ~]]]]
------------------------------------------------------------------------
++port
++ port $: p=axis ::
$= q ::
$% [%& p=type] ::
[%| p=axis q=(list ,[p=type q=foot])] ::
== ::
== ::
XX move to `++ut`
Type and location of core-shaped thing? XX Compiler Internals
~zod/try=> *port
[p=0 q=[%.y p=%void]]
------------------------------------------------------------------------
++post
++ post $: p=axis ::
$= q ::
$% [0 p=type] ::
[1 p=axis q=(list ,[p=type q=foot])] ::
[2 p=twin q=type] ::
== ::
== ::
XX move to `++ut`
Type and location of possibly core-shaped thing? XX Compiler Internals
~zod/try=> *post
[p=0 q=[%0 p=%void]]
------------------------------------------------------------------------
++prop
++ prop $: p=axis ::
$= q ::
[p=?(~ axis) q=(list ,[p=type q=foot])] ::
== ::
XX move to `++ut`
Verified core-shaped thing? XX Compiler Internals
~zod/try=> *prop
[p=0 q=[p=~ q=~]]
------------------------------------------------------------------------
++qual
++ qual |* [a=$+(* *) b=$+(* *) c=$+(* *) d=$+(* *)] :: just a quadruple
,[p=a q=b r=c s=d] ::
Tile generator. A `++qual` is a tuple of four of the types passed in..
~zod/try=> *(qual date time tape cord)
[p=[[a=%.y y=0] m=0 t=[d=0 h=0 m=0 s=0 f=~]] q=~292277024401-.1.1 r="" s='']
------------------------------------------------------------------------
++rege
++ rege $| ?(%dote %ende %sart %empt %boun %bout) :: parsed regex
$% [%lite p=char] :: literal
[%pair p=rege q=rege] :: ordering
[%capt p=rege q=@u] :: capture group
[%brac p=@] :: p is 256 bitmask
[%eith p=rege q=rege] :: either
[%mant p=rege] :: greedy 0 or more
[%plls p=rege] :: greedy 1 or more
[%betw p=rege q=@u r=@u] :: between q and r
[%bint p=rege q=@u] :: min q
[%bant p=rege q=@u] :: exactly q
[%manl p=rege] :: lazy 0 or more
[%plll p=rege] :: lazy 1 or more
[%betl p=rege q=@u r=@u] :: between q and r lazy
[%binl p=rege q=@u] :: min q lazy
== ::
Regular expressions. `++rege` defines the cases of a regex.
See also: `++rexp`, `++repg`, `++pars`
~zod/try=> (pars "[a-z]")
[~ [%brac p=10.633.823.807.823.001.954.701.781.295.154.855.936]]
~zod/try=> (rexp "[a-z]" "abc1")
[~ [~ {[p=0 q="a"]}]]
------------------------------------------------------------------------
++ring
++ ring ,@ :: private key
Atom alias, used primarily in crypto.
See also: `++acru`, `++crua`, `++crub`.
------------------------------------------------------------------------
++rule
++ rule |=(tub=nail `edge`[p.tub ~ ~ tub]) :: parsing rule
Parsing rule. `++rule` is an empty parsing rule, but it is used to check
that parsing rules match this with `_`.
See also: `++cold`, Section 2eC
~zod/try=> *rule
[p=[p=0 q=0] q=[~ [p=0 q=[p=[p=0 q=0] q=""]]]]
~zod/try=> ^+(rule [|=(a=nail [p.a ~])]:|6)
<1.dww [tub=[p=[p=@ud q=@ud] q=""] <101.jzo 1.ypj %164>]>
~zod/try=> (^+(rule [|=(a=nail [p.a ~ u=['a' a]])]:|6) [1 1] "hi")
[p=[p=1 q=1] q=[~ [p=97 q=[p=[p=1 q=1] q="hi"]]]]
~zod/try=> ([|=(a=nail [p.a ~ u=['a' a]])]:|6 [1 1] "hi")
[[p=1 q=1] ~ u=['a' p=[p=1 q=1] q="hi"]]
------------------------------------------------------------------------
++span
++ span ,@ta :: text-atom (ASCII)
A restricted text atom for canonical atom syntaxes. The prefix is `~.`.
There are no escape sequences except `~~`, which means `~`, and `~-`,
which means `_`. `-` and `.` encode themselves. No other characters
besides numbers and lowercase letters are permitted.
~zod/try=> *span
~.
~zod/try=> `@t`~.foo
'foo'
~zod/try=> `@t`~.foo.bar
'foo.bar'
~zod/try=> `@t`~.foo~~bar
'foo~bar'
~zod/try=> `@t`~.foo~-bar
'foo_bar'
~zod/try=> `@t`~.foo-bar
'foo-bar'
------------------------------------------------------------------------
++spot
++ spot ,[p=path q=pint] :: range in file
Stack trace line. A `++spot` is what we print after crashing.
See also: `++pint`
~zod/try=> :into /=main=/bin/fail/hoon '!: !!'
+ /~zod/main/359/bin/fail/hoon
~zod/try=> :fail
! /~zod/main/~2014.9.22..18.40.56..ef04/bin/fail/:<[1 5].[1 7]>
! exit
------------------------------------------------------------------------
++tang
++ tang (list tank) :: general error
Unused XX
------------------------------------------------------------------------
++tank
++ tank $% [%leaf p=tape] :: printing formats
$: %palm ::
p=[p=tape q=tape r=tape s=tape] ::
q=(list tank) ::
== ::
$: %rose :: delimeted list
p=[p=tape q=tape r=tape] :: mid open close
q=(list tank) ::
== ::
==
Pretty-printing structure. A `++tank` is one of three cases. A `%leaf`
is just a string. A `%palm` is XX need more information. A `%rose` is a
list of `++tank` delimted by the strings in `p`.
~zod/try=> >(bex 20) (bex 19)<
[%rose p=[p=" " q="[" r="]"] q=~[[%leaf p="1.048.576"] [%leaf p="524.288"]]]
~zod/try=> (wash [0 80] >(bex 20) (bex 19)<) :: at 80 cols
<<"[1.048.576 524.288]">>
~zod/try=> (wash [0 15] >(bex 20) (bex 19)<) :: at 15 cols (two lines)
<<"[ 1.048.576" " 524.288" "]">>
~zod/try=> [(bex 150) (bex 151)] :: at 80 cols
[ 1.427.247.692.705.959.881.058.285.969.449.495.136.382.746.624
2.854.495.385.411.919.762.116.571.938.898.990.272.765.493.248
]
------------------------------------------------------------------------
++tape
++ tape (list char) :: like a string
One of Hoon's two string types, the other being `++cord`. A tape is a
list of chars.
~zod/try=> `(list ,char)`"foobar"
"foobar"
~zod/try=> `(list ,@)`"foobar"
~[102 111 111 98 97 114]
------------------------------------------------------------------------
++term
++ term ,@tas :: Hoon ASCII subset
A restricted text atom for Hoon constants. The only characters permitted
are lowercase ASCII, - except as the first or last character, and 0-9
except as the first character. The syntax for `@tas` is the text itself,
always preceded by `%`. This means a term is always cubical. The empty
`@tas` has a special syntax, `$`:
~zod/try=> *term
%$
~zod/try=> %dead-fish9
%dead-fish9
~zod/try=> -:!>(%dead-fish9)
[%cube p=271.101.667.197.767.630.546.276 q=[%atom p=%tas]]
------------------------------------------------------------------------
++tiki
++ tiki :: test case
$% [& p=(unit term) q=wing] :: simple wing
[| p=(unit term) q=twig] :: named wing
== ::
XX move to `++ut`
A `++wing` or `++twig`.
~zod/try=> (ream '=+ a=4 ?-(a @ ~)')
[ %tsls
p=[%ktts p=p=%a q=[%dtzy p=%ud q=4]]
q
[ %wthz
p=[%.y p=~ q=~[%a]]
q=~[[p=[%axil p=[%atom p=~.]] q=[%bczp p=%null]]]
]
]
~zod/try=> (ream '=+ a=4 ?-(4 @ ~)')
[ %tsls
p=[%ktts p=p=%a q=[%dtzy p=%ud q=4]]
q
[ %wthz
p=[%.n p=~ q=[%dtzy p=%ud q=4]]
q=~[[p=[%axil p=[%atom p=~.]] q=[%bczp p=%null]]]
]
]
------------------------------------------------------------------------
++tile
See the Tile section of the Hoon Reference.
------------------------------------------------------------------------
++toga
++ toga :: face control
$| p=term :: two togas
$% [0 ~] :: no toga
[1 p=term q=toga] :: deep toga
[2 p=toga q=toga] :: cell toga
== ::
XX move to `++ut` and rune doc (for \^= examples)
A face, or tree of faces. A `++toga` is applied to anything assigned
using `^=`.
~zod/try=> a=1
a=1
~zod/try=> (ream 'a=1')
[%ktts p=p=%a q=[%dtzy p=%ud q=1]]
~zod/try=> [a b]=[1 2 3]
[a=1 b=[2 3]]
~zod/try=> (ream '[a b]=[1 2 3]')
[ %ktts
p=[%2 p=p=%a q=p=%b]
q=[%cltr p=~[[%dtzy p=%ud q=1] [%dtzy p=%ud q=2] [%dtzy p=%ud q=3]]]
]
~zod/try=> [a ~]=[1 2 3]
[a=1 2 3]
~zod/try=> (ream '[a ~]=[1 2 3]')
[ %ktts
p=[%2 p=p=%a q=[%0 ~]]
q=[%cltr p=~[[%dtzy p=%ud q=1] [%dtzy p=%ud q=2] [%dtzy p=%ud q=3]]]
]
------------------------------------------------------------------------
++trap
++ trap ,_|.(_*) :: makes perfect sense
A trap is a core with one arm `++$`.
See also: `|.`
~zod/try=> *trap
<1.mws 101.jzo 1.ypj %164>
~zod/try=> (*trap)
0
~zod/try=> (|.(42))
42
------------------------------------------------------------------------
++trel
++ trel |* [a=$+(* *) b=$+(* *) c=$+(* *)] :: just a triple
,[p=a q=b r=c] ::
Tile generator. `++trel` is a tuple of three of the types passed in.
~zod/try=> *(trel ,@ud ,@t ,@s)
[p=0 q='' r=--0]
------------------------------------------------------------------------
++tuna
++ tuna :: tagflow
$% [%a p=twig] :: plain text
[%b p=twig] :: single tag
[%c p=twig] :: simple list
[%d p=twig] :: dynamic list
[%e p=twig q=(list tuna)] :: element
[%f p=(list tuna)] :: subflow
== ::
An XML template tree.
Leaf %a contains plain-text, %b an empty tag, %c a static list, %d a
dynamic list, %e a full node element containing a twig and a list of
tuna, and %f is a empty node.
See also: `++sail`
------------------------------------------------------------------------
++twig
See Twig section of Hoon reference
------------------------------------------------------------------------
++tine
++ tine (list ,[p=tile q=twig]) ::
Switch statement cases. In `?-`, for example, your list of cases is a
`++tine`.
See also: `++twig`
~zod/try=> (ream '?-(!! @ |, ^ &)')
[ %wthz
p=[%.n p=~ q=[%zpzp ~]]
q
~[
[p=[%axil p=[%atom p=~.]] q=[%dtzy p=%f q=1]]
[p=[%axil p=%cell] q=[%dtzy p=%f q=0]]
]
]
~zod/try=> (tine |2:(ream '?-(!! @ |, ^ &)'))
~[
[p=[%axil p=[%atom p=~.]] q=[%dtzy p=%f q=1]]
[p=[%axil p=%cell] q=[%dtzy p=%f q=0]]
]
------------------------------------------------------------------------
++tusk
++ tusk (list twig) ::
Variable-arity expression list. In `:*`, for example, your contents are
a `++tusk`.
See also: `++twig`
~zod/try=> (ream '[1 2 3]')
[%cltr p=~[[%dtzy p=%ud q=1] [%dtzy p=%ud q=2] [%dtzy p=%ud q=3]]]
~zod/try=> (tusk +:(ream '[1 2 3]'))
~[[%dtzy p=%ud q=1] [%dtzy p=%ud q=2] [%dtzy p=%ud q=3]]
------------------------------------------------------------------------
++tyre
++ tyre (list ,[p=term q=twig]) ::
Associative list of term to twig, used in jet hint processing.
See also: `++twig`
------------------------------------------------------------------------
++tyke
++ tyke (list (unit twig)) ::
List of twigs, or gaps left to be inferred, in path parsing. When you
use a path such as `/=main=/pub/src/doc` the path is in fact a `++tyke`,
where the `=` are inferred from your current path.
~zod/try=> (scan "/==as=" porc:vast)
[0 ~[~ ~ [~ [%dtzy p=%tas q=29.537]] ~]]
~zod/try=> `tyke`+:(scan "/==as=" porc:vast)
~[~ ~ [~ [%dtzy p=%tas q=29.537]] ~]
------------------------------------------------------------------------
++tram
++ tram (list ,[p=wing q=twig]) ::
List of changes by location in context. When using `%=`, for example,
the list of changes is a `++tram`.
See also: `++twig`
~zod/try=> (ream '$(a 1, b 2)')
[ %cnts
p=~[%$]
q=~[[p=~[%a] q=[%dtzy p=%ud q=1]] [p=~[%b] q=[%dtzy p=%ud q=2]]]
]
~zod/try=> (tram +:(ream '$(a 1, b 2)'))
~[[p=~ q=[% p=0]] [p=~[%a] q=[%dtzy p=%ud q=1]] [p=~[%b] q=[%dtzy p=%ud q=2]]]
------------------------------------------------------------------------
++nock
++ nock $& [p=nock q=nock] :: autocons
$% [%0 p=@] :: axis select
[%1 p=*] :: constant
[%2 p=nock q=nock] :: compose
[%3 p=nock] :: cell test
[%4 p=nock] :: increment
[%5 p=nock q=nock] :: equality test
[%6 p=nock q=nock r=nock] :: if, then, else
[%7 p=nock q=nock] :: serial compose
[%8 p=nock q=nock] :: push onto subject
[%9 p=@ q=nock] :: select arm and fire
[%10 p=?(@ [p=@ q=nock]) q=nock] :: hint
[%11 p=nock] :: grab data from sky
== ::
See Nock doc
~zod/try=> !=([+(.) 20 -<])
[[4 0 1] [1 20] 0 4]
~zod/try=> (nock !=([+(.) 20]))
[p=[%4 p=[%0 p=1]] q=[%1 p=20]]
------------------------------------------------------------------------
++tone
++ tone $% [%0 p=*] :: success
[%1 p=(list)] :: blocks
[%2 p=(list ,[@ta *])] :: error ~_s
== ::
Intermediate Nock computation result. Similar to `++toon`, but stack
trace is not yet rendered.
~zod/try=> (mink [[20 21] 0 3] ,~)
[%0 p=21]
~zod/try=> (mink [[0] !=(.^(cy//=main/1))] ,~)
[%1 p=~[[31.075 1.685.027.454 1.852.399.981 49 0]]]
~zod/try=> (path [31.075 1.685.027.454 1.852.399.981 49 0])
/cy/~zod/main/1
~zod/try=> (mink [[1 2] !=(~|(%hi +(.)))] ,~)
[%2 p=~[[~.yelp 26.984]]]
~zod/try=> (mink [[1 2] !=(!:(+(.)))] ,~)
[ %2
p
~[
[ ~.spot
[ [ 1.685.027.454
7.959.156
\/159.445.990.350.374.058.574.398.238.344.143.957.205.628.479.572.65\/
8.112.403.878.526
\/ \/
0
]
[1 20]
1
24
]
]
]
]
------------------------------------------------------------------------
++toon
++ toon $% [%0 p=*] :: success
[%1 p=(list)] :: blocks
[%2 p=(list tank)] :: stack trace
== ::
Nock computation result. Either success (`%0`), a block with list of
requests blocked on (`%1`), or failure with stack trace (`%2`).
~zod/try=> (mock [[20 21] 0 3] ,~)
[%0 p=21]
~zod/try=> (mock [[0] !=(.^(cy//=main/1))] ,~)
[%1 p=~[[31.075 1.685.027.454 1.852.399.981 49 0]]]
~zod/try=> (path [31.075 1.685.027.454 1.852.399.981 49 0])
/cy/~zod/main/1
~zod/try=> (mock [[1 2] !=(!:(+(.)))] ,~)
[%2 p=~[[%leaf p="/~zod/try/~2014.9.23..18.34.32..d3c5/:<[1 20].[1 24]>"]]]
------------------------------------------------------------------------
++tune
++ tune $% [%0 p=vase] ::
[%1 p=(list)] ::
[%2 p=(list ,[@ta *])] ::
== ::
XX Unused
Probably typed `tone`?
------------------------------------------------------------------------
++twin
++ twin ,[p=term q=wing r=axis s=type] :: alias info
Aliasing. Used in `%bull` `++type` to typecheck aliased faces.
~zod/try=> (~(busk ut %cell %noun [%atom %ud]) %fal [%& 3]~)
[ %bull
p=[p=%fal q=~[[%.y p=3]] r=3 s=[%atom p=%ud]]
q=[%cell p=%noun q=[%atom p=%ud]]
]
~zod/try=> &2:(~(busk ut %cell %noun [%atom %ud]) %fal [%& 3]~)
p=[p=%fal q=~[[%.y p=3]] r=3 s=[%atom p=%ud]]
~zod/try=> (twin &2:(~(busk ut %cell %noun [%atom %ud]) %fal [%& 3]~))
[p=%fal q=~[[%.y p=3]] r=3 s=[%atom p=%ud]]
------------------------------------------------------------------------
++type
See Type section of Hoon reference
------------------------------------------------------------------------
++typo
++ typo type :: old type
Pointer for `++type`. `++typo` preserves the previous `++type` in your
context when upating.
See also: `++seem`, `++vise`, `++type`
------------------------------------------------------------------------
++udal
++ udal :: atomic change (%b)
$: p=@ud :: blockwidth
q=(list ,[p=@ud q=(unit ,[p=@ q=@])]) :: indels
== ::
XX Unused
------------------------------------------------------------------------
++udon
++ udon :: abstract delta
$: p=umph :: preprocessor
$= q :: patch
$% [%a p=* q=*] :: trivial replace
[%b p=udal] :: atomic indel
[%c p=(urge)] :: list indel
[%d p=upas q=upas] :: tree edit
== ::
== ::
See `%clay` doc
------------------------------------------------------------------------
++umph
++ umph :: change filter
$| $? %a :: no filter
%b :: jamfile
%c :: LF text
== ::
$% [%d p=@ud] :: blocklist
== ::
See `%clay` doc
------------------------------------------------------------------------
++unce
++ unce |* a=_,* :: change part
$% [%& p=@ud] :: skip[copy]
[%| p=(list a) q=(list a)] :: p -> q[chunk]
== ::
See `%clay` doc
------------------------------------------------------------------------
++unit
++ unit |* a=_,* :: maybe
$|(~ [~ u=a]) ::
Tile generator. A `++unit` is either `~` or `[~ u=a]` where `a` is the
type that was passed in.
See also: `++bind`, Section 2bA
~zod/try=> :type; *(unit time)
~
u(@da)
~zod/try=> `(unit time)`[~ -<-]
[~ ~2014.9.24..19.25.10..7dd5]
------------------------------------------------------------------------
++upas
++ upas :: tree change (%d)
$& [p=upas q=upas] :: cell
$% [%0 p=axis] :: copy old
[%1 p=*] :: insert new
[%2 p=axis q=udon] :: mutate!
== ::
See `%clay` doc
------------------------------------------------------------------------
++urge
++ urge |*(a=_,* (list (unce a))) :: list change
See `%clay` doc
------------------------------------------------------------------------
++vase
++ vase ,[p=type q=*] :: type-value pair
Typed data. A `++vase` is used wherever typed data is explicitly worked
with.
See `%arvo` doc
~zod/try=> `vase`!>(~)
[p=[%cube p=0 q=[%atom p=%n]] q=0]
------------------------------------------------------------------------
++vise
++ vise ,[p=typo q=*] :: old vase
Used to convert from previously-typed data during reboot.
See `++typo`, `++seer`
------------------------------------------------------------------------
++wall
++ wall (list tape) :: text lines (no \n)
A list of lines. A `++wall` is used instead of a single `++tape` with
`\n`.
See also: `++wash`
~zod/try=> `wall`(wash [0 20] leaf/<(bex 256)>)
<<
"\/115.792.089.237.\/"
" 316.195.423.570."
" 985.008.687.907."
" 853.269.984.665."
" 640.564.039.457."
" 584.007.913.129."
" 639.936"
"\/ \/"
>>
------------------------------------------------------------------------
++wain
++ wain (list cord) :: text lines (no \n)
A list of lines. A `++wain` is used instead of a single `++cord` with
`\n`.
See also: `++lore`, `++role`
~zod/try=> `wain`/som/del/rok
<|som del rok|>
~zod/try=> `wain`(lore ^:@t/=main=/bin/tree/hoon)
<|
!:
:: /===/bin/tree/hoon
|= ^
|= [pax=path fla=$|(~ [%full ~])]
=- ~[te/-]~
=+ len=(lent pax)
=+ rend=?~(fla |=(a=path +:(spud (slag len a))) spud)
|- ^- wain
=+ ark=;;(arch .^(cy/pax))
=- ?~ q.ark -
[(crip (rend pax)) -]
%- zing
%- turn :_ |=(a=@t ^$(pax (weld pax `path`/[a])))
%- sort :_ aor
%- turn :_ |=([a=@t ~] a)
(~(tap by r.ark))
|>
------------------------------------------------------------------------
++wing
++ wing (list limb) ::
Address in subject. A `++wing` is a path to a value in the subject. A
term alone is the trivial case of a `++wing`.
See also: `++twig`
~zod/try=> (ream 'a.+.c')
[%cnzz p=~[%a [%.y p=3] %c]]
~zod/try=> (wing +:(ream 'a.+.c'))
~[%a [%.y p=3] %c]
------------------------------------------------------------------------
++wine
++ wine $| ?(%noun %path %tank %void %wall %wool %yarn)
$% [%atom p=term] ::
[%core p=(list ,@ta) q=wine] ::
[%face p=term q=wine] ::
[%list p=term q=wine] ::
[%pear p=term q=@] ::
[%pick p=(list wine)] ::
[%plot p=(list wine)] ::
[%stop p=@ud] ::
[%tree p=term q=wine] ::
[%unit p=term q=wine] ::
== ::
Printable type. `++wine` is used for pretty printing.
See also: `++calf`
~zod/try=> ~(dole ut p:!>(*@tas))
[p={} q=[%atom p=%tas]]
~zod/try=> `wine`q:~(dole ut p:!>(*@tas))
[%atom p=%tas]
~zod/try=> ~(dole ut p:!>(*path))
[ p
{ [ p=1
q
[ %pick
p
~[
[%pear p=%n q=0]
[%plot p=~[[%face p=%i q=[%atom p=%ta]] [%face p=%t q=[%stop p=1]]]]
]
]
]
}
q=%path
]
~zod/try=> `wine`q:~(dole ut p:!>(*path))
%path
~zod/try=> ~(dole ut p:!>(*(map time cord)))
[ p
{ [ p=1
q
[ %pick
p
~[
[%pear p=%n q=0]
[ %plot
p
~[
[ %face
p=%n
q
[ %plot
p=~[[%face p=%p q=[%atom p=%da]] [%face p=%q q=[%atom p=%t]]]
]
]
[%face p=%l q=[%stop p=1]]
[%face p=%r q=[%stop p=1]]
]
]
]
]
]
}
q
[ %tree
p=%nlr
q=[%plot p=~[[%face p=%p q=[%atom p=%da]] [%face p=%q q=[%atom p=%t]]]]
]
]
~zod/try=> `wine`q:~(dole ut p:!>(*(map time cord)))
[ %tree
p=%nlr
q=[%plot p=~[[%face p=%p q=[%atom p=%da]] [%face p=%q q=[%atom p=%t]]]]
]
------------------------------------------------------------------------
++wonk
++ wonk |*(veq=edge ?~(q.veq !! p.u.q.veq)) ::
:: ::
:: ::
XX Not a model?
++ wonk |*(veq=edge ?~(q.veq !! p.u.q.veq)) ::
Pull result out of a `++edge`, or crash if there's no result.
See also: `++edge`, Section 2eC
~zod/try=> (wide:vast [1 1] "(add 2 2)")
[ p=[p=1 q=10]
q
[ ~
[ p=[%cnhp p=[%cnzz p=~[%add]] q=~[[%dtzy p=%ud q=2] [%dtzy p=%ud q=2]]]
q=[p=[p=1 q=10] q=""]
]
]
]
~zod/try=> (wonk (wide:vast [1 1] "(add 2 2)"))
[%cnhp p=[%cnzz p=~[%add]] q=~[[%dtzy p=%ud q=2] [%dtzy p=%ud q=2]]]
------------------------------------------------------------------------
++map
++ map |* [a=_,* b=_,*] :: associative tree
$|(~ [n=[p=a q=b] l=(map a b) r=(map a b)]) ::
Tile generator. A `++map` is a
[treap](http://en.wikipedia.org/wiki/Treap) of key, value pairs.
See also: `++by`
~zod/try=> :type; *(map ,@t ,@u)
{}
nlr([p=@t q=@u])
~zod/try=> `(map ,@ta ,@ud)`(mo (limo a/1 b/2 ~))
{[p=~.a q=1] [p=~.b q=2]}
------------------------------------------------------------------------
++qeu
++ qeu |* a=_,* :: queue
$|(~ [n=a l=(qeu a) r=(qeu a)]) ::
Tile generator. A `++qeu` is an ordered
[treap](http://en.wikipedia.org/wiki/Treap) of items.
See also: `++to`
~zod/try=> (qeu time)
<1.qyo [* <1.sxx [a=<1.ebd [* <101.jzo 1.ypj %164>]> <101.jzo 1.ypj %164>]>]>
~zod/try=> (~(gas to *(qeu time)) [~2014.1.1 ~2014.1.2 ~])
{~2014.1.2 ~2014.1.1}
------------------------------------------------------------------------
++set
++ set |* a=_,* :: set
$|(~ [n=a l=(set a) r=(set a)]) ::
Tile generator. A `++set` is a
[treap](http://en.wikipedia.org/wiki/Treap) with unique values.
See also: `++in`
~zod/try=> (sa "abc")
{~~a ~~c ~~b}
~zod/try=> (~(put in (sa "abc")) %d)
{~~d ~~a ~~c ~~b}
~zod/try=> (~(put in (sa "abc")) %a)
{~~a ~~c ~~b}
------------------------------------------------------------------------
++jar
++ jar |*([a=_,* b=_,*] (map a (list b))) :: map of lists
Tile generator. A `++jar` is a `++map` of `++list`.
See also: `++ja`, `++by`, `++map`, `++list`
~zod/try=> =a (limo [1 2 ~])
~zod/try=> a
[i=1 t=[i=2 t=~]]
~zod/try=> =b (limo [3 4 ~])
~zod/try=> b
[i=3 t=[i=4 t=~]]
~zod/try=> =c (mo (limo [[%a a] [%b b] ~]))
~zod/try=> c
{[p=%a q=[i=1 t=[i=2 t=~]]] [p=%b q=[i=3 t=[i=4 t=~]]]}
~zod/try=> (~(get ja c) %a)
[i=1 t=[i=2 t=~]]
~zod/try=> (~(get ja c) %c)
~
------------------------------------------------------------------------
++jug
++ jug |*([a=_,* b=_,*] (map a (set b))) :: map of sets
Tile generator. Similar to `++jar`, but with `++set`. A `++jug` is a
`++map` of `++set`.
See also: `++ju`, `++by`, `++map`, `++set`
~zod/try=> =a (sa (limo [1 2 ~]))
~zod/try=> a
{1 2}
~zod/try=> =b (sa (limo [3 4 ~]))
~zod/try=> b
{4 3}
~zod/try=> =c (mo (limo [[%a a] [%b b] ~]))
~zod/try=> c
{[p=%a q={1 2}] [p=%b q={4 3}]}
~zod/try=> (~(get ju c) %b)
{4 3}
~zod/try=> (~(put ju c) [%b 5])
{[p=%a q={1 2}] [p=%b q={5 4 3}]}
------------------------------------------------------------------------