git.iko.soy/urbit.org
on 4fdc19d help sign in
urbit.org/content/docs/hoon/reference/stdlib/4o.md
1473 lines 31 kB history raw
1+++
2title = "4o: Molds"
3weight = 42
4template = "doc.html"
5+++
7## `+$abel`
9Original sin: type
11Old type, same as the new `type`.
13#### Source
15```hoon
16+$ abel typo
17```
19#### Examples
21```
22> *abel
23#t/*
24```
26---
28## `+$alas`
30Alias list
32This is the type used in `%brcb` (`|_` door) `hoon` type for `+*` alias arms.
34#### Source
36```hoon
37+$ alas (list (pair term hoon))
38```
40---
42## `+$atom`
44Just an atom
46This is the same as `@`.
48#### Source
50```hoon
51+$ atom @
52```
54#### Examples
56```
57> *atom
60> `atom`'foo'
617.303.014
62```
64---
66## `+$aura`
68'type' of atom
70By convention, a short name for a category of atom. `aura` is circularly
71defined, with `@ta` being the `aura` of the ASCII subset commonly used in urbit.
73#### Source
75```hoon
76+$ aura @ta
77```
79#### Examples
81See also: [`+$base`](#base), aura reference
83```
84> `aura`'ux'
85~.ux
86```
88---
90## `+$base`
92Base type
94A base type that nouns are built from. A `base` is either a noun, atom with
95aura, cell, boolean, null, or an empty set.
97#### Source
99```hoon
100+$ base :: base mold
101 $@ $? %noun :: any noun
102 %cell :: any cell
103 %flag :: loobean
104 %null :: ~ == 0
105 %void :: empty set
106 == ::
107 [%atom p=aura] :: atom
108```
110#### Examples
112```
113> *base
114%void
116> (ream '=|(^ !!)')
117[%tsbr p=[%base p=%cell] q=[%zpzp ~]]
118```
120---
122## `+$woof`
124Simple embed
126An atom or some `hoon`.
128#### Source
130```hoon
131+$ woof $@(@ [~ p=hoon])
132```
134#### Examples
136```
137> *woof
140> `woof`[~ %base p=%cell]
141[~ p=[%base p=%cell]]
143> `woof`'foo'
1447.303.014
145```
147---
149## `+$chum`
151Jet hint information
153Jet hint information that must be present in the body of a `~/` or `~%` rune. A
154`chum` can optionally contain a kelvin version, jet vendor, and version number.
156#### Source
158```hoon
159+$ chum $? lef=term :: jet name
160 [std=term kel=@] :: kelvin version
161 [ven=term pro=term kel=@] :: vendor and product
162 [ven=term pro=term ver=@ kel=@] :: all of the above
163 == ::
164```
166#### Examples
168```
169> `chum`'hi'
170lef=%hi
172> (ream '~/(%lob.314 !!)')
173[%sgfs p=[std=%lob kel=314] q=[%zpzp ~]]
174```
176---
178## `+$coil`
180Tuple of core information
182Variance `p`, subject type `q`, and `r`: optional compiled nock, and arms. Used
183as an intermediate step during compilation and converted to a core.
185#### Source
187```hoon
188+$ coil $: p=garb :: name, wet=dry, vary
189 q=type :: context
190 r=(pair seminoun (map term tome)) :: chapters
191 == ::
192```
194---
196## `+$garb`
198Core metadata
200A triple of an optional name, polarity (wet/dry), and variance (`%iron`, etc).
202#### Source
204```hoon
205+$ garb (trel (unit term) poly vair)
206```
208---
210## `+$poly`
212Polarity
214Whether a core is wet or dry.
216#### Source
218```hoon
219+$ poly ?(%wet %dry)
220```
222---
224## `+$foot`
226Cases of arms by variance model.
228#### Source
230```hoon
231+$ foot $% [%dry p=hoon] :: dry arm, geometric
232 [%wet p=hoon] :: wet arm, generic
233 ==
234```
236---
238## `+$link`
240Lexical segment
242Used for documentation.
244#### Source
246```hoon
247+$ link :: lexical segment
248 $% [%chat p=term] :: |chapter
249 [%cone p=aura q=atom] :: %constant
250 [%frag p=term] :: .leg
251 [%funk p=term] :: +arm
252 ==
253```
255---
257## `+$crib`
259Summary and details
261Summary and details for documentation.
263#### Source
265```hoon
266+$ crib [summary=cord details=(list sect)]
267```
269---
271## `+$help`
273Documentation
275#### Source
277```hoon
278+$ help [links=(list link) =crib]
279```
281---
283## `+$limb`
285Wing element
287Reference into subject by tree address or name.
289#### Source
291```hoon
292+$ limb $@ term :: wing element
293 $% [%& p=axis] :: by geometry
294 [%| p=@ud q=(unit term)] :: by name
295 == ::
296```
298#### Examples
300```
301> (ream '^^$')
302[%wing p=~[[%.n p=2 q=[~ %$]]]]
303```
305---
307## `+$null`
309Null, nil, etc
311Just `~`.
313#### Source
315```hoon
316+$ null ~
317```
319#### Examples
321```
322> *null
324```
326---
328## `+$onyx`
330Arm activation
332#### Source
334```hoon
335+$ onyx (list (pair type foot))
336```
338---
340## `+$opal`
342Wing match
344Arm or leg of a wing.
346#### Source
348```hoon
349+$ opal :: limb match
350 $% [%& p=type] :: leg
351 [%| p=axis q=(set [p=type q=foot])] :: arm
352 == ::
353```
355---
357## `+$pica`
359Prose or code
361A `(pair ? cord)`. If `%.y` it's prose and if `%.n` it's code. Used in
362documentation.
364#### Source
366```hoon
367+$ pica (pair ? cord)
368```
370---
372## `+$palo`
374Wing trace, match
376A [`$vein`](#vein) and a [`$opal`](#opal).
378#### Source
380```hoon
381+$ palo (pair vein opal)
382```
384---
386## `+$plat`
388%hoon, %type, %nock or %tank
390#### Source
392```hoon
393+$ plat
394 $? %hoon
395 %type
396 %nock
397 %tank
398 ==
399```
401---
403## `+$pock`
405Changes
407#### Source
409```hoon
410+$ pock (pair axis nock)
411```
413---
415## `+$port`
417Successful wing match
419#### Source
421```hoon
422+$ port (each palo (pair type nock))
423```
425---
427## `+$spec`
429Structure definition AST.
431#### Source
433```hoon
434+$ spec :: structure definition
435 $~ [%base %null] ::
436 $% [%base p=base] :: base type
437 [%dbug p=spot q=spec] :: set debug
438 [%leaf p=term q=@] :: constant atom
439 [%like p=wing q=(list wing)] :: reference
440 [%loop p=term] :: hygienic reference
441 [%made p=(pair term (list term)) q=spec] :: annotate synthetic
442 [%make p=hoon q=(list spec)] :: composed spec
443 [%name p=term q=spec] :: annotate simple
444 [%over p=wing q=spec] :: relative to subject
445 :: ::
446 [%bcgr p=spec q=spec] :: $>, filter: require
447 [%bcbc p=spec q=(map term spec)] :: $$, recursion
448 [%bcbr p=spec q=hoon] :: $|, verify
449 [%bccb p=hoon] :: $_, example
450 [%bccl p=[i=spec t=(list spec)]] :: $:, tuple
451 [%bccn p=[i=spec t=(list spec)]] :: $%, head pick
452 [%bcdt p=spec q=(map term spec)] :: $., read-write core
453 [%bcgl p=spec q=spec] :: $<, filter: exclude
454 [%bchp p=spec q=spec] :: $-, function core
455 [%bckt p=spec q=spec] :: $^, cons pick
456 [%bcls p=stud q=spec] :: $+, standard
457 [%bcfs p=spec q=(map term spec)] :: $/, write-only core
458 [%bcmc p=hoon] :: $;, manual
459 [%bcpm p=spec q=hoon] :: $&, repair
460 [%bcsg p=hoon q=spec] :: $~, default
461 [%bctc p=spec q=(map term spec)] :: $`, read-only core
462 [%bcts p=skin q=spec] :: $=, name
463 [%bcpt p=spec q=spec] :: $@, atom pick
464 [%bcwt p=[i=spec t=(list spec)]] :: $?, full pick
465 [%bczp p=spec q=(map term spec)] :: $!, opaque core
466 == ::
467```
469#### Examples
471```
472> *spec
473[%base p=%null]
475> `spec`[%bccl ~[leaf+ud+1 leaf+ud+2]]
476[%bccl p=[i=[%leaf p=%ud q=1] t=~[[%leaf p=%ud q=2]]]]
477```
479---
481## `+$tent`
483Model builder
485#### Source
487```hoon
488+$ tent
489 $% [%| p=wing q=tent r=(list spec)] :: ~(p q r...)
490 [%& p=(list wing)] :: a.b:c.d
491 == ::
492```
494---
496## `+$tiki`
498Test case
500This is used when compiling `?-` expressions and similar.
502#### Source
504```hoon
505+$ tiki :: test case
506 $% [%& p=(unit term) q=wing] :: simple wing
507 [%| p=(unit term) q=hoon] :: named wing
508 == ::
509```
511---
513## `+$skin`
515Texture
517This type is used for faces and similar by the compiler.
519#### Source
521```hoon
522+$ skin :: texture
523 $@ =term :: name/~[term %none]
524 $% [%base =base] :: base match
525 [%cell =skin =skin] :: pair
526 [%dbug =spot =skin] :: trace
527 [%leaf =aura =atom] :: atomic constant
528 [%help =help =skin] :: describe
529 [%name =term =skin] :: apply label
530 [%over =wing =skin] :: relative to
531 [%spec =spec =skin] :: cast to
532 [%wash depth=@ud] :: strip faces
533 == ::
534```
536---
538## `+$tome`
540Core chapter
542This type is used by the compiler for the contents of arms in cores.
544#### Source
546```hoon
547+$ tome (pair what (map term hoon))
548```
550---
552## `+$tope`
554Topographic type
556Describes the structure of a noun.
558#### Source
560```hoon
561+$ tope :: topographic type
562 $@ $? %& :: cell or atom
563 %| :: atom
564 == ::
565 (pair tope tope) :: cell
566```
568#### Examples
570```
571> *tope
572%.n
574> `tope`[%| %&]
575[p=%.n q=%.y]
576```
578---
580## `++hoot`
582Hoon tools
584Container core for internally-used XML structure types. XML structure types
585you'd typically use directly are defined in [Standard Library section
5865e](/docs/hoon/reference/stdlib/5e).
588#### Source
590```hoon
591++ hoot
592 |%
593```
595---
597### `+$beer:hoot`
599Simple embed
601Either a tape element or interpolated hoon expression in an XML attribute.
603#### Source
605```hoon
606+$ beer $@(char [~ p=hoon])
607```
609---
611### `+$mane:hoot`
613XML name+space
615XML tag name and optional namespace.
617#### Source
619```hoon
620+$ mane $@(@tas [@tas @tas])
621```
623#### Examples
625```
626> (en-xml:html ;foo;)
627"<foo></foo>"
629> (en-xml:html ;foo_bar;)
630"<foo:bar></foo:bar>"
632> `manx:hoot`;foo_bar;
633[g=[n=[%foo %bar] a=~] c=~]
635> `mane:hoot`n.g:`manx`;foo_bar;
636[%foo %bar]
638> `mane:hoot`n.g:`manx:hoot`;foo;
639%foo
640```
642---
644### `+$manx:hoot`
646Dynamic XML node
648An XML element which may contain text, attributes, and other elements.
650`g` is a [`$marx:hoot`](#marxhoot) (a tag) and `c` is a
651[`$marl:hoot`](#marlhoot) (its contents).
653#### Source
655```hoon
656+$ manx $~([[%$ ~] ~] [g=marx c=marl])
657```
659#### Examples
661```
662> *manx:hoot
663[g=[n=%$ a=~] c=~
665> `manx:hoot`;foo;
666[g=[n=%foo a=~] c=~]
668> (en-xml:html `manx:hoot`;foo;)
669"<foo></foo>"
671> =a ^- manx:hoot
672 ;foo
673 ;bar: abc
674 ;baz
675 ;xxx: hello
676 ==
677 ==
679> a
680[ g=[n=%foo a=~]
681 c
682 ~[
683 [ g=[n=%bar a=~]
684 c=~[[g=[n=%$ a=~[[n=%$ v="abc"]]] c=~]]
685 ]
686 [ g=[n=%baz a=~]
687 c
688 ~[
689 [ g=[n=%xxx a=~]
690 c=~[[g=[n=%$ a=~[[n=%$ v="hello"]]] c=~]]
691 ]
692 ]
693 ]
694 ]
697> (en-xml:html a)
698"<foo><bar>abc</bar><baz><xxx>hello</xxx></baz></foo>"
699```
701---
703### `+$marl:hoot`
705Dynamic XML nodes
707A list of XML nodes - maybe with interpolation and recursion. See
708[`$tuna:hoot`](#tunahoot).
710#### Source
712```hoon
713+$ marl (list tuna)
714```
716#### Examples
718```
719> *marl
722> ^- marl:hoot
723 ;=
724 ;foo: abc
725 ;bar: def
726 ==
727~[
728 [g=[n=%foo a=~] c=~[[g=[n=%$ a=~[[n=%$ v=~['a' 'b' 'c']]]] c=~]]]
729 [g=[n=%bar a=~] c=~[[g=[n=%$ a=~[[n=%$ v=~['d' 'e' 'f']]]] c=~]]]
732> %- en-xml:html
733 ;baz
734 ;=
735 ;foo: abc
736 ;bar: def
737 ==
738 ==
739"<baz><foo>abc</foo><bar>def</bar></baz>"
740```
742---
744### `+$mart:hoot`
746Dynamic XML attributes
748A list of atributes for an XML tag. For each list item, `n` is a
749[`$mane:hoot`](#manehoot) (an attribute name with optional namespace) and `v` is
750a `(list beer:hoot)` (the attribute itself, maybe with interpolated hoon).
752#### Source
754```hoon
755+$ mart (list [n=mane v=(list beer)])
756```
758#### Examples
760```
761> *mart:hoot
764> `manx:hoot`;foo.bar;
765[g=[n=%foo a=~[[n=%class v=~['b' 'a' 'r']]]] c=~]
767> `mart:hoot`a.g:`manx:hoot`;foo.bar;
768~[[n=%class v=~['b' 'a' 'r']]]
770> (en-xml:html ;foo.bar;)
771"<foo class=\"bar\"></foo>"
772```
774---
776### `+$marx:hoot`
778Dynamic XML tag
780An XML tag with optional attributes. `n` is a [`$mane:hoot`](#manehoot) (the tag
781name with optional namespace) and `a` is a [`$mart:hoot`](marthoot) (any XML
782attributes).
784#### Source
786```hoon
787+$ marx $~([%$ ~] [n=mane a=mart])
788```
790#### Examples
792```
793> `manx:hoot`;foo.bar;
794[g=[n=%foo a=~[[n=%class v=~['b' 'a' 'r']]]] c=~]
796> `marx:hoot`g:`manx:hoot`;foo.bar;
797[n=%foo a=~[[n=%class v=~['b' 'a' 'r']]]]
799> (en-xml:html ;foo.bar;)
800"<foo class=\"bar\"></foo>"
801```
803---
805### `+$mare:hoot`
807Node or nodes
809If `%.y`, a [`$manx:hoot`](#manxhoot) (single XML node). If `%.n`, a
810[`$marl:hoot`](#marlhoot) (list of XML nodes).
812#### Source
814```hoon
815+$ mare (each manx marl)
816```
818#### Examples
820```
821> *mare:hoot
822[%.y p=[g=[n=%$ a=~] c=~]]
824> `mare:hoot`[%.y ;foo.bar;]
825[%.y p=[g=[n=%foo a=~[[n=%class v=~['b' 'a' 'r']]]] c=~]]
827> `mare:hoot`[%.n ~[;foo.bar; ;baz;]]
828[%.n p=~[[g=[n=%foo a=~[[n=%class v=~['b' 'a' 'r']]]] c=~] [g=[n=%baz a=~] c=~]]]
829```
831---
833### `+$maru:hoot`
835Interpolation or nodes
837If `%.y`, a [`$tuna:hoot`](#tunahoot). If `%.n`, a [`$marl:hoot`](#marlhoot).
839#### Source
841```hoon
842+$ maru (each tuna marl)
843```
845---
847### `+$tuna:hoot`
849Maybe interpolation
851Kinds of nodes. Either an ordinary [`$manx:hoot`](#manxhoot), or else a plain tape, a
852[`$marl:hoot`](#marlhoot), or a function call.
854#### Source
856```hoon
857+$ tuna
858 $~ [[%$ ~] ~]
859 $^ manx
860 $: ?(%tape %manx %marl %call)
861 p=hoon
862 ==
863```
865---
867## `+$hoon`
869Hoon AST
871See the [Rune section](/docs/hoon/reference/rune) of the Hoon reference for
872details of what many of these relate to.
874#### Source
876```hoon
877+$ hoon ::
878 $~ [%zpzp ~]
879 $^ [p=hoon q=hoon] ::
880 $% ::
881 [%$ p=axis] :: simple leg
882 :: ::
883 [%base p=base] :: base spec
884 [%bust p=base] :: bunt base
885 [%dbug p=spot q=hoon] :: debug info in trace
886 [%eror p=tape] :: assembly error
887 [%hand p=type q=nock] :: premade result
888 [%note p=note q=hoon] :: annotate
889 [%fits p=hoon q=wing] :: underlying ?=
890 [%knit p=(list woof)] :: assemble string
891 [%leaf p=(pair term @)] :: symbol spec
892 [%limb p=term] :: take limb
893 [%lost p=hoon] :: not to be taken
894 [%rock p=term q=*] :: fixed constant
895 [%sand p=term q=*] :: unfixed constant
896 [%tell p=(list hoon)] :: render as tape
897 [%tune p=$@(term tune)] :: minimal face
898 [%wing p=wing] :: take wing
899 [%yell p=(list hoon)] :: render as tank
900 [%xray p=manx:hoot] :: ;foo; templating
901 :: :::::: cores
902 [%brbc sample=(lest term) body=spec] :: |$
903 [%brcb p=spec q=alas r=(map term tome)] :: |_
904 [%brcl p=hoon q=hoon] :: |:
905 [%brcn p=(unit term) q=(map term tome)] :: |%
906 [%brdt p=hoon] :: |.
907 [%brkt p=hoon q=(map term tome)] :: |^
908 [%brhp p=hoon] :: |-
909 [%brsg p=spec q=hoon] :: |~
910 [%brtr p=spec q=hoon] :: |*
911 [%brts p=spec q=hoon] :: |=
912 [%brpt p=(unit term) q=(map term tome)] :: |@
913 [%brwt p=hoon] :: |?
914 :: :::::: tuples
915 [%clcb p=hoon q=hoon] :: :_ [q p]
916 [%clkt p=hoon q=hoon r=hoon s=hoon] :: :^ [p q r s]
917 [%clhp p=hoon q=hoon] :: :- [p q]
918 [%clls p=hoon q=hoon r=hoon] :: :+ [p q r]
919 [%clsg p=(list hoon)] :: :~ [p ~]
920 [%cltr p=(list hoon)] :: :* p as a tuple
921 :: :::::: invocations
922 [%cncb p=wing q=(list (pair wing hoon))] :: %_
923 [%cndt p=hoon q=hoon] :: %.
924 [%cnhp p=hoon q=hoon] :: %-
925 [%cncl p=hoon q=(list hoon)] :: %:
926 [%cntr p=wing q=hoon r=(list (pair wing hoon))] :: %*
927 [%cnkt p=hoon q=hoon r=hoon s=hoon] :: %^
928 [%cnls p=hoon q=hoon r=hoon] :: %+
929 [%cnsg p=wing q=hoon r=(list hoon)] :: %~
930 [%cnts p=wing q=(list (pair wing hoon))] :: %=
931 :: :::::: nock
932 [%dtkt p=spec q=hoon] :: .^ nock 11
933 [%dtls p=hoon] :: .+ nock 4
934 [%dttr p=hoon q=hoon] :: .* nock 2
935 [%dtts p=hoon q=hoon] :: .= nock 5
936 [%dtwt p=hoon] :: .? nock 3
937 :: :::::: type conversion
938 [%ktbr p=hoon] :: ^| contravariant
939 [%ktdt p=hoon q=hoon] :: ^. self-cast
940 [%ktls p=hoon q=hoon] :: ^+ expression cast
941 [%kthp p=spec q=hoon] :: ^- structure cast
942 [%ktpm p=hoon] :: ^& covariant
943 [%ktsg p=hoon] :: ^~ constant
944 [%ktts p=skin q=hoon] :: ^= label
945 [%ktwt p=hoon] :: ^? bivariant
946 [%kttr p=spec] :: ^* example
947 [%ktcl p=spec] :: ^: filter
948 :: :::::: hints
949 [%sgbr p=hoon q=hoon] :: ~| sell on trace
950 [%sgcb p=hoon q=hoon] :: ~_ tank on trace
951 [%sgcn p=chum q=hoon r=tyre s=hoon] :: ~% general jet hint
952 [%sgfs p=chum q=hoon] :: ~/ function j-hint
953 [%sggl p=$@(term [p=term q=hoon]) q=hoon] :: ~< backward hint
954 [%sggr p=$@(term [p=term q=hoon]) q=hoon] :: ~> forward hint
955 [%sgbc p=term q=hoon] :: ~$ profiler hit
956 [%sgls p=@ q=hoon] :: ~+ cache=memoize
957 [%sgpm p=@ud q=hoon r=hoon] :: ~& printf=priority
958 [%sgts p=hoon q=hoon] :: ~= don't duplicate
959 [%sgwt p=@ud q=hoon r=hoon s=hoon] :: ~? tested printf
960 [%sgzp p=hoon q=hoon] :: ~! type on trace
961 :: :::::: miscellaneous
962 [%mcts p=marl:hoot] :: ;= list templating
963 [%mccl p=hoon q=(list hoon)] :: ;: binary to nary
964 [%mcfs p=hoon] :: ;/ [%$ [%$ p ~] ~]
965 [%mcgl p=spec q=hoon r=hoon s=hoon] :: ;< bind
966 [%mcsg p=hoon q=(list hoon)] :: ;~ kleisli arrow
967 [%mcmc p=spec q=hoon] :: ;; normalize
968 :: :::::: compositions
969 [%tsbr p=spec q=hoon] :: =| push bunt
970 [%tscl p=(list (pair wing hoon)) q=hoon] :: =: q w= p changes
971 [%tsfs p=skin q=hoon r=hoon] :: =/ typed variable
972 [%tsmc p=skin q=hoon r=hoon] :: =; =/(q p r)
973 [%tsdt p=wing q=hoon r=hoon] :: =. r with p as q
974 [%tswt p=wing q=hoon r=hoon s=hoon] :: =? conditional =.
975 [%tsgl p=hoon q=hoon] :: =< =>(q p)
976 [%tshp p=hoon q=hoon] :: =- =+(q p)
977 [%tsgr p=hoon q=hoon] :: => q w=subject p
978 [%tskt p=skin q=wing r=hoon s=hoon] :: =^ state machine
979 [%tsls p=hoon q=hoon] :: =+ q w=[p subject]
980 [%tssg p=(list hoon)] :: =~ hoon stack
981 [%tstr p=(pair term (unit spec)) q=hoon r=hoon] :: =* new style
982 [%tscm p=hoon q=hoon] :: =, overload p in q
983 :: :::::: conditionals
984 [%wtbr p=(list hoon)] :: ?| loobean or
985 [%wthp p=wing q=(list (pair spec hoon))] :: ?- pick case in q
986 [%wtcl p=hoon q=hoon r=hoon] :: ?: if=then=else
987 [%wtdt p=hoon q=hoon r=hoon] :: ?. ?:(p r q)
988 [%wtkt p=wing q=hoon r=hoon] :: ?^ if p is a cell
989 [%wtgl p=hoon q=hoon] :: ?< ?:(p !! q)
990 [%wtgr p=hoon q=hoon] :: ?> ?:(p q !!)
991 [%wtls p=wing q=hoon r=(list (pair spec hoon))] :: ?+ ?- w=default
992 [%wtpm p=(list hoon)] :: ?& loobean and
993 [%wtpt p=wing q=hoon r=hoon] :: ?@ if p is atom
994 [%wtsg p=wing q=hoon r=hoon] :: ?~ if p is null
995 [%wthx p=skin q=wing] :: ?# if q matches p
996 [%wtts p=spec q=wing] :: ?= if q matches p
997 [%wtzp p=hoon] :: ?! loobean not
998 :: :::::: special
999 [%zpcm p=hoon q=hoon] :: !,
1000 [%zpgr p=hoon] :: !>
1001 [%zpgl p=spec q=hoon] :: !<
1002 [%zpmc p=hoon q=hoon] :: !;
1003 [%zpts p=hoon] :: !=
1004 [%zppt p=(list wing) q=hoon r=hoon] :: !@
1005 [%zpwt p=$@(p=@ [p=@ q=@]) q=hoon] :: !?
1006 [%zpzp ~] :: !!
1007 == ::
1008```
1010#### Examples
1012```
1013> *hoon
1014[%zpzp ~]
1016> `hoon`(ream '|=([a=@ b=@] [b a])')
1017[ %brts
1019 [ %bccl
1021 [ i=[%bcts p=term=%a q=[%base p=[%atom p=~.]]]
1022 t=~[[%bcts p=term=%b q=[%base p=[%atom p=~.]]]]
1025 q=[%cltr p=~[[%wing p=~[%b]] [%wing p=~[%a]]]]
1027```
1029---
1031## `+$tyre`
1033List, term hoon
1035Associative list of `term` `hoon`, used in jet hint processing.
1037#### Source
1039```hoon
1040+$ tyre (list [p=term q=hoon]) ::
1041```
1043---
1045## `+$tyke`
1047List of 'maybe' hoons
1049List of `unit` `hoon`, or gaps left to be inferred, in `path` parsing. When you
1050use a path such as `/=base=/gen/code` the path is in fact a `tyke`, where the
1051`=` are inferred from your current path.
1053#### Source
1055```hoon
1056+$ tyke (list (unit hoon))
1057```
1059---
1061## `+$nock`
1063Virtual nock.
1065See the [Nock documentation](/docs/nock/definition) for details.
1067#### Source
1069```hoon
1070+$ nock $^ [p=nock q=nock] :: autocons
1071 $% [%1 p=*] :: constant
1072 [%2 p=nock q=nock] :: compose
1073 [%3 p=nock] :: cell test
1074 [%4 p=nock] :: increment
1075 [%5 p=nock q=nock] :: equality test
1076 [%6 p=nock q=nock r=nock] :: if, then, else
1077 [%7 p=nock q=nock] :: serial compose
1078 [%8 p=nock q=nock] :: push onto subject
1079 [%9 p=@ q=nock] :: select arm and fire
1080 [%10 p=[p=@ q=nock] q=nock] :: edit
1081 [%11 p=$@(@ [p=@ q=nock]) q=nock] :: hint
1082 [%12 p=nock q=nock] :: grab data from sky
1083 [%0 p=@] :: axis select
1084 == ::
1085```
1087#### Examples
1089```
1090> !=([+(.) 20 -<])
1091[[4 0 1] [1 20] 0 4]
1093> (nock !=([+(.) 20]))
1094[p=[%4 p=[%0 p=1]] q=[%1 p=20]]
1095```
1097---
1099## `+$note`
1101Type annotation
1103Used for documentation.
1105#### Source
1107```hoon
1108+$ note :: type annotation
1109 $% [%help p=help] :: documentation
1110 [%know p=stud] :: global standard
1111 [%made p=term q=(unit (list wing))] :: structure
1112 == ::
1113```
1115---
1117## `+$type`
1119Hoon type type
1121#### Source
1123```hoon
1124+$ type $~ %noun ::
1125 $@ $? %noun :: any nouns
1126 %void :: no noun
1127 == ::
1128 $% [%atom p=term q=(unit @)] :: atom / constant
1129 [%cell p=type q=type] :: ordered pair
1130 [%core p=type q=coil] :: object
1131 [%face p=$@(term tune) q=type] :: namespace
1132 [%fork p=(set type)] :: union
1133 [%hint p=(pair type note) q=type] :: annotation
1134 [%hold p=type q=hoon] :: lazy evaluation
1135 == ::
1136```
1138#### Examples
1140```
1141> `type`[%cell [%atom %ud ~] [%atom %ud ~]]
1142#t/[@ud @ud]
1143```
1145---
1147## `+$tony`
1149`$tone` done right
1151An intermediate Nock computation result. Similar to a
1152[`$toon`](/docs/hoon/reference/stdlib/3g#toon) but without a rendered stack
1153trace.
1155#### Source
1157```hoon
1158+$ tony :: ++tone done right
1159 $% [%0 p=tine q=*] :: success
1160 [%1 p=(set)] :: blocks
1161 [%2 p=(list [@ta *])] :: error ~_s
1162 == ::
1163```
1165---
1167## `+$tine`
1169Partial noun
1171#### Source
1173```hoon
1174+$ tine :: partial noun
1175 $@ ~ :: open
1176 $% [%& p=tine q=tine] :: half-blocked
1177 [%| p=(set)] :: fully blocked
1178 == ::
1179```
1181---
1183## `+$tool`
1185Type decoration
1187#### Source
1189```hoon
1190+$ tool $@(term tune)
1191```
1193---
1195## `+$tune`
1197Complex
1199#### Source
1201```hoon
1202+$ tune :: complex
1203 $~ [~ ~] ::
1204 $: p=(map term (unit hoon)) :: aliases
1205 q=(list hoon) :: bridges
1206 == ::
1207```
1209---
1211## `+$typo`
1213Old type
1215Same as `$type`
1217#### Source
1219```hoon
1220+$ typo type
1221```
1223---
1225## `+$vase`
1227Type-value pair
1229Typed data. A `$vase` is used wherever typed data is explicitly worked with.
1231#### Source
1233```hoon
1234+$ vase [p=type q=*]
1235```
1237#### Examples
1239```
1240> *vase
1241[#t/* q=0]
1243> !>([2 2])
1244[#t/[@ud @ud] q=[2 2]]
1246> !>('foo')
1247[#t/@t q=7.303.014]
1248```
1250---
1252## `+$vise`
1254Old vase
1256Same as a [`$vase`](#vase).
1258#### Source
1260```hoon
1261+$ vise [p=typo q=*]
1262```
1264---
1266## `+$vial`
1268co/contra/in/bi
1270Covariant, contravariant, invariant, bivariant.
1272#### Source
1274```hoon
1275+$ vial ?(%read %rite %both %free)
1276```
1278---
1280## `+$vair`
1282in/contra/bi/co
1284Core variance.
1286- `%gold` - invariant payload.
1287- `%iron` - contravariant sample.
1288- `%lead` - bivariant sample.
1289- `%zinc` - covariant sample.
1291See the Hoon School lesson on [type
1292polymorphism](/docs/hoon/hoon-school/type-polymorphism) for more details.
1294#### Source
1296```hoon
1297+$ vair ?(%gold %iron %lead %zinc)
1298```
1300---
1302## `+$vein`
1304Search trace
1306Noun search trace.
1308#### Source
1310```hoon
1311+$ vein (list (unit axis))
1312```
1314---
1316## `+$sect`
1318Paragraph
1320Used in documentation.
1322#### Source
1324```hoon
1325+$ sect (list pica)
1326```
1328---
1330## `+$whit`
1332Documentation
1334#### Source
1336```hoon
1337+$ whit ::
1338 $: lab=(unit term) :: label
1339 boy=(unit (pair cord (list sect))) :: body
1340 def=(map term (pair cord (list sect))) :: definitions
1341 use=(set term) :: defs used
1342 == ::
1343```
1345---
1347## `+$what`
1349Help slogan/section
1351#### Source
1353```hoon
1354+$ what (unit (pair cord (list sect)))
1355```
1357---
1359## `+$wing`
1361Search path
1363Address in subject. A `$wing` is a path to a value in the subject. A
1364term alone is the trivial case of a `$wing`.
1366#### Source
1368```hoon
1369+$ wing (list limb)
1370```
1372#### Examples
1374```
1375> (ream 'a.+.c')
1376[%wing p=~[%a [%.y p=3] %c]]
1378> (wing +:(ream 'a.+.c'))
1379~[%a [%.y p=3] %c]
1380```
1382---
1384## `+$block`
1386Abstract identity of resource awaited
1388#### Source
1390```hoon
1391+$ block
1392 path
1393```
1395---
1397## `+$result`
1399Internal interpreter result
1401#### Source
1403```hoon
1404+$ result
1405 $@(~ seminoun)
1406```
1408---
1410## `+$thunk`
1412Fragment constructor
1414#### Source
1416```hoon
1417+$ thunk
1418 $-(@ud (unit noun))
1419```
1421---
1423## `+$doss`
1425Profiling
1427#### Source
1429```hoon
1430+$ doss
1431 $: mon=moan :: sample count
1432 hit=(map term @ud) :: hit points
1433 cut=(map path hump) :: cut points
1434 ==
1435```
1437---
1439## `+$moan`
1441Profiling: sample metric
1443#### Source
1445```hoon
1446+$ moan :: sample metric
1447 $: fun=@ud :: samples in C
1448 noc=@ud :: samples in nock
1449 glu=@ud :: samples in glue
1450 mal=@ud :: samples in alloc
1451 far=@ud :: samples in frag
1452 coy=@ud :: samples in copy
1453 euq=@ud :: samples in equal
1454 == ::
1455```
1457---
1459## `+$hump`
1461Profiling
1463#### Source
1465```hoon
1466+$ hump
1467 $: mon=moan :: sample count
1468 out=(map path @ud) :: calls out of
1469 inn=(map path @ud) :: calls into
1470 ==
1471```
1473---