@@ -0,0 +1,1786 @@
1+volume 1, Hoon Structures
2+=========================
3+
4+------------------------------------------------------------------------
5+
6+### `++abel`
7+
8+ ++ abel typo :: original sin: type
9+
10+Biblical names in hoon are primarily aliases for the compiler.
11+
12+See also: `++typo`
13+
14+ ~zod/try=> *abel
15+ %void
16+
17+------------------------------------------------------------------------
18+
19+### `++axis`
20+
21+ ++ axis ,@ :: tree address
22+
23+A Nock axis inside a noun. After the leading 1, in binary, a 1 signfies
24+right and 0 left.
25+
26+See also: `++clue`, `++limb`, `++slot`, `++peg`, and Section 2fC
27+
28+ ~zod/try=> *axis
29+ 0
30+
31+ ~zod/try=> :: 0 is not actually a valid axis
32+ ~zod/try=> [[4 5] 6 7]
33+ [[4 5] 6 7]
34+ ~zod/try=> `axis`0b110
35+ 6
36+
37+------------------------------------------------------------------------
38+
39+### `++also`
40+
41+ ++ also ,[p=term q=wing r=type] :: alias
42+
43+XX unused?
44+
45+------------------------------------------------------------------------
46+
47+### `++base`
48+
49+ ++ base ?([%atom p=odor] %noun %cell %bean %null) :: axils, @ * ^ ? ~
50+
51+A base type that nouns are built from. Either a noun, a cell, loobean or
52+null labelled with an odor.
53+
54+See also: `++tile`, `++twig`
55+
56+ ~zod/try=> *base
57+ %null
58+
59+ ~zod/try=> (ream '=|(^ !!)')
60+ [%tsbr p=[%axil p=%cell] q=[%zpzp ~]]
61+ ~zod/try=> :: p.p is a ++base
62+ ~zod/try=> (ream '=|(@t !!)')
63+ [%tsbr p=[%axil p=[%atom p=~.t]] q=[%zpzp ~]]
64+ ~zod/try=> (ream '=|(? !!)')
65+ [%tsbr p=[%axil p=%bean] q=[%zpzp ~]]
66+
67+------------------------------------------------------------------------
68+
69+### `++bean`
70+
71+ ++ bean ,? :: 0=&=yes, 1=|=no
72+
73+The Urbit version of a boolean, which we call a loobean. 0 or & is
74+"yes", 1 or | is "no".
75+
76+ ~zod/try=> *bean
77+ %.y
78+
79+ ~zod/try=> `bean`&
80+ %.y
81+ ~zod/try=> `bean`|
82+ %.n
83+
84+------------------------------------------------------------------------
85+
86+### `++beer`
87+
88+ ++ beer $|(@ [~ p=twig]) :: simple embed
89+
90+Used to build tapes internally.
91+
92+See also: `++phax`, `++scat`, section 2fD
93+
94+ ~zod/try=> `beer`'as'
95+ 29.537
96+ ~zod/try=> `beer`[~ (ream 'lan')]
97+ [~ p=[%cnzz p=~[%lan]]]
98+
99+------------------------------------------------------------------------
100+
101+### `++beet`
102+
103+ ++ beet $| @ :: advanced embed
104+ $% [%a p=twig] :: take tape
105+ [%b p=twig] :: take manx
106+ [%c p=twig] :: take marl
107+ [%d p=twig] :: take $+(marl marl)
108+ [%e p=twig q=(list tuna)] :: element literal
109+ == ::
110+
111+Cases for XML interpolation. Used internally.
112+
113+See also: `++sail`, section 2fD
114+
115+------------------------------------------------------------------------
116+
117+### `++bloq`
118+
119+ ++ bloq ,@ :: blockclass
120+
121+Atom representing a blocksize, by convention expressed as a power of 2.
122+
123+See also: section 2cA
124+
125+ ~zod/try=> :: ++met measures how many bloqs long an atom is
126+ ~zod/try=> (met 3 256)
127+ 2
128+ ~zod/try=> :: 256 is 2 bloqs of 2^3
129+
130+------------------------------------------------------------------------
131+
132+### `++calf`
133+
134+ ++ calf ,[p=(map ,@ud wine) q=wine] ::
135+
136+Encodes cyclical backreferences in types. Used in pretty printing.
137+
138+See also: `++wine`, `++dole`, `++doge`, `++dish`, section 2fC
139+
140+ ~zod/try=> `calf`[~ %atom %ta]
141+ [p={} q=[%atom p=%ta]]
142+
143+ ~zod/try=> `calf`~(dole ut p:!>(*^))
144+ [p={} q=[%plot p=~[%noun %noun]]]
145+
146+ ~zod/try=> `calf`~(dole ut p:!>($:|-(?(~ [* $]))))
147+ [ p={[p=1 q=[%pick p=~[[%pear p=%n q=0] [%plot p=~[%noun [%stop p=1]]]]]]}
148+ q=[%stop p=1]
149+ ]
150+
151+------------------------------------------------------------------------
152+
153+### `++char`
154+
155+ ++ char ,@tD :: UTF-8 byte
156+
157+A single character. Odor `@tD` designates a single Unicode byte. All
158+parsers consume `++tape` (a list of `++char`).
159+
160+See also: `++tape`, `++lust`, `++just`, `++mask`, chapter 2f
161+
162+ ~zod/try=> *char
163+ ~~
164+
165+ ~zod/try=> (char 97)
166+ ~~a
167+
168+------------------------------------------------------------------------
169+
170+### `++chub`
171+
172+ ++ chub :: registered battery
173+ $: p=(pair chum tyre) :: definition
174+ q=* :: battery
175+ r=(unit (pair axis chub)) :: parent
176+ == ::
177+
178+Used by the compiler (implicitly by `%sgcn`) to attach jets.
179+
180+See also: Section 2fB.
181+
182+------------------------------------------------------------------------
183+
184+### `++chum`
185+
186+ ++ chum $? lef=term :: jet name
187+ [std=term kel=@] :: kelvin version
188+ [ven=term pro=term kel=@] :: vendor and product
189+ [ven=term pro=term ver=@ kel=@] :: all of the above
190+ == ::
191+
192+Jet hint information that must be present in the body of a \~/ or \~%
193+rune. A `++chum` can optionally contain a kelvin version, jet vendor,
194+and major.minor version number.
195+
196+XX there's a ++chum in zuse that's politely causing this not to work
197+
198+See also: `++twig`, `++clue`
199+
200+ ~zod/try=> `chum`'hi'
201+ lef=%hi
202+
203+ ~zod/try=> (ream '~/(%lob.314 !!)')
204+ [%sgfs p=[std=%lob kel=314] q=[%zpzp ~]]
205+
206+------------------------------------------------------------------------
207+
208+### `++clue`
209+
210+ ++ clue ,[p=axis q=chum r=tyre] :: battery definition
211+
212+Used by compiler to attach jets.
213+
214+XX implementation does not currenlty match docs
215+
216+See also: section 2fB
217+
218+------------------------------------------------------------------------
219+
220+### `++coil`
221+
222+ ++ coil $: p=?(%gold %iron %lead %zinc) :: core type
223+ q=type ::
224+ r=[p=?(~ ^) q=(map term foot)] ::
225+ == ::
226+
227+Core information tuple: variance, subject type, optional compiled nock,
228+and arms. Used as an intermediate step within Section 2fB. Converted by
229+`++core` to %core type.
230+
231+See also: `++core`, Section 2fB
232+
233+------------------------------------------------------------------------
234+
235+### `++coin`
236+
237+ ++ coin $% [%$ p=dime] ::
238+ [%blob p=*] ::
239+ [%many p=(list coin)] ::
240+ == ::
241+
242+Noun literal syntax cases: atoms, jammed nouns, and nestable tuples.
243+Parsed and printed using `++so` and `++co` cores in Section 2eL
244+respectively.
245+
246+See also: `++so`, `++co`, Section 2eL, `++dime`
247+
248+ ~zod/try=> `coin`(need (slay '~s1'))
249+ [%$ p=[p=~.dr q=18.446.744.073.709.551.616]]
250+ ~zod/try=> `coin`(need (slay '0x2b59'))
251+ [%$ p=[p=~.ux q=11.097]]
252+
253+ ~zod/try=> ~(rend co [%many ~[[%$ %ud 1] [%$ %tas 'a'] [%$ %s -2]]])
254+ "._1_a_-2__"
255+ ~zod/try=> ._1_a_-2__
256+ [1 %a -2]
257+
258+ ~zod/try=> `@uv`(jam [3 4])
259+ 0v2cd1
260+ ~zod/try=> (slay '~02cd1')
261+ [~ [%blob p=[3 4]]]
262+ ~zod/try=> ~02cd1
263+ [3 4]
264+
265+------------------------------------------------------------------------
266+
267+### `++cord`
268+
269+ ++ cord ,@t :: text atom (UTF-8)
270+
271+One of Hoon's two string types (the other being `++tape`). A cord is an
272+atom of UTF-8 text. `++trip` and `++crip` convert between cord and
273+`++tape`
274+
275+Odor `@t` designates a Unicode atom, little-endian: the first character
276+in the text is the low byte.
277+
278+See also: `++trip`, `++crip`, Section 2eJ
279+
280+ ~zod/try=> `@ux`'foobar'
281+ 0x7261.626f.6f66
282+
283+ ~zod/try=> `@`'urbit'
284+ 499.984.265.845
285+ ~zod/try=> (cord 499.984.265.845)
286+ 'urbit'
287+
288+------------------------------------------------------------------------
289+
290+### `++date`
291+
292+ ++ date ,[[a=? y=@ud] m=@ud t=tarp] :: parsed date
293+
294+A point in time. A loobean designating AD or BC, a year atom, a month
295+atom, and a `++tarp`, which is a day atom and a time.
296+
297+See also: `++year`, `++yore`, Section 2cH, `++stud`, `++dust`, Section
298+3bc
299+
300+ ~zod/try=> `date`(yore ~2014.6.6..21.09.15..0a16)
301+ [[a=%.y y=2.014] m=6 t=[d=6 h=21 m=9 s=15 f=~[0xa16]]]
302+
303+------------------------------------------------------------------------
304+
305+### `++dime`
306+
307+ ++ dime ,[p=@ta q=@] ::
308+
309+Odor-atom pair, used in `++coin`.
310+
311+Convenience methods `++scot` and `++scow` (in Section 2eL) print dimes
312+as cords/tapes, `++slat`, `++slav`, and `++slaw` are used to parse atoms
313+of specific odor.
314+
315+See also: `++so`, `++co`, Section 2eL, `++coin`
316+
317+ ~zod/try=> +>:(slay '0x123')
318+ p=[p=~.ux q=291]
319+
320+------------------------------------------------------------------------
321+
322+### `++dram`
323+
324+ ++ dram $% [| p=(map ,@tas dram)] :: simple unix dir
325+ [& p=@ud q=@] ::
326+ == ::
327+
328+The structure of a unix filesystem tree. A `++dram` is one of two cases:
329+`|` a directory - a map of names to deeper tree structures, `&` a file -
330+a numbered atom of data.
331+
332+XX Unused
333+
334+------------------------------------------------------------------------
335+
336+### `++each`
337+
338+ ++ each |*([a=$+(* *) b=$+(* *)] $%([& p=a] [| p=b])) :: either a or b
339+
340+Tile generator: produces a discriminated fork between two types.
341+
342+ ~zod/try=> :type; *(each cord time)
343+ [%.y p='']
344+ {[%.y p=@t] [%.n p=@da]}
345+
346+------------------------------------------------------------------------
347+
348+### `++edge`
349+
350+ ++ edge ,[p=hair q=(unit ,[p=* q=nail])] :: parsing output
351+
352+Parsing location metadata: optional result and parsing continuation.
353+
354+See also: Section 2eD, `++rule`
355+
356+ ~zod/try=> *edge
357+ [p=[p=0 q=0] q=~]
358+ ~zod/try=> (tall:vast [1 1] "a b")
359+ [p=[p=1 q=2] q=[~ [p=[%cnzz p=~[%a]] q=[p=[p=1 q=2] q=" b"]]]]
360+
361+------------------------------------------------------------------------
362+
363+### `++foot`
364+
365+ ++ foot $% [%ash p=twig] :: dry arm, geometric
366+ [%elm p=twig] :: wet arm, generic
367+ [%oak ~] :: XX not used
368+ [%yew p=(map term foot)] :: XX not used
369+ == ::
370+
371+Cases of arms by variance model.
372+
373+See also: `++ap`, `++ut`, Section 2fB, Section 2fC
374+
375+ ~zod/try=> *foot
376+ [%yew p={}]
377+
378+ ~zod/try=> (ream '|% ++ $ foo --')
379+ [%brcn p={[p=%$ q=[%ash p=[%cnzz p=~[%foo]]]]}]
380+ ~zod/try=> +<+:(ream '|% ++ $ foo --')
381+ t=~[%ash %cnzz %foo]
382+ ~zod/try=> (foot +<+:(ream '|% ++ $ foo --'))
383+ [%ash p=[%cnzz p=~[%foo]]]
384+ ~zod/try=> (foot +<+:(ream '|% +- $ foo --'))
385+ [%elm p=[%cnzz p=~[%foo]]]
386+
387+------------------------------------------------------------------------
388+
389+### `++gate`
390+
391+ ++ gate $+(* *) :: general gate
392+
393+An core with one arm, `$`, which transforms a sample noun into a product
394+noun. If used dryly as a type, subject must have a sample type of `*`.
395+
396+See also: `++lift`, `++cork`, Core Language Doc
397+
398+ ~zod/try=> *gate
399+ <1|mws [* <101.jzo 1.ypj %164>]>
400+ ~zod/try=> `gate`|=(* 0)
401+ <1|mws [* <101.jzo 1.ypj %164>]>
402+
403+ ~zod/try=> (|=(a=* [a 'b']) 'c')
404+ [99 'b']
405+ ~zod/try=> (`gate`|=(a=* [a 'b']) 'c')
406+ [99 98]
407+
408+------------------------------------------------------------------------
409+
410+### `++hair`
411+
412+ ++ hair ,[p=@ud q=@ud] :: parsing trace
413+
414+A pair of two `@ud` used in parsing indicating line and column number.
415+
416+See also: `++last`, Section 2eB
417+
418+ ~zod/try=> *hair
419+ [p=0 q=0]
420+
421+ ~zod/try=> `hair`[1 1] :: parsing starts at [1 1] as a convention.
422+ [p=1 q=1]
423+ ~zod/try=> ((plus ace) [1 1] " --")
424+ [p=[p=1 q=4] q=[~ u=[p=[~~. " "] q=[p=[p=1 q=4] q="--"]]]]
425+ ~zod/try=> `hair`p:((plus ace) [1 1] " --")
426+ [p=1 q=4]
427+
428+------------------------------------------------------------------------
429+
430+### `++like`
431+
432+ ++ like |* a=_,* :: generic edge
433+ |= b=_`*`[(hair) ~] ::
434+ :- p=(hair -.b) ::
435+ ^= q ::
436+ ?@ +.b ~ ::
437+ :- ~ ::
438+ u=[p=(a +>-.b) q=[p=(hair -.b) q=(tape +.b)]] ::
439+
440+Tile generator for an `++edge`. `++like` generates an `++edge` with a
441+parsed result set to a specific type.
442+
443+See also: `++easy`, `++just`/`++jest`, `++knee`, `++mask`, `++shim`,
444+`++stir`, `++stun`, Section 2eC
445+
446+ ~zod/try=> *(like char)
447+ [p=[p=0 q=0] q=~]
448+
449+ ~zod/try=> (ace [1 1] " a")
450+ [p=[p=1 q=2] q=[~ [p=~~. q=[p=[p=1 q=2] q="a"]]]]
451+ ~zod/try=> `(like char)`(ace [1 1] " a")
452+ [p=[p=1 q=2] q=[~ [p=~~. q=[p=[p=1 q=2] q="a"]]]]
453+ ~zod/try=> `(like ,@)`(ace [1 1] " a")
454+ [p=[p=1 q=2] q=[~ [p=32 q=[p=[p=1 q=2] q="a"]]]]
455+
456+------------------------------------------------------------------------
457+
458+### `++limb`
459+
460+ ++ limb $|(term $%([%& p=axis] [%| p=@ud q=term])) ::
461+
462+XX move to `++ut`
463+
464+Reference into subject by name/axis
465+
466+See also: section 2fC-2fD
467+
468+ ~zod/try=> (ream '^^$')
469+ [%cnzz p=~[[%.n p=2 q=%$]]]
470+ ~zod/try=> (limb &2:(ream '^^$'))
471+ [%.n p=2 q=%$]
472+ ~zod/try=> (limb &2:(ream '^^^$'))
473+ [%.n p=3 q=%$]
474+
475+------------------------------------------------------------------------
476+
477+### `++line`
478+
479+ ++ line ,[p=[%leaf p=odor q=@] q=tile] :: %kelp case
480+
481+XX move to `++ut`
482+
483+Dicriminated union unionee XX
484+
485+Used in compilation and grammar, section 2fC-2fD
486+
487+ ~zod/try=> (ream '$%([1 a] [%2 b])')
488+ [ %bccm
489+ p
490+ [ %kelp
491+ p
492+ [ i=[p=[%leaf p=~.ud q=1] q=[%herb p=[%cnzz p=~[%a]]]]
493+ t=~[[p=[%leaf p=~.ud q=2] q=[%herb p=[%cnzz p=~[%b]]]]]
494+ ]
495+ ]
496+ ]
497+ ~zod/try=> &3:(ream '$%([1 a] [%2 b])')
498+ p=[p=[%leaf p=%ud q=1] q=[%herb p=[%cnzz p=~[%a]]]]
499+ ~zod/try=> (line &3:(ream '$%([1 a] [%2 b])'))
500+ [p=[%leaf p=~.ud q=1] q=[%herb p=[%cnzz p=~[%a]]]]
501+
502+------------------------------------------------------------------------
503+
504+### `++list`
505+
506+ ++ list |* a=_,* :: null-term list
507+ $|(~ [i=a t=(list a)]) ::
508+
509+Tile generator. `++list` generates a tile of a null-terminated list of
510+homogenous type.
511+
512+See also: `++turn`, `++snag`, section 2bB.
513+
514+ ~zod/try=> *(list)
515+ ~
516+ ~zod/try=> `(list ,@)`"abc"
517+ ~[97 98 99]
518+ ~zod/try=> (snag 0 "abc")
519+ ~~a
520+
521+------------------------------------------------------------------------
522+
523+### `++lone`
524+
525+ ++ lone |*(a=$+(* *) ,p=a) :: just one thing
526+
527+XX unused
528+
529+Tile generator. `++lone` puts face of `p` on something.
530+
531+------------------------------------------------------------------------
532+
533+### `++mane`
534+
535+ ++ mane $|(@tas [@tas @tas]) :: XML name/space
536+
537+An XML name (tag name or attribute name) with an optional namespace.
538+Parsed by `++name`:poxa, rendered by `++name`:poxo.
539+
540+See also: `++sail` doc, Section 3bD
541+
542+ ~zod/try=> *mane
543+ %$
544+
545+ ~zod/try=> `mane`n.g:`manx`;div:namespace;
546+ %div
547+ ~zod/try=> `mane`n.g:`manx`;div_namespace;
548+ [%div %namespace]
549+
550+------------------------------------------------------------------------
551+
552+### `++manx`
553+
554+ ++ manx ,[g=marx c=marl] :: XML node
555+
556+XML node.
557+
558+Parsed by `++apex`:poxa, rendered by `++poxo`, section 3bD
559+
560+See also: `++sail` doc, Section 3bD
561+
562+------------------------------------------------------------------------
563+
564+### `++marl`
565+
566+ ++ marl (list manx) :: XML node list
567+
568+List of XML nodes.
569+
570+Parsed within `++apex`:poxa, rendered by `++many`:poxo, section 3bD
571+
572+See also: `++sail` doc
573+
574+------------------------------------------------------------------------
575+
576+### `++mars`
577+
578+ ++ mars ,[t=[n=%$ a=[i=[n=%$ v=tape] t=~]] c=~] :: XML cdata
579+
580+XML CDATA. Implicitly produced by `++chrd`:poxa
581+
582+See also: `++sail` doc
583+
584+------------------------------------------------------------------------
585+
586+### `++mart`
587+
588+ ++ mart (list ,[n=mane v=tape]) :: XML attributes
589+
590+List of XML attributes. Each `++mart` is a list of pairs of `++mane` and
591+`++tape`.
592+
593+Parsed by `++attr`:poxa, rendered by `++attr`:poxo, section 3bD
594+
595+See also: `++sail` doc
596+
597+------------------------------------------------------------------------
598+
599+### `++marx`
600+
601+ ++ marx ,[n=mane a=mart] :: XML tag
602+
603+XML tag. A `++marx` is a pair of a tag name, `++mane` and a list of
604+attributes, `++mart`.
605+
606+Parsed by `++head`:poxa, rendered within `++poxo`, section 3bD
607+
608+See also: `++sail` doc
609+
610+------------------------------------------------------------------------
611+
612+### `++metl`
613+
614+ ++ metl ?(%gold %iron %zinc %lead) :: core variance
615+
616+XX move to `++ut`
617+
618+See also: `++coil`
619+
620+------------------------------------------------------------------------
621+
622+### `++noun`
623+
624+ ++ noun ,* :: any noun
625+
626+Used nowhere XX
627+
628+ ~zod/try=> `noun`~[1 2 3]
629+ [1 2 3 0]
630+
631+------------------------------------------------------------------------
632+
633+### `++null`
634+
635+ ++ null ,~ :: null, nil, etc
636+
637+Used nowhere XX
638+
639+ ~zod/try=> :type; *null
640+ ~
641+ %~
642+
643+------------------------------------------------------------------------
644+
645+### `++odor`
646+
647+ ++ odor ,@ta :: atom format
648+
649+By convetion, a short name for a category of atom. `++odor` is
650+circularly defined, `@ta` being the `++odor` of the ASCII subset
651+commonly used in urbit.
652+
653+See also: `++base`, odor reference
654+
655+ ~zod/try=> `odor`%ux
656+ ~.ux
657+
658+------------------------------------------------------------------------
659+
660+### `++tarp`
661+
662+ ++ tarp ,[d=@ud h=@ud m=@ud s=@ud f=(list ,@ux)] :: parsed time
663+
664+The remaining part of a `++date`: day, hour, minute, second and a list
665+of `@ux` for precision.
666+
667+See also: `++date`, `++yell`/`++yule`, Section 2cH
668+
669+ ~zod/try=> -<-
670+ ~2014.9.20..00.43.33..b52a
671+ ~zod/try=> :: the time is always in your context at -<-
672+ ~zod/try=> (yell -<-)
673+ [d=106.751.991.820.278 h=0 m=43 s=39 f=~[0x54d1]]
674+
675+ ~zod/try=> (yell ~d20)
676+ [d=20 h=0 m=0 s=0 f=~]
677+
678+------------------------------------------------------------------------
679+
680+### `++time`
681+
682+ ++ time ,@da :: galactic time
683+
684+The `@da` odor designates an absolute date atom.
685+
686+See also: `++date`, odor reference
687+
688+ ~zod/try=> `time`-<-
689+ ~2014.9.25..20.01.47..eeac
690+ ~zod/try=> :: the time is always in your context at -<-
691+ ~zod/try=> `time`~2014.1.1
692+ ~2014.1.1
693+
694+------------------------------------------------------------------------
695+
696+### `++tree`
697+
698+ ++ tree |* a=_,* :: binary tree
699+ $|(~ [n=a l=(tree a) r=(tree a)]) ::
700+
701+Tile generator. A `++tree` can be empty, or contain a node of a type and
702+left/right sub `++tree`s of the same type. Pretty-printed with `{}`.
703+
704+ ~zod/try=> `(tree ,[@ tape])`[[1 "hi"] [[2 "bye"] ~ ~] ~]
705+ {[2 "bye"] [1 "hi"]}
706+
707+------------------------------------------------------------------------
708+
709+### `++nail`
710+
711+ ++ nail ,[p=hair q=tape] :: parsing input
712+
713+Location in parsed text, and remainder of it. Indicates parsing position
714+and remaining text to be parsed.
715+
716+See also: `++roll`
717+
718+ ~zod/try=> +<:;~(plug cab cab)
719+ c=tub=[p=[p=0 q=0] q=""]
720+ ~zod/try=> :: tub is a ++nail
721+
722+------------------------------------------------------------------------
723+
724+### `++numb`
725+
726+ ++ numb ,@ :: just a number
727+
728+Used nowhere XX
729+
730+------------------------------------------------------------------------
731+
732+### `++pair`
733+
734+ ++ pair |*([a=$+(* *) b=$+(* *)] ,[p=a q=b]) :: just a pair
735+
736+Tile generator. Produces a tuple of two of the types passed in.
737+
738+ ~zod/try=> *(pair bean cord)
739+ [p=%.y q='']
740+
741+------------------------------------------------------------------------
742+
743+### `++pass`
744+
745+ ++ pass ,@ :: public key
746+
747+Atom alias. Used primarily in crypto.
748+
749+See also: `++acru`, `++crua`, `++crub`
750+
751+------------------------------------------------------------------------
752+
753+### `++path`
754+
755+ ++ path (list span) :: filesys location
756+
757+A filesystem path. A `++path` is a list of `++span`, `@ta`. Used in
758+`%clay` and `%eyre` extensively.
759+
760+ ~zod/try=> `path`"abc"
761+ /a/b/c
762+
763+------------------------------------------------------------------------
764+
765+### `++pint`
766+
767+ ++ pint ,[p=[p=@ q=@] q=[p=@ q=@]] :: line/column range
768+
769+A parsing range, mostly used for stacktraces. A `++pint` is a pair of
770+hairs indicating from - to.
771+
772+ ~zod/try=> !:(!!)
773+ ! /~zod/try/~2014.9.20..01.22.04..52e3/:<[1 4].[1 6]>
774+ ~zod/try=> :: !! always produces a crash
775+ ~zod/try=> `pint`[[1 4] [1 6]]
776+ [p=[p=1 q=4] q=[p=1 q=6]]
777+
778+------------------------------------------------------------------------
779+
780+### `++pole`
781+
782+ ++ pole |* a=_,* :: nameless list
783+ $|(~ [a (pole a)]) ::
784+
785+A `++list` without the faces. A `++pole` is a null-terminated tuple
786+without the `i=` and `t=`.
787+
788+ ~zod/try=> `(pole char)`"asdf"
789+ [~~a [~~s [~~d [~~f ~]]]]
790+
791+------------------------------------------------------------------------
792+
793+### `++port`
794+
795+ ++ port $: p=axis ::
796+ $= q ::
797+ $% [%& p=type] ::
798+ [%| p=axis q=(list ,[p=type q=foot])] ::
799+ == ::
800+ == ::
801+
802+XX move to `++ut`
803+
804+Type and location of core-shaped thing? XX Compiler Internals
805+
806+ ~zod/try=> *port
807+ [p=0 q=[%.y p=%void]]
808+
809+------------------------------------------------------------------------
810+
811+### `++post`
812+
813+ ++ post $: p=axis ::
814+ $= q ::
815+ $% [0 p=type] ::
816+ [1 p=axis q=(list ,[p=type q=foot])] ::
817+ [2 p=twin q=type] ::
818+ == ::
819+ == ::
820+
821+XX move to `++ut`
822+
823+Type and location of possibly core-shaped thing? XX Compiler Internals
824+
825+ ~zod/try=> *post
826+ [p=0 q=[%0 p=%void]]
827+
828+------------------------------------------------------------------------
829+
830+### `++prop`
831+
832+ ++ prop $: p=axis ::
833+ $= q ::
834+ [p=?(~ axis) q=(list ,[p=type q=foot])] ::
835+ == ::
836+
837+XX move to `++ut`
838+
839+Verified core-shaped thing? XX Compiler Internals
840+
841+ ~zod/try=> *prop
842+ [p=0 q=[p=~ q=~]]
843+
844+------------------------------------------------------------------------
845+
846+### `++qual`
847+
848+ ++ qual |* [a=$+(* *) b=$+(* *) c=$+(* *) d=$+(* *)] :: just a quadruple
849+ ,[p=a q=b r=c s=d] ::
850+
851+Tile generator. A `++qual` is a tuple of four of the types passed in..
852+
853+ ~zod/try=> *(qual date time tape cord)
854+ [p=[[a=%.y y=0] m=0 t=[d=0 h=0 m=0 s=0 f=~]] q=~292277024401-.1.1 r="" s='']
855+
856+------------------------------------------------------------------------
857+
858+### `++rege`
859+
860+ ++ rege $| ?(%dote %ende %sart %empt %boun %bout) :: parsed regex
861+ $% [%lite p=char] :: literal
862+ [%pair p=rege q=rege] :: ordering
863+ [%capt p=rege q=@u] :: capture group
864+ [%brac p=@] :: p is 256 bitmask
865+ [%eith p=rege q=rege] :: either
866+ [%mant p=rege] :: greedy 0 or more
867+ [%plls p=rege] :: greedy 1 or more
868+ [%betw p=rege q=@u r=@u] :: between q and r
869+ [%bint p=rege q=@u] :: min q
870+ [%bant p=rege q=@u] :: exactly q
871+ [%manl p=rege] :: lazy 0 or more
872+ [%plll p=rege] :: lazy 1 or more
873+ [%betl p=rege q=@u r=@u] :: between q and r lazy
874+ [%binl p=rege q=@u] :: min q lazy
875+ == ::
876+
877+Regular expressions. `++rege` defines the cases of a regex.
878+
879+See also: `++rexp`, `++repg`, `++pars`
880+
881+ ~zod/try=> (pars "[a-z]")
882+ [~ [%brac p=10.633.823.807.823.001.954.701.781.295.154.855.936]]
883+ ~zod/try=> (rexp "[a-z]" "abc1")
884+ [~ [~ {[p=0 q="a"]}]]
885+
886+------------------------------------------------------------------------
887+
888+### `++ring`
889+
890+ ++ ring ,@ :: private key
891+
892+Atom alias, used primarily in crypto.
893+
894+See also: `++acru`, `++crua`, `++crub`.
895+
896+------------------------------------------------------------------------
897+
898+### `++rule`
899+
900+ ++ rule |=(tub=nail `edge`[p.tub ~ ~ tub]) :: parsing rule
901+
902+Parsing rule. `++rule` is an empty parsing rule, but it is used to check
903+that parsing rules match this with `_`.
904+
905+See also: `++cold`, Section 2eC
906+
907+ ~zod/try=> *rule
908+ [p=[p=0 q=0] q=[~ [p=0 q=[p=[p=0 q=0] q=""]]]]
909+
910+ ~zod/try=> ^+(rule [|=(a=nail [p.a ~])]:|6)
911+ <1.dww [tub=[p=[p=@ud q=@ud] q=""] <101.jzo 1.ypj %164>]>
912+ ~zod/try=> (^+(rule [|=(a=nail [p.a ~ u=['a' a]])]:|6) [1 1] "hi")
913+ [p=[p=1 q=1] q=[~ [p=97 q=[p=[p=1 q=1] q="hi"]]]]
914+ ~zod/try=> ([|=(a=nail [p.a ~ u=['a' a]])]:|6 [1 1] "hi")
915+ [[p=1 q=1] ~ u=['a' p=[p=1 q=1] q="hi"]]
916+
917+------------------------------------------------------------------------
918+
919+### `++span`
920+
921+ ++ span ,@ta :: text-atom (ASCII)
922+
923+A restricted text atom for canonical atom syntaxes. The prefix is `~.`.
924+There are no escape sequences except `~~`, which means `~`, and `~-`,
925+which means `_`. `-` and `.` encode themselves. No other characters
926+besides numbers and lowercase letters are permitted.
927+
928+ ~zod/try=> *span
929+ ~.
930+
931+ ~zod/try=> `@t`~.foo
932+ 'foo'
933+ ~zod/try=> `@t`~.foo.bar
934+ 'foo.bar'
935+ ~zod/try=> `@t`~.foo~~bar
936+ 'foo~bar'
937+ ~zod/try=> `@t`~.foo~-bar
938+ 'foo_bar'
939+ ~zod/try=> `@t`~.foo-bar
940+ 'foo-bar'
941+
942+------------------------------------------------------------------------
943+
944+### `++spot`
945+
946+ ++ spot ,[p=path q=pint] :: range in file
947+
948+Stack trace line. A `++spot` is what we print after crashing.
949+
950+See also: `++pint`
951+
952+ ~zod/try=> :into /=main=/bin/fail/hoon '!: !!'
953+ + /~zod/main/359/bin/fail/hoon
954+ ~zod/try=> :fail
955+ ! /~zod/main/~2014.9.22..18.40.56..ef04/bin/fail/:<[1 5].[1 7]>
956+ ! exit
957+
958+------------------------------------------------------------------------
959+
960+### `++tang`
961+
962+ ++ tang (list tank) :: general error
963+
964+Unused XX
965+
966+------------------------------------------------------------------------
967+
968+### `++tank`
969+
970+ ++ tank $% [%leaf p=tape] :: printing formats
971+ $: %palm ::
972+ p=[p=tape q=tape r=tape s=tape] ::
973+ q=(list tank) ::
974+ == ::
975+ $: %rose :: delimeted list
976+ p=[p=tape q=tape r=tape] :: mid open close
977+ q=(list tank) ::
978+ == ::
979+ ==
980+
981+Pretty-printing structure. A `++tank` is one of three cases. A `%leaf`
982+is just a string. A `%palm` is XX need more information. A `%rose` is a
983+list of `++tank` delimted by the strings in `p`.
984+
985+ ~zod/try=> >(bex 20) (bex 19)<
986+ [%rose p=[p=" " q="[" r="]"] q=~[[%leaf p="1.048.576"] [%leaf p="524.288"]]]
987+ ~zod/try=> (wash [0 80] >(bex 20) (bex 19)<) :: at 80 cols
988+ <<"[1.048.576 524.288]">>
989+ ~zod/try=> (wash [0 15] >(bex 20) (bex 19)<) :: at 15 cols (two lines)
990+ <<"[ 1.048.576" " 524.288" "]">>
991+
992+ ~zod/try=> [(bex 150) (bex 151)] :: at 80 cols
993+ [ 1.427.247.692.705.959.881.058.285.969.449.495.136.382.746.624
994+ 2.854.495.385.411.919.762.116.571.938.898.990.272.765.493.248
995+ ]
996+
997+------------------------------------------------------------------------
998+
999+### `++tape`
1000+
1001+ ++ tape (list char) :: like a string
1002+
1003+One of Hoon's two string types, the other being `++cord`. A tape is a
1004+list of chars.
1005+
1006+ ~zod/try=> `(list ,char)`"foobar"
1007+ "foobar"
1008+ ~zod/try=> `(list ,@)`"foobar"
1009+ ~[102 111 111 98 97 114]
1010+
1011+------------------------------------------------------------------------
1012+
1013+### `++term`
1014+
1015+ ++ term ,@tas :: Hoon ASCII subset
1016+
1017+A restricted text atom for Hoon constants. The only characters permitted
1018+are lowercase ASCII, - except as the first or last character, and 0-9
1019+except as the first character. The syntax for `@tas` is the text itself,
1020+always preceded by `%`. This means a term is always cubical. The empty
1021+`@tas` has a special syntax, `$`:
1022+
1023+ ~zod/try=> *term
1024+ %$
1025+
1026+ ~zod/try=> %dead-fish9
1027+ %dead-fish9
1028+ ~zod/try=> -:!>(%dead-fish9)
1029+ [%cube p=271.101.667.197.767.630.546.276 q=[%atom p=%tas]]
1030+
1031+------------------------------------------------------------------------
1032+
1033+### `++tiki`
1034+
1035+ ++ tiki :: test case
1036+ $% [& p=(unit term) q=wing] :: simple wing
1037+ [| p=(unit term) q=twig] :: named wing
1038+ == ::
1039+
1040+XX move to `++ut`
1041+
1042+A `++wing` or `++twig`.
1043+
1044+ ~zod/try=> (ream '=+ a=4 ?-(a @ ~)')
1045+ [ %tsls
1046+ p=[%ktts p=p=%a q=[%dtzy p=%ud q=4]]
1047+ q
1048+ [ %wthz
1049+ p=[%.y p=~ q=~[%a]]
1050+ q=~[[p=[%axil p=[%atom p=~.]] q=[%bczp p=%null]]]
1051+ ]
1052+ ]
1053+ ~zod/try=> (ream '=+ a=4 ?-(4 @ ~)')
1054+ [ %tsls
1055+ p=[%ktts p=p=%a q=[%dtzy p=%ud q=4]]
1056+ q
1057+ [ %wthz
1058+ p=[%.n p=~ q=[%dtzy p=%ud q=4]]
1059+ q=~[[p=[%axil p=[%atom p=~.]] q=[%bczp p=%null]]]
1060+ ]
1061+ ]
1062+
1063+------------------------------------------------------------------------
1064+
1065+### `++tile`
1066+
1067+See the Tile section of the Hoon Reference.
1068+
1069+------------------------------------------------------------------------
1070+
1071+### `++toga`
1072+
1073+ ++ toga :: face control
1074+ $| p=term :: two togas
1075+ $% [0 ~] :: no toga
1076+ [1 p=term q=toga] :: deep toga
1077+ [2 p=toga q=toga] :: cell toga
1078+ == ::
1079+
1080+XX move to `++ut` and rune doc (for \^= examples)
1081+
1082+A face, or tree of faces. A `++toga` is applied to anything assigned
1083+using `^=`.
1084+
1085+ ~zod/try=> a=1
1086+ a=1
1087+ ~zod/try=> (ream 'a=1')
1088+ [%ktts p=p=%a q=[%dtzy p=%ud q=1]]
1089+ ~zod/try=> [a b]=[1 2 3]
1090+ [a=1 b=[2 3]]
1091+ ~zod/try=> (ream '[a b]=[1 2 3]')
1092+ [ %ktts
1093+ p=[%2 p=p=%a q=p=%b]
1094+ q=[%cltr p=~[[%dtzy p=%ud q=1] [%dtzy p=%ud q=2] [%dtzy p=%ud q=3]]]
1095+ ]
1096+
1097+ ~zod/try=> [a ~]=[1 2 3]
1098+ [a=1 2 3]
1099+ ~zod/try=> (ream '[a ~]=[1 2 3]')
1100+ [ %ktts
1101+ p=[%2 p=p=%a q=[%0 ~]]
1102+ q=[%cltr p=~[[%dtzy p=%ud q=1] [%dtzy p=%ud q=2] [%dtzy p=%ud q=3]]]
1103+ ]
1104+
1105+------------------------------------------------------------------------
1106+
1107+### `++trap`
1108+
1109+ ++ trap ,_|.(_*) :: makes perfect sense
1110+
1111+A trap is a core with one arm `++$`.
1112+
1113+See also: `|.`
1114+
1115+ ~zod/try=> *trap
1116+ <1.mws 101.jzo 1.ypj %164>
1117+ ~zod/try=> (*trap)
1118+ 0
1119+ ~zod/try=> (|.(42))
1120+ 42
1121+
1122+------------------------------------------------------------------------
1123+
1124+### `++trel`
1125+
1126+ ++ trel |* [a=$+(* *) b=$+(* *) c=$+(* *)] :: just a triple
1127+ ,[p=a q=b r=c] ::
1128+
1129+Tile generator. `++trel` is a tuple of three of the types passed in.
1130+
1131+ ~zod/try=> *(trel ,@ud ,@t ,@s)
1132+ [p=0 q='' r=--0]
1133+
1134+------------------------------------------------------------------------
1135+
1136+### `++tuna`
1137+
1138+ ++ tuna :: tagflow
1139+ $% [%a p=twig] :: plain text
1140+ [%b p=twig] :: single tag
1141+ [%c p=twig] :: simple list
1142+ [%d p=twig] :: dynamic list
1143+ [%e p=twig q=(list tuna)] :: element
1144+ [%f p=(list tuna)] :: subflow
1145+ == ::
1146+
1147+An XML template tree.
1148+
1149+Leaf %a contains plain-text, %b an empty tag, %c a static list, %d a
1150+dynamic list, %e a full node element containing a twig and a list of
1151+tuna, and %f is a empty node.
1152+
1153+See also: `++sail`
1154+
1155+------------------------------------------------------------------------
1156+
1157+### `++twig`
1158+
1159+See Twig section of Hoon reference
1160+
1161+------------------------------------------------------------------------
1162+
1163+### `++tine`
1164+
1165+ ++ tine (list ,[p=tile q=twig]) ::
1166+
1167+Switch statement cases. In `?-`, for example, your list of cases is a
1168+`++tine`.
1169+
1170+See also: `++twig`
1171+
1172+ ~zod/try=> (ream '?-(!! @ |, ^ &)')
1173+ [ %wthz
1174+ p=[%.n p=~ q=[%zpzp ~]]
1175+ q
1176+ ~[
1177+ [p=[%axil p=[%atom p=~.]] q=[%dtzy p=%f q=1]]
1178+ [p=[%axil p=%cell] q=[%dtzy p=%f q=0]]
1179+ ]
1180+ ]
1181+ ~zod/try=> (tine |2:(ream '?-(!! @ |, ^ &)'))
1182+ ~[
1183+ [p=[%axil p=[%atom p=~.]] q=[%dtzy p=%f q=1]]
1184+ [p=[%axil p=%cell] q=[%dtzy p=%f q=0]]
1185+ ]
1186+
1187+------------------------------------------------------------------------
1188+
1189+### `++tusk`
1190+
1191+ ++ tusk (list twig) ::
1192+
1193+Variable-arity expression list. In `:*`, for example, your contents are
1194+a `++tusk`.
1195+
1196+See also: `++twig`
1197+
1198+ ~zod/try=> (ream '[1 2 3]')
1199+ [%cltr p=~[[%dtzy p=%ud q=1] [%dtzy p=%ud q=2] [%dtzy p=%ud q=3]]]
1200+ ~zod/try=> (tusk +:(ream '[1 2 3]'))
1201+ ~[[%dtzy p=%ud q=1] [%dtzy p=%ud q=2] [%dtzy p=%ud q=3]]
1202+
1203+------------------------------------------------------------------------
1204+
1205+### `++tyre`
1206+
1207+ ++ tyre (list ,[p=term q=twig]) ::
1208+
1209+Associative list of term to twig, used in jet hint processing.
1210+
1211+See also: `++twig`
1212+
1213+------------------------------------------------------------------------
1214+
1215+### `++tyke`
1216+
1217+ ++ tyke (list (unit twig)) ::
1218+
1219+List of twigs, or gaps left to be inferred, in path parsing. When you
1220+use a path such as `/=main=/pub/src/doc` the path is in fact a `++tyke`,
1221+where the `=` are inferred from your current path.
1222+
1223+ ~zod/try=> (scan "/==as=" porc:vast)
1224+ [0 ~[~ ~ [~ [%dtzy p=%tas q=29.537]] ~]]
1225+ ~zod/try=> `tyke`+:(scan "/==as=" porc:vast)
1226+ ~[~ ~ [~ [%dtzy p=%tas q=29.537]] ~]
1227+
1228+------------------------------------------------------------------------
1229+
1230+### `++tram`
1231+
1232+ ++ tram (list ,[p=wing q=twig]) ::
1233+
1234+List of changes by location in context. When using `%=`, for example,
1235+the list of changes is a `++tram`.
1236+
1237+See also: `++twig`
1238+
1239+ ~zod/try=> (ream '$(a 1, b 2)')
1240+ [ %cnts
1241+ p=~[%$]
1242+ q=~[[p=~[%a] q=[%dtzy p=%ud q=1]] [p=~[%b] q=[%dtzy p=%ud q=2]]]
1243+ ]
1244+ ~zod/try=> (tram +:(ream '$(a 1, b 2)'))
1245+ ~[[p=~ q=[% p=0]] [p=~[%a] q=[%dtzy p=%ud q=1]] [p=~[%b] q=[%dtzy p=%ud q=2]]]
1246+
1247+------------------------------------------------------------------------
1248+
1249+### `++nock`
1250+
1251+ ++ nock $& [p=nock q=nock] :: autocons
1252+ $% [%0 p=@] :: axis select
1253+ [%1 p=*] :: constant
1254+ [%2 p=nock q=nock] :: compose
1255+ [%3 p=nock] :: cell test
1256+ [%4 p=nock] :: increment
1257+ [%5 p=nock q=nock] :: equality test
1258+ [%6 p=nock q=nock r=nock] :: if, then, else
1259+ [%7 p=nock q=nock] :: serial compose
1260+ [%8 p=nock q=nock] :: push onto subject
1261+ [%9 p=@ q=nock] :: select arm and fire
1262+ [%10 p=?(@ [p=@ q=nock]) q=nock] :: hint
1263+ [%11 p=nock] :: grab data from sky
1264+ == ::
1265+
1266+See Nock doc
1267+
1268+ ~zod/try=> !=([+(.) 20 -<])
1269+ [[4 0 1] [1 20] 0 4]
1270+ ~zod/try=> (nock !=([+(.) 20]))
1271+ [p=[%4 p=[%0 p=1]] q=[%1 p=20]]
1272+
1273+------------------------------------------------------------------------
1274+
1275+### `++tone`
1276+
1277+ ++ tone $% [%0 p=*] :: success
1278+ [%1 p=(list)] :: blocks
1279+ [%2 p=(list ,[@ta *])] :: error ~_s
1280+ == ::
1281+
1282+Intermediate Nock computation result. Similar to `++toon`, but stack
1283+trace is not yet rendered.
1284+
1285+ ~zod/try=> (mink [[20 21] 0 3] ,~)
1286+ [%0 p=21]
1287+
1288+ ~zod/try=> (mink [[0] !=(.^(cy//=main/1))] ,~)
1289+ [%1 p=~[[31.075 1.685.027.454 1.852.399.981 49 0]]]
1290+ ~zod/try=> (path [31.075 1.685.027.454 1.852.399.981 49 0])
1291+ /cy/~zod/main/1
1292+
1293+ ~zod/try=> (mink [[1 2] !=(~|(%hi +(.)))] ,~)
1294+ [%2 p=~[[~.yelp 26.984]]]
1295+ ~zod/try=> (mink [[1 2] !=(!:(+(.)))] ,~)
1296+ [ %2
1297+ p
1298+ ~[
1299+ [ ~.spot
1300+ [ [ 1.685.027.454
1301+ 7.959.156
1302+ \/159.445.990.350.374.058.574.398.238.344.143.957.205.628.479.572.65\/
1303+ 8.112.403.878.526
1304+ \/ \/
1305+ 0
1306+ ]
1307+ [1 20]
1308+ 1
1309+ 24
1310+ ]
1311+ ]
1312+ ]
1313+ ]
1314+
1315+------------------------------------------------------------------------
1316+
1317+### `++toon`
1318+
1319+ ++ toon $% [%0 p=*] :: success
1320+ [%1 p=(list)] :: blocks
1321+ [%2 p=(list tank)] :: stack trace
1322+ == ::
1323+
1324+Nock computation result. Either success (`%0`), a block with list of
1325+requests blocked on (`%1`), or failure with stack trace (`%2`).
1326+
1327+ ~zod/try=> (mock [[20 21] 0 3] ,~)
1328+ [%0 p=21]
1329+
1330+ ~zod/try=> (mock [[0] !=(.^(cy//=main/1))] ,~)
1331+ [%1 p=~[[31.075 1.685.027.454 1.852.399.981 49 0]]]
1332+ ~zod/try=> (path [31.075 1.685.027.454 1.852.399.981 49 0])
1333+ /cy/~zod/main/1
1334+
1335+ ~zod/try=> (mock [[1 2] !=(!:(+(.)))] ,~)
1336+ [%2 p=~[[%leaf p="/~zod/try/~2014.9.23..18.34.32..d3c5/:<[1 20].[1 24]>"]]]
1337+
1338+------------------------------------------------------------------------
1339+
1340+### `++tune`
1341+
1342+ ++ tune $% [%0 p=vase] ::
1343+ [%1 p=(list)] ::
1344+ [%2 p=(list ,[@ta *])] ::
1345+ == ::
1346+
1347+XX Unused
1348+
1349+Probably typed `tone`?
1350+
1351+------------------------------------------------------------------------
1352+
1353+### `++twin`
1354+
1355+ ++ twin ,[p=term q=wing r=axis s=type] :: alias info
1356+
1357+Aliasing. Used in `%bull` `++type` to typecheck aliased faces.
1358+
1359+ ~zod/try=> (~(busk ut %cell %noun [%atom %ud]) %fal [%& 3]~)
1360+ [ %bull
1361+ p=[p=%fal q=~[[%.y p=3]] r=3 s=[%atom p=%ud]]
1362+ q=[%cell p=%noun q=[%atom p=%ud]]
1363+ ]
1364+ ~zod/try=> &2:(~(busk ut %cell %noun [%atom %ud]) %fal [%& 3]~)
1365+ p=[p=%fal q=~[[%.y p=3]] r=3 s=[%atom p=%ud]]
1366+ ~zod/try=> (twin &2:(~(busk ut %cell %noun [%atom %ud]) %fal [%& 3]~))
1367+ [p=%fal q=~[[%.y p=3]] r=3 s=[%atom p=%ud]]
1368+
1369+------------------------------------------------------------------------
1370+
1371+### `++type`
1372+
1373+See Type section of Hoon reference
1374+
1375+------------------------------------------------------------------------
1376+
1377+### `++typo`
1378+
1379+ ++ typo type :: old type
1380+
1381+Pointer for `++type`. `++typo` preserves the previous `++type` in your
1382+context when upating.
1383+
1384+See also: `++seem`, `++vise`, `++type`
1385+
1386+------------------------------------------------------------------------
1387+
1388+### `++udal`
1389+
1390+ ++ udal :: atomic change (%b)
1391+ $: p=@ud :: blockwidth
1392+ q=(list ,[p=@ud q=(unit ,[p=@ q=@])]) :: indels
1393+ == ::
1394+
1395+XX Unused
1396+
1397+------------------------------------------------------------------------
1398+
1399+### `++udon`
1400+
1401+ ++ udon :: abstract delta
1402+ $: p=umph :: preprocessor
1403+ $= q :: patch
1404+ $% [%a p=* q=*] :: trivial replace
1405+ [%b p=udal] :: atomic indel
1406+ [%c p=(urge)] :: list indel
1407+ [%d p=upas q=upas] :: tree edit
1408+ == ::
1409+ == ::
1410+
1411+See `%clay` doc
1412+
1413+------------------------------------------------------------------------
1414+
1415+### `++umph`
1416+
1417+ ++ umph :: change filter
1418+ $| $? %a :: no filter
1419+ %b :: jamfile
1420+ %c :: LF text
1421+ == ::
1422+ $% [%d p=@ud] :: blocklist
1423+ == ::
1424+
1425+See `%clay` doc
1426+
1427+------------------------------------------------------------------------
1428+
1429+### `++unce`
1430+
1431+ ++ unce |* a=_,* :: change part
1432+ $% [%& p=@ud] :: skip[copy]
1433+ [%| p=(list a) q=(list a)] :: p -> q[chunk]
1434+ == ::
1435+
1436+See `%clay` doc
1437+
1438+------------------------------------------------------------------------
1439+
1440+### `++unit`
1441+
1442+ ++ unit |* a=_,* :: maybe
1443+ $|(~ [~ u=a]) ::
1444+
1445+Tile generator. A `++unit` is either `~` or `[~ u=a]` where `a` is the
1446+type that was passed in.
1447+
1448+See also: `++bind`, Section 2bA
1449+
1450+ ~zod/try=> :type; *(unit time)
1451+ ~
1452+ u(@da)
1453+ ~zod/try=> `(unit time)`[~ -<-]
1454+ [~ ~2014.9.24..19.25.10..7dd5]
1455+
1456+------------------------------------------------------------------------
1457+
1458+### `++upas`
1459+
1460+ ++ upas :: tree change (%d)
1461+ $& [p=upas q=upas] :: cell
1462+ $% [%0 p=axis] :: copy old
1463+ [%1 p=*] :: insert new
1464+ [%2 p=axis q=udon] :: mutate!
1465+ == ::
1466+
1467+See `%clay` doc
1468+
1469+------------------------------------------------------------------------
1470+
1471+### `++urge`
1472+
1473+ ++ urge |*(a=_,* (list (unce a))) :: list change
1474+
1475+See `%clay` doc
1476+
1477+------------------------------------------------------------------------
1478+
1479+### `++vase`
1480+
1481+ ++ vase ,[p=type q=*] :: type-value pair
1482+
1483+Typed data. A `++vase` is used wherever typed data is explicitly worked
1484+with.
1485+
1486+See `%arvo` doc
1487+
1488+ ~zod/try=> `vase`!>(~)
1489+ [p=[%cube p=0 q=[%atom p=%n]] q=0]
1490+
1491+------------------------------------------------------------------------
1492+
1493+### `++vise`
1494+
1495+ ++ vise ,[p=typo q=*] :: old vase
1496+
1497+Used to convert from previously-typed data during reboot.
1498+
1499+See `++typo`, `++seer`
1500+
1501+------------------------------------------------------------------------
1502+
1503+### `++wall`
1504+
1505+ ++ wall (list tape) :: text lines (no \n)
1506+
1507+A list of lines. A `++wall` is used instead of a single `++tape` with
1508+`\n`.
1509+
1510+See also: `++wash`
1511+
1512+ ~zod/try=> `wall`(wash [0 20] leaf/<(bex 256)>)
1513+ <<
1514+ "\/115.792.089.237.\/"
1515+ " 316.195.423.570."
1516+ " 985.008.687.907."
1517+ " 853.269.984.665."
1518+ " 640.564.039.457."
1519+ " 584.007.913.129."
1520+ " 639.936"
1521+ "\/ \/"
1522+ >>
1523+
1524+------------------------------------------------------------------------
1525+
1526+### `++wain`
1527+
1528+ ++ wain (list cord) :: text lines (no \n)
1529+
1530+A list of lines. A `++wain` is used instead of a single `++cord` with
1531+`\n`.
1532+
1533+See also: `++lore`, `++role`
1534+
1535+ ~zod/try=> `wain`/som/del/rok
1536+ <|som del rok|>
1537+ ~zod/try=> `wain`(lore ^:@t/=main=/bin/tree/hoon)
1538+ <|
1539+ !:
1540+ :: /===/bin/tree/hoon
1541+ |= ^
1542+ |= [pax=path fla=$|(~ [%full ~])]
1543+ =- ~[te/-]~
1544+ =+ len=(lent pax)
1545+ =+ rend=?~(fla |=(a=path +:(spud (slag len a))) spud)
1546+ |- ^- wain
1547+ =+ ark=;;(arch .^(cy/pax))
1548+ =- ?~ q.ark -
1549+ [(crip (rend pax)) -]
1550+ %- zing
1551+ %- turn :_ |=(a=@t ^$(pax (weld pax `path`/[a])))
1552+ %- sort :_ aor
1553+ %- turn :_ |=([a=@t ~] a)
1554+ (~(tap by r.ark))
1555+ |>
1556+
1557+------------------------------------------------------------------------
1558+
1559+### `++wing`
1560+
1561+ ++ wing (list limb) ::
1562+
1563+Address in subject. A `++wing` is a path to a value in the subject. A
1564+term alone is the trivial case of a `++wing`.
1565+
1566+See also: `++twig`
1567+
1568+ ~zod/try=> (ream 'a.+.c')
1569+ [%cnzz p=~[%a [%.y p=3] %c]]
1570+ ~zod/try=> (wing +:(ream 'a.+.c'))
1571+ ~[%a [%.y p=3] %c]
1572+
1573+------------------------------------------------------------------------
1574+
1575+### `++wine`
1576+
1577+ ++ wine $| ?(%noun %path %tank %void %wall %wool %yarn)
1578+ $% [%atom p=term] ::
1579+ [%core p=(list ,@ta) q=wine] ::
1580+ [%face p=term q=wine] ::
1581+ [%list p=term q=wine] ::
1582+ [%pear p=term q=@] ::
1583+ [%pick p=(list wine)] ::
1584+ [%plot p=(list wine)] ::
1585+ [%stop p=@ud] ::
1586+ [%tree p=term q=wine] ::
1587+ [%unit p=term q=wine] ::
1588+ == ::
1589+
1590+Printable type. `++wine` is used for pretty printing.
1591+
1592+See also: `++calf`
1593+
1594+ ~zod/try=> ~(dole ut p:!>(*@tas))
1595+ [p={} q=[%atom p=%tas]]
1596+ ~zod/try=> `wine`q:~(dole ut p:!>(*@tas))
1597+ [%atom p=%tas]
1598+
1599+ ~zod/try=> ~(dole ut p:!>(*path))
1600+ [ p
1601+ { [ p=1
1602+ q
1603+ [ %pick
1604+ p
1605+ ~[
1606+ [%pear p=%n q=0]
1607+ [%plot p=~[[%face p=%i q=[%atom p=%ta]] [%face p=%t q=[%stop p=1]]]]
1608+ ]
1609+ ]
1610+ ]
1611+ }
1612+ q=%path
1613+ ]
1614+ ~zod/try=> `wine`q:~(dole ut p:!>(*path))
1615+ %path
1616+
1617+ ~zod/try=> ~(dole ut p:!>(*(map time cord)))
1618+ [ p
1619+ { [ p=1
1620+ q
1621+ [ %pick
1622+ p
1623+ ~[
1624+ [%pear p=%n q=0]
1625+ [ %plot
1626+ p
1627+ ~[
1628+ [ %face
1629+ p=%n
1630+ q
1631+ [ %plot
1632+ p=~[[%face p=%p q=[%atom p=%da]] [%face p=%q q=[%atom p=%t]]]
1633+ ]
1634+ ]
1635+ [%face p=%l q=[%stop p=1]]
1636+ [%face p=%r q=[%stop p=1]]
1637+ ]
1638+ ]
1639+ ]
1640+ ]
1641+ ]
1642+ }
1643+ q
1644+ [ %tree
1645+ p=%nlr
1646+ q=[%plot p=~[[%face p=%p q=[%atom p=%da]] [%face p=%q q=[%atom p=%t]]]]
1647+ ]
1648+ ]
1649+ ~zod/try=> `wine`q:~(dole ut p:!>(*(map time cord)))
1650+ [ %tree
1651+ p=%nlr
1652+ q=[%plot p=~[[%face p=%p q=[%atom p=%da]] [%face p=%q q=[%atom p=%t]]]]
1653+ ]
1654+
1655+------------------------------------------------------------------------
1656+
1657+### `++wonk`
1658+
1659+ ++ wonk |*(veq=edge ?~(q.veq !! p.u.q.veq)) ::
1660+ :: ::
1661+ :: ::
1662+
1663+XX Not a model?
1664+
1665+ ++ wonk |*(veq=edge ?~(q.veq !! p.u.q.veq)) ::
1666+
1667+Pull result out of a `++edge`, or crash if there's no result.
1668+
1669+See also: `++edge`, Section 2eC
1670+
1671+ ~zod/try=> (wide:vast [1 1] "(add 2 2)")
1672+ [ p=[p=1 q=10]
1673+ q
1674+ [ ~
1675+ [ p=[%cnhp p=[%cnzz p=~[%add]] q=~[[%dtzy p=%ud q=2] [%dtzy p=%ud q=2]]]
1676+ q=[p=[p=1 q=10] q=""]
1677+ ]
1678+ ]
1679+ ]
1680+ ~zod/try=> (wonk (wide:vast [1 1] "(add 2 2)"))
1681+ [%cnhp p=[%cnzz p=~[%add]] q=~[[%dtzy p=%ud q=2] [%dtzy p=%ud q=2]]]
1682+
1683+------------------------------------------------------------------------
1684+
1685+### `++map`
1686+
1687+ ++ map |* [a=_,* b=_,*] :: associative tree
1688+ $|(~ [n=[p=a q=b] l=(map a b) r=(map a b)]) ::
1689+
1690+Tile generator. A `++map` is a
1691+[treap](http://en.wikipedia.org/wiki/Treap) of key, value pairs.
1692+
1693+See also: `++by`
1694+
1695+ ~zod/try=> :type; *(map ,@t ,@u)
1696+ {}
1697+ nlr([p=@t q=@u])
1698+ ~zod/try=> `(map ,@ta ,@ud)`(mo (limo a/1 b/2 ~))
1699+ {[p=~.a q=1] [p=~.b q=2]}
1700+
1701+------------------------------------------------------------------------
1702+
1703+### `++qeu`
1704+
1705+ ++ qeu |* a=_,* :: queue
1706+ $|(~ [n=a l=(qeu a) r=(qeu a)]) ::
1707+
1708+Tile generator. A `++qeu` is an ordered
1709+[treap](http://en.wikipedia.org/wiki/Treap) of items.
1710+
1711+See also: `++to`
1712+
1713+ ~zod/try=> (qeu time)
1714+ <1.qyo [* <1.sxx [a=<1.ebd [* <101.jzo 1.ypj %164>]> <101.jzo 1.ypj %164>]>]>
1715+ ~zod/try=> (~(gas to *(qeu time)) [~2014.1.1 ~2014.1.2 ~])
1716+ {~2014.1.2 ~2014.1.1}
1717+
1718+------------------------------------------------------------------------
1719+
1720+### `++set`
1721+
1722+ ++ set |* a=_,* :: set
1723+ $|(~ [n=a l=(set a) r=(set a)]) ::
1724+
1725+Tile generator. A `++set` is a
1726+[treap](http://en.wikipedia.org/wiki/Treap) with unique values.
1727+
1728+See also: `++in`
1729+
1730+ ~zod/try=> (sa "abc")
1731+ {~~a ~~c ~~b}
1732+ ~zod/try=> (~(put in (sa "abc")) %d)
1733+ {~~d ~~a ~~c ~~b}
1734+ ~zod/try=> (~(put in (sa "abc")) %a)
1735+ {~~a ~~c ~~b}
1736+
1737+------------------------------------------------------------------------
1738+
1739+### `++jar`
1740+
1741+ ++ jar |*([a=_,* b=_,*] (map a (list b))) :: map of lists
1742+
1743+Tile generator. A `++jar` is a `++map` of `++list`.
1744+
1745+See also: `++ja`, `++by`, `++map`, `++list`
1746+
1747+ ~zod/try=> =a (limo [1 2 ~])
1748+ ~zod/try=> a
1749+ [i=1 t=[i=2 t=~]]
1750+ ~zod/try=> =b (limo [3 4 ~])
1751+ ~zod/try=> b
1752+ [i=3 t=[i=4 t=~]]
1753+ ~zod/try=> =c (mo (limo [[%a a] [%b b] ~]))
1754+ ~zod/try=> c
1755+ {[p=%a q=[i=1 t=[i=2 t=~]]] [p=%b q=[i=3 t=[i=4 t=~]]]}
1756+ ~zod/try=> (~(get ja c) %a)
1757+ [i=1 t=[i=2 t=~]]
1758+ ~zod/try=> (~(get ja c) %c)
1759+ ~
1760+
1761+------------------------------------------------------------------------
1762+
1763+### `++jug`
1764+
1765+ ++ jug |*([a=_,* b=_,*] (map a (set b))) :: map of sets
1766+
1767+Tile generator. Similar to `++jar`, but with `++set`. A `++jug` is a
1768+`++map` of `++set`.
1769+
1770+See also: `++ju`, `++by`, `++map`, `++set`
1771+
1772+ ~zod/try=> =a (sa (limo [1 2 ~]))
1773+ ~zod/try=> a
1774+ {1 2}
1775+ ~zod/try=> =b (sa (limo [3 4 ~]))
1776+ ~zod/try=> b
1777+ {4 3}
1778+ ~zod/try=> =c (mo (limo [[%a a] [%b b] ~]))
1779+ ~zod/try=> c
1780+ {[p=%a q={1 2}] [p=%b q={4 3}]}
1781+ ~zod/try=> (~(get ju c) %b)
1782+ {4 3}
1783+ ~zod/try=> (~(put ju c) [%b 5])
1784+ {[p=%a q={1 2}] [p=%b q={5 4 3}]}
1785+
1786+------------------------------------------------------------------------