mirror of
https://github.com/ilyakooo0/urbit.git
synced 2024-12-18 20:31:40 +03:00
1787 lines
55 KiB
Markdown
1787 lines
55 KiB
Markdown
volume 1, Hoon Structures
|
|
=========================
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++abel"><code>++abel</code></h3>
|
|
|
|
++ abel typo :: original sin: type
|
|
|
|
Biblical names in hoon are primarily aliases for the compiler.
|
|
|
|
See also: `++typo`
|
|
|
|
~zod/try=> *abel
|
|
%void
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++axis"><code>++axis</code></h3>
|
|
|
|
++ 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
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++also"><code>++also</code></h3>
|
|
|
|
++ also ,[p=term q=wing r=type] :: alias
|
|
|
|
XX unused?
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++base"><code>++base</code></h3>
|
|
|
|
++ 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 ~]]
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++bean"><code>++bean</code></h3>
|
|
|
|
++ 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
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++beer"><code>++beer</code></h3>
|
|
|
|
++ 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]]]
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++beet"><code>++beet</code></h3>
|
|
|
|
++ 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
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++bloq"><code>++bloq</code></h3>
|
|
|
|
++ 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
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++calf"><code>++calf</code></h3>
|
|
|
|
++ 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]
|
|
]
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++char"><code>++char</code></h3>
|
|
|
|
++ 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
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++chub"><code>++chub</code></h3>
|
|
|
|
++ 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.
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++chum"><code>++chum</code></h3>
|
|
|
|
++ 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 ~]]
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++clue"><code>++clue</code></h3>
|
|
|
|
++ 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
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++coil"><code>++coil</code></h3>
|
|
|
|
++ 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
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++coin"><code>++coin</code></h3>
|
|
|
|
++ 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]
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++cord"><code>++cord</code></h3>
|
|
|
|
++ 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'
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++date"><code>++date</code></h3>
|
|
|
|
++ 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]]]
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++dime"><code>++dime</code></h3>
|
|
|
|
++ 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]
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++dram"><code>++dram</code></h3>
|
|
|
|
++ 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
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++each"><code>++each</code></h3>
|
|
|
|
++ 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]}
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++edge"><code>++edge</code></h3>
|
|
|
|
++ 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"]]]]
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++foot"><code>++foot</code></h3>
|
|
|
|
++ 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]]]
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++gate"><code>++gate</code></h3>
|
|
|
|
++ 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]
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++hair"><code>++hair</code></h3>
|
|
|
|
++ 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]
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++like"><code>++like</code></h3>
|
|
|
|
++ 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"]]]]
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++limb"><code>++limb</code></h3>
|
|
|
|
++ 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=%$]
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++line"><code>++line</code></h3>
|
|
|
|
++ 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]]]]
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++list"><code>++list</code></h3>
|
|
|
|
++ 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
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++lone"><code>++lone</code></h3>
|
|
|
|
++ lone |*(a=$+(* *) ,p=a) :: just one thing
|
|
|
|
XX unused
|
|
|
|
Tile generator. `++lone` puts face of `p` on something.
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++mane"><code>++mane</code></h3>
|
|
|
|
++ 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]
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++manx"><code>++manx</code></h3>
|
|
|
|
++ manx ,[g=marx c=marl] :: XML node
|
|
|
|
XML node.
|
|
|
|
Parsed by `++apex`:poxa, rendered by `++poxo`, section 3bD
|
|
|
|
See also: `++sail` doc, Section 3bD
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++marl"><code>++marl</code></h3>
|
|
|
|
++ marl (list manx) :: XML node list
|
|
|
|
List of XML nodes.
|
|
|
|
Parsed within `++apex`:poxa, rendered by `++many`:poxo, section 3bD
|
|
|
|
See also: `++sail` doc
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++mars"><code>++mars</code></h3>
|
|
|
|
++ mars ,[t=[n=%$ a=[i=[n=%$ v=tape] t=~]] c=~] :: XML cdata
|
|
|
|
XML CDATA. Implicitly produced by `++chrd`:poxa
|
|
|
|
See also: `++sail` doc
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++mart"><code>++mart</code></h3>
|
|
|
|
++ 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
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++marx"><code>++marx</code></h3>
|
|
|
|
++ 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
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++metl"><code>++metl</code></h3>
|
|
|
|
++ metl ?(%gold %iron %zinc %lead) :: core variance
|
|
|
|
XX move to `++ut`
|
|
|
|
See also: `++coil`
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++noun"><code>++noun</code></h3>
|
|
|
|
++ noun ,* :: any noun
|
|
|
|
Used nowhere XX
|
|
|
|
~zod/try=> `noun`~[1 2 3]
|
|
[1 2 3 0]
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++null"><code>++null</code></h3>
|
|
|
|
++ null ,~ :: null, nil, etc
|
|
|
|
Used nowhere XX
|
|
|
|
~zod/try=> :type; *null
|
|
~
|
|
%~
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++odor"><code>++odor</code></h3>
|
|
|
|
++ 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
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++tarp"><code>++tarp</code></h3>
|
|
|
|
++ 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=~]
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++time"><code>++time</code></h3>
|
|
|
|
++ 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
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++tree"><code>++tree</code></h3>
|
|
|
|
++ 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"]}
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++nail"><code>++nail</code></h3>
|
|
|
|
++ 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
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++numb"><code>++numb</code></h3>
|
|
|
|
++ numb ,@ :: just a number
|
|
|
|
Used nowhere XX
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++pair"><code>++pair</code></h3>
|
|
|
|
++ 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='']
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++pass"><code>++pass</code></h3>
|
|
|
|
++ pass ,@ :: public key
|
|
|
|
Atom alias. Used primarily in crypto.
|
|
|
|
See also: `++acru`, `++crua`, `++crub`
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++path"><code>++path</code></h3>
|
|
|
|
++ 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
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++pint"><code>++pint</code></h3>
|
|
|
|
++ 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]]
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++pole"><code>++pole</code></h3>
|
|
|
|
++ 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 ~]]]]
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++port"><code>++port</code></h3>
|
|
|
|
++ 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]]
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++post"><code>++post</code></h3>
|
|
|
|
++ 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]]
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++prop"><code>++prop</code></h3>
|
|
|
|
++ 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=~]]
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++qual"><code>++qual</code></h3>
|
|
|
|
++ 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='']
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++rege"><code>++rege</code></h3>
|
|
|
|
++ 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"]}]]
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++ring"><code>++ring</code></h3>
|
|
|
|
++ ring ,@ :: private key
|
|
|
|
Atom alias, used primarily in crypto.
|
|
|
|
See also: `++acru`, `++crua`, `++crub`.
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++rule"><code>++rule</code></h3>
|
|
|
|
++ 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"]]
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++span"><code>++span</code></h3>
|
|
|
|
++ 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'
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++spot"><code>++spot</code></h3>
|
|
|
|
++ 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
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++tang"><code>++tang</code></h3>
|
|
|
|
++ tang (list tank) :: general error
|
|
|
|
Unused XX
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++tank"><code>++tank</code></h3>
|
|
|
|
++ 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
|
|
]
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++tape"><code>++tape</code></h3>
|
|
|
|
++ 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]
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++term"><code>++term</code></h3>
|
|
|
|
++ 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]]
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++tiki"><code>++tiki</code></h3>
|
|
|
|
++ 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]]]
|
|
]
|
|
]
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++tile"><code>++tile</code></h3>
|
|
|
|
See the Tile section of the Hoon Reference.
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++toga"><code>++toga</code></h3>
|
|
|
|
++ 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]]]
|
|
]
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++trap"><code>++trap</code></h3>
|
|
|
|
++ 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
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++trel"><code>++trel</code></h3>
|
|
|
|
++ 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]
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++tuna"><code>++tuna</code></h3>
|
|
|
|
++ 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`
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++twig"><code>++twig</code></h3>
|
|
|
|
See Twig section of Hoon reference
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++tine"><code>++tine</code></h3>
|
|
|
|
++ 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]]
|
|
]
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++tusk"><code>++tusk</code></h3>
|
|
|
|
++ 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]]
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++tyre"><code>++tyre</code></h3>
|
|
|
|
++ tyre (list ,[p=term q=twig]) ::
|
|
|
|
Associative list of term to twig, used in jet hint processing.
|
|
|
|
See also: `++twig`
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++tyke"><code>++tyke</code></h3>
|
|
|
|
++ 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]] ~]
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++tram"><code>++tram</code></h3>
|
|
|
|
++ 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]]]
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++nock"><code>++nock</code></h3>
|
|
|
|
++ 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]]
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++tone"><code>++tone</code></h3>
|
|
|
|
++ 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
|
|
]
|
|
]
|
|
]
|
|
]
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++toon"><code>++toon</code></h3>
|
|
|
|
++ 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]>"]]]
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++tune"><code>++tune</code></h3>
|
|
|
|
++ tune $% [%0 p=vase] ::
|
|
[%1 p=(list)] ::
|
|
[%2 p=(list ,[@ta *])] ::
|
|
== ::
|
|
|
|
XX Unused
|
|
|
|
Probably typed `tone`?
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++twin"><code>++twin</code></h3>
|
|
|
|
++ 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]]
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++type"><code>++type</code></h3>
|
|
|
|
See Type section of Hoon reference
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++typo"><code>++typo</code></h3>
|
|
|
|
++ typo type :: old type
|
|
|
|
Pointer for `++type`. `++typo` preserves the previous `++type` in your
|
|
context when upating.
|
|
|
|
See also: `++seem`, `++vise`, `++type`
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++udal"><code>++udal</code></h3>
|
|
|
|
++ udal :: atomic change (%b)
|
|
$: p=@ud :: blockwidth
|
|
q=(list ,[p=@ud q=(unit ,[p=@ q=@])]) :: indels
|
|
== ::
|
|
|
|
XX Unused
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++udon"><code>++udon</code></h3>
|
|
|
|
++ 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
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++umph"><code>++umph</code></h3>
|
|
|
|
++ umph :: change filter
|
|
$| $? %a :: no filter
|
|
%b :: jamfile
|
|
%c :: LF text
|
|
== ::
|
|
$% [%d p=@ud] :: blocklist
|
|
== ::
|
|
|
|
See `%clay` doc
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++unce"><code>++unce</code></h3>
|
|
|
|
++ unce |* a=_,* :: change part
|
|
$% [%& p=@ud] :: skip[copy]
|
|
[%| p=(list a) q=(list a)] :: p -> q[chunk]
|
|
== ::
|
|
|
|
See `%clay` doc
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++unit"><code>++unit</code></h3>
|
|
|
|
++ 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]
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++upas"><code>++upas</code></h3>
|
|
|
|
++ 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
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++urge"><code>++urge</code></h3>
|
|
|
|
++ urge |*(a=_,* (list (unce a))) :: list change
|
|
|
|
See `%clay` doc
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++vase"><code>++vase</code></h3>
|
|
|
|
++ 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]
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++vise"><code>++vise</code></h3>
|
|
|
|
++ vise ,[p=typo q=*] :: old vase
|
|
|
|
Used to convert from previously-typed data during reboot.
|
|
|
|
See `++typo`, `++seer`
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++wall"><code>++wall</code></h3>
|
|
|
|
++ 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"
|
|
"\/ \/"
|
|
>>
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++wain"><code>++wain</code></h3>
|
|
|
|
++ 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))
|
|
|>
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++wing"><code>++wing</code></h3>
|
|
|
|
++ 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]
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++wine"><code>++wine</code></h3>
|
|
|
|
++ 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]]]]
|
|
]
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++wonk"><code>++wonk</code></h3>
|
|
|
|
++ 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]]]
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++map"><code>++map</code></h3>
|
|
|
|
++ 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]}
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++qeu"><code>++qeu</code></h3>
|
|
|
|
++ 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}
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++set"><code>++set</code></h3>
|
|
|
|
++ 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}
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++jar"><code>++jar</code></h3>
|
|
|
|
++ 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)
|
|
~
|
|
|
|
------------------------------------------------------------------------
|
|
|
|
<h3 id="++jug"><code>++jug</code></h3>
|
|
|
|
++ 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}]}
|
|
|
|
------------------------------------------------------------------------
|