+++
title = "4o: Molds"
weight = 42
template = "doc.html"
+++
## `+$abel`
Original sin: type
Old type, same as the new `type`.
#### Source
```hoon
+$ abel typo
```
#### Examples
```
> *abel
#t/*
```
---
## `+$alas`
Alias list
This is the type used in `%brcb` (`|_` door) `hoon` type for `+*` alias arms.
#### Source
```hoon
+$ alas (list (pair term hoon))
```
---
## `+$atom`
Just an atom
This is the same as `@`.
#### Source
```hoon
+$ atom @
```
#### Examples
```
> *atom
0
> `atom`'foo'
7.303.014
```
---
## `+$aura`
'type' of atom
By convention, a short name for a category of atom. `aura` is circularly
defined, with `@ta` being the `aura` of the ASCII subset commonly used in urbit.
#### Source
```hoon
+$ aura @ta
```
#### Examples
See also: [`+$base`](#base), aura reference
```
> `aura`'ux'
~.ux
```
---
## `+$base`
Base type
A base type that nouns are built from. A `base` is either a noun, atom with
aura, cell, boolean, null, or an empty set.
#### Source
```hoon
+$ base :: base mold
$@ $? %noun :: any noun
%cell :: any cell
%flag :: loobean
%null :: ~ == 0
%void :: empty set
== ::
[%atom p=aura] :: atom
```
#### Examples
```
> *base
%void
> (ream '=|(^ !!)')
[%tsbr p=[%base p=%cell] q=[%zpzp ~]]
```
---
## `+$woof`
Simple embed
An atom or some `hoon`.
#### Source
```hoon
+$ woof $@(@ [~ p=hoon])
```
#### Examples
```
> *woof
0
> `woof`[~ %base p=%cell]
[~ p=[%base p=%cell]]
> `woof`'foo'
7.303.014
```
---
## `+$chum`
Jet hint information
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 version number.
#### Source
```hoon
+$ 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
== ::
```
#### Examples
```
> `chum`'hi'
lef=%hi
> (ream '~/(%lob.314 !!)')
[%sgfs p=[std=%lob kel=314] q=[%zpzp ~]]
```
---
## `+$coil`
Tuple of core information
Variance `p`, subject type `q`, and `r`: optional compiled nock, and arms. Used
as an intermediate step during compilation and converted to a core.
#### Source
```hoon
+$ coil $: p=garb :: name, wet=dry, vary
q=type :: context
r=(pair seminoun (map term tome)) :: chapters
== ::
```
---
## `+$garb`
Core metadata
A triple of an optional name, polarity (wet/dry), and variance (`%iron`, etc).
#### Source
```hoon
+$ garb (trel (unit term) poly vair)
```
---
## `+$poly`
Polarity
Whether a core is wet or dry.
#### Source
```hoon
+$ poly ?(%wet %dry)
```
---
## `+$foot`
Cases of arms by variance model.
#### Source
```hoon
+$ foot $% [%dry p=hoon] :: dry arm, geometric
[%wet p=hoon] :: wet arm, generic
==
```
---
## `+$link`
Lexical segment
Used for documentation.
#### Source
```hoon
+$ link :: lexical segment
$% [%chat p=term] :: |chapter
[%cone p=aura q=atom] :: %constant
[%frag p=term] :: .leg
[%funk p=term] :: +arm
==
```
---
## `+$crib`
Summary and details
Summary and details for documentation.
#### Source
```hoon
+$ crib [summary=cord details=(list sect)]
```
---
## `+$help`
Documentation
#### Source
```hoon
+$ help [links=(list link) =crib]
```
---
## `+$limb`
Wing element
Reference into subject by tree address or name.
#### Source
```hoon
+$ limb $@ term :: wing element
$% [%& p=axis] :: by geometry
[%| p=@ud q=(unit term)] :: by name
== ::
```
#### Examples
```
> (ream '^^$')
[%wing p=~[[%.n p=2 q=[~ %$]]]]
```
---
## `+$null`
Null, nil, etc
Just `~`.
#### Source
```hoon
+$ null ~
```
#### Examples
```
> *null
~
```
---
## `+$onyx`
Arm activation
#### Source
```hoon
+$ onyx (list (pair type foot))
```
---
## `+$opal`
Wing match
Arm or leg of a wing.
#### Source
```hoon
+$ opal :: limb match
$% [%& p=type] :: leg
[%| p=axis q=(set [p=type q=foot])] :: arm
== ::
```
---
## `+$pica`
Prose or code
A `(pair ? cord)`. If `%.y` it's prose and if `%.n` it's code. Used in
documentation.
#### Source
```hoon
+$ pica (pair ? cord)
```
---
## `+$palo`
Wing trace, match
A [`$vein`](#vein) and a [`$opal`](#opal).
#### Source
```hoon
+$ palo (pair vein opal)
```
---
## `+$plat`
%hoon, %type, %nock or %tank
#### Source
```hoon
+$ plat
$? %hoon
%type
%nock
%tank
==
```
---
## `+$pock`
Changes
#### Source
```hoon
+$ pock (pair axis nock)
```
---
## `+$port`
Successful wing match
#### Source
```hoon
+$ port (each palo (pair type nock))
```
---
## `+$spec`
Structure definition AST.
#### Source
```hoon
+$ spec :: structure definition
$~ [%base %null] ::
$% [%base p=base] :: base type
[%dbug p=spot q=spec] :: set debug
[%leaf p=term q=@] :: constant atom
[%like p=wing q=(list wing)] :: reference
[%loop p=term] :: hygienic reference
[%made p=(pair term (list term)) q=spec] :: annotate synthetic
[%make p=hoon q=(list spec)] :: composed spec
[%name p=term q=spec] :: annotate simple
[%over p=wing q=spec] :: relative to subject
:: ::
[%bcgr p=spec q=spec] :: $>, filter: require
[%bcbc p=spec q=(map term spec)] :: $$, recursion
[%bcbr p=spec q=hoon] :: $|, verify
[%bccb p=hoon] :: $_, example
[%bccl p=[i=spec t=(list spec)]] :: $:, tuple
[%bccn p=[i=spec t=(list spec)]] :: $%, head pick
[%bcdt p=spec q=(map term spec)] :: $., read-write core
[%bcgl p=spec q=spec] :: $<, filter: exclude
[%bchp p=spec q=spec] :: $-, function core
[%bckt p=spec q=spec] :: $^, cons pick
[%bcls p=stud q=spec] :: $+, standard
[%bcfs p=spec q=(map term spec)] :: $/, write-only core
[%bcmc p=hoon] :: $;, manual
[%bcpm p=spec q=hoon] :: $&, repair
[%bcsg p=hoon q=spec] :: $~, default
[%bctc p=spec q=(map term spec)] :: $`, read-only core
[%bcts p=skin q=spec] :: $=, name
[%bcpt p=spec q=spec] :: $@, atom pick
[%bcwt p=[i=spec t=(list spec)]] :: $?, full pick
[%bczp p=spec q=(map term spec)] :: $!, opaque core
== ::
```
#### Examples
```
> *spec
[%base p=%null]
> `spec`[%bccl ~[leaf+ud+1 leaf+ud+2]]
[%bccl p=[i=[%leaf p=%ud q=1] t=~[[%leaf p=%ud q=2]]]]
```
---
## `+$tent`
Model builder
#### Source
```hoon
+$ tent
$% [%| p=wing q=tent r=(list spec)] :: ~(p q r...)
[%& p=(list wing)] :: a.b:c.d
== ::
```
---
## `+$tiki`
Test case
This is used when compiling `?-` expressions and similar.
#### Source
```hoon
+$ tiki :: test case
$% [%& p=(unit term) q=wing] :: simple wing
[%| p=(unit term) q=hoon] :: named wing
== ::
```
---
## `+$skin`
Texture
This type is used for faces and similar by the compiler.
#### Source
```hoon
+$ skin :: texture
$@ =term :: name/~[term %none]
$% [%base =base] :: base match
[%cell =skin =skin] :: pair
[%dbug =spot =skin] :: trace
[%leaf =aura =atom] :: atomic constant
[%help =help =skin] :: describe
[%name =term =skin] :: apply label
[%over =wing =skin] :: relative to
[%spec =spec =skin] :: cast to
[%wash depth=@ud] :: strip faces
== ::
```
---
## `+$tome`
Core chapter
This type is used by the compiler for the contents of arms in cores.
#### Source
```hoon
+$ tome (pair what (map term hoon))
```
---
## `+$tope`
Topographic type
Describes the structure of a noun.
#### Source
```hoon
+$ tope :: topographic type
$@ $? %& :: cell or atom
%| :: atom
== ::
(pair tope tope) :: cell
```
#### Examples
```
> *tope
%.n
> `tope`[%| %&]
[p=%.n q=%.y]
```
---
## `++hoot`
Hoon tools
Container core for internally-used XML structure types. XML structure types
you'd typically use directly are defined in [Standard Library section
5e](/docs/hoon/reference/stdlib/5e).
#### Source
```hoon
++ hoot
|%
```
---
### `+$beer:hoot`
Simple embed
Either a tape element or interpolated hoon expression in an XML attribute.
#### Source
```hoon
+$ beer $@(char [~ p=hoon])
```
---
### `+$mane:hoot`
XML name+space
XML tag name and optional namespace.
#### Source
```hoon
+$ mane $@(@tas [@tas @tas])
```
#### Examples
```
> (en-xml:html ;foo;)
""
> (en-xml:html ;foo_bar;)
""
> `manx:hoot`;foo_bar;
[g=[n=[%foo %bar] a=~] c=~]
> `mane:hoot`n.g:`manx`;foo_bar;
[%foo %bar]
> `mane:hoot`n.g:`manx:hoot`;foo;
%foo
```
---
### `+$manx:hoot`
Dynamic XML node
An XML element which may contain text, attributes, and other elements.
`g` is a [`$marx:hoot`](#marxhoot) (a tag) and `c` is a
[`$marl:hoot`](#marlhoot) (its contents).
#### Source
```hoon
+$ manx $~([[%$ ~] ~] [g=marx c=marl])
```
#### Examples
```
> *manx:hoot
[g=[n=%$ a=~] c=~
> `manx:hoot`;foo;
[g=[n=%foo a=~] c=~]
> (en-xml:html `manx:hoot`;foo;)
""
> =a ^- manx:hoot
;foo
;bar: abc
;baz
;xxx: hello
==
==
> a
[ g=[n=%foo a=~]
c
~[
[ g=[n=%bar a=~]
c=~[[g=[n=%$ a=~[[n=%$ v="abc"]]] c=~]]
]
[ g=[n=%baz a=~]
c
~[
[ g=[n=%xxx a=~]
c=~[[g=[n=%$ a=~[[n=%$ v="hello"]]] c=~]]
]
]
]
]
]
> (en-xml:html a)
"abchello"
```
---
### `+$marl:hoot`
Dynamic XML nodes
A list of XML nodes - maybe with interpolation and recursion. See
[`$tuna:hoot`](#tunahoot).
#### Source
```hoon
+$ marl (list tuna)
```
#### Examples
```
> *marl
~
> ^- marl:hoot
;=
;foo: abc
;bar: def
==
~[
[g=[n=%foo a=~] c=~[[g=[n=%$ a=~[[n=%$ v=~['a' 'b' 'c']]]] c=~]]]
[g=[n=%bar a=~] c=~[[g=[n=%$ a=~[[n=%$ v=~['d' 'e' 'f']]]] c=~]]]
]
> %- en-xml:html
;baz
;=
;foo: abc
;bar: def
==
==
"abcdef"
```
---
### `+$mart:hoot`
Dynamic XML attributes
A list of atributes for an XML tag. For each list item, `n` is a
[`$mane:hoot`](#manehoot) (an attribute name with optional namespace) and `v` is
a `(list beer:hoot)` (the attribute itself, maybe with interpolated hoon).
#### Source
```hoon
+$ mart (list [n=mane v=(list beer)])
```
#### Examples
```
> *mart:hoot
~
> `manx:hoot`;foo.bar;
[g=[n=%foo a=~[[n=%class v=~['b' 'a' 'r']]]] c=~]
> `mart:hoot`a.g:`manx:hoot`;foo.bar;
~[[n=%class v=~['b' 'a' 'r']]]
> (en-xml:html ;foo.bar;)
""
```
---
### `+$marx:hoot`
Dynamic XML tag
An XML tag with optional attributes. `n` is a [`$mane:hoot`](#manehoot) (the tag
name with optional namespace) and `a` is a [`$mart:hoot`](marthoot) (any XML
attributes).
#### Source
```hoon
+$ marx $~([%$ ~] [n=mane a=mart])
```
#### Examples
```
> `manx:hoot`;foo.bar;
[g=[n=%foo a=~[[n=%class v=~['b' 'a' 'r']]]] c=~]
> `marx:hoot`g:`manx:hoot`;foo.bar;
[n=%foo a=~[[n=%class v=~['b' 'a' 'r']]]]
> (en-xml:html ;foo.bar;)
""
```
---
### `+$mare:hoot`
Node or nodes
If `%.y`, a [`$manx:hoot`](#manxhoot) (single XML node). If `%.n`, a
[`$marl:hoot`](#marlhoot) (list of XML nodes).
#### Source
```hoon
+$ mare (each manx marl)
```
#### Examples
```
> *mare:hoot
[%.y p=[g=[n=%$ a=~] c=~]]
> `mare:hoot`[%.y ;foo.bar;]
[%.y p=[g=[n=%foo a=~[[n=%class v=~['b' 'a' 'r']]]] c=~]]
> `mare:hoot`[%.n ~[;foo.bar; ;baz;]]
[%.n p=~[[g=[n=%foo a=~[[n=%class v=~['b' 'a' 'r']]]] c=~] [g=[n=%baz a=~] c=~]]]
```
---
### `+$maru:hoot`
Interpolation or nodes
If `%.y`, a [`$tuna:hoot`](#tunahoot). If `%.n`, a [`$marl:hoot`](#marlhoot).
#### Source
```hoon
+$ maru (each tuna marl)
```
---
### `+$tuna:hoot`
Maybe interpolation
Kinds of nodes. Either an ordinary [`$manx:hoot`](#manxhoot), or else a plain tape, a
[`$marl:hoot`](#marlhoot), or a function call.
#### Source
```hoon
+$ tuna
$~ [[%$ ~] ~]
$^ manx
$: ?(%tape %manx %marl %call)
p=hoon
==
```
---
## `+$hoon`
Hoon AST
See the [Rune section](/docs/hoon/reference/rune) of the Hoon reference for
details of what many of these relate to.
#### Source
```hoon
+$ hoon ::
$~ [%zpzp ~]
$^ [p=hoon q=hoon] ::
$% ::
[%$ p=axis] :: simple leg
:: ::
[%base p=base] :: base spec
[%bust p=base] :: bunt base
[%dbug p=spot q=hoon] :: debug info in trace
[%eror p=tape] :: assembly error
[%hand p=type q=nock] :: premade result
[%note p=note q=hoon] :: annotate
[%fits p=hoon q=wing] :: underlying ?=
[%knit p=(list woof)] :: assemble string
[%leaf p=(pair term @)] :: symbol spec
[%limb p=term] :: take limb
[%lost p=hoon] :: not to be taken
[%rock p=term q=*] :: fixed constant
[%sand p=term q=*] :: unfixed constant
[%tell p=(list hoon)] :: render as tape
[%tune p=$@(term tune)] :: minimal face
[%wing p=wing] :: take wing
[%yell p=(list hoon)] :: render as tank
[%xray p=manx:hoot] :: ;foo; templating
:: :::::: cores
[%brbc sample=(lest term) body=spec] :: |$
[%brcb p=spec q=alas r=(map term tome)] :: |_
[%brcl p=hoon q=hoon] :: |:
[%brcn p=(unit term) q=(map term tome)] :: |%
[%brdt p=hoon] :: |.
[%brkt p=hoon q=(map term tome)] :: |^
[%brhp p=hoon] :: |-
[%brsg p=spec q=hoon] :: |~
[%brtr p=spec q=hoon] :: |*
[%brts p=spec q=hoon] :: |=
[%brpt p=(unit term) q=(map term tome)] :: |@
[%brwt p=hoon] :: |?
:: :::::: tuples
[%clcb p=hoon q=hoon] :: :_ [q p]
[%clkt p=hoon q=hoon r=hoon s=hoon] :: :^ [p q r s]
[%clhp p=hoon q=hoon] :: :- [p q]
[%clls p=hoon q=hoon r=hoon] :: :+ [p q r]
[%clsg p=(list hoon)] :: :~ [p ~]
[%cltr p=(list hoon)] :: :* p as a tuple
:: :::::: invocations
[%cncb p=wing q=(list (pair wing hoon))] :: %_
[%cndt p=hoon q=hoon] :: %.
[%cnhp p=hoon q=hoon] :: %-
[%cncl p=hoon q=(list hoon)] :: %:
[%cntr p=wing q=hoon r=(list (pair wing hoon))] :: %*
[%cnkt p=hoon q=hoon r=hoon s=hoon] :: %^
[%cnls p=hoon q=hoon r=hoon] :: %+
[%cnsg p=wing q=hoon r=(list hoon)] :: %~
[%cnts p=wing q=(list (pair wing hoon))] :: %=
:: :::::: nock
[%dtkt p=spec q=hoon] :: .^ nock 11
[%dtls p=hoon] :: .+ nock 4
[%dttr p=hoon q=hoon] :: .* nock 2
[%dtts p=hoon q=hoon] :: .= nock 5
[%dtwt p=hoon] :: .? nock 3
:: :::::: type conversion
[%ktbr p=hoon] :: ^| contravariant
[%ktdt p=hoon q=hoon] :: ^. self-cast
[%ktls p=hoon q=hoon] :: ^+ expression cast
[%kthp p=spec q=hoon] :: ^- structure cast
[%ktpm p=hoon] :: ^& covariant
[%ktsg p=hoon] :: ^~ constant
[%ktts p=skin q=hoon] :: ^= label
[%ktwt p=hoon] :: ^? bivariant
[%kttr p=spec] :: ^* example
[%ktcl p=spec] :: ^: filter
:: :::::: hints
[%sgbr p=hoon q=hoon] :: ~| sell on trace
[%sgcb p=hoon q=hoon] :: ~_ tank on trace
[%sgcn p=chum q=hoon r=tyre s=hoon] :: ~% general jet hint
[%sgfs p=chum q=hoon] :: ~/ function j-hint
[%sggl p=$@(term [p=term q=hoon]) q=hoon] :: ~< backward hint
[%sggr p=$@(term [p=term q=hoon]) q=hoon] :: ~> forward hint
[%sgbc p=term q=hoon] :: ~$ profiler hit
[%sgls p=@ q=hoon] :: ~+ cache=memoize
[%sgpm p=@ud q=hoon r=hoon] :: ~& printf=priority
[%sgts p=hoon q=hoon] :: ~= don't duplicate
[%sgwt p=@ud q=hoon r=hoon s=hoon] :: ~? tested printf
[%sgzp p=hoon q=hoon] :: ~! type on trace
:: :::::: miscellaneous
[%mcts p=marl:hoot] :: ;= list templating
[%mccl p=hoon q=(list hoon)] :: ;: binary to nary
[%mcfs p=hoon] :: ;/ [%$ [%$ p ~] ~]
[%mcgl p=spec q=hoon r=hoon s=hoon] :: ;< bind
[%mcsg p=hoon q=(list hoon)] :: ;~ kleisli arrow
[%mcmc p=spec q=hoon] :: ;; normalize
:: :::::: compositions
[%tsbr p=spec q=hoon] :: =| push bunt
[%tscl p=(list (pair wing hoon)) q=hoon] :: =: q w= p changes
[%tsfs p=skin q=hoon r=hoon] :: =/ typed variable
[%tsmc p=skin q=hoon r=hoon] :: =; =/(q p r)
[%tsdt p=wing q=hoon r=hoon] :: =. r with p as q
[%tswt p=wing q=hoon r=hoon s=hoon] :: =? conditional =.
[%tsgl p=hoon q=hoon] :: =< =>(q p)
[%tshp p=hoon q=hoon] :: =- =+(q p)
[%tsgr p=hoon q=hoon] :: => q w=subject p
[%tskt p=skin q=wing r=hoon s=hoon] :: =^ state machine
[%tsls p=hoon q=hoon] :: =+ q w=[p subject]
[%tssg p=(list hoon)] :: =~ hoon stack
[%tstr p=(pair term (unit spec)) q=hoon r=hoon] :: =* new style
[%tscm p=hoon q=hoon] :: =, overload p in q
:: :::::: conditionals
[%wtbr p=(list hoon)] :: ?| loobean or
[%wthp p=wing q=(list (pair spec hoon))] :: ?- pick case in q
[%wtcl p=hoon q=hoon r=hoon] :: ?: if=then=else
[%wtdt p=hoon q=hoon r=hoon] :: ?. ?:(p r q)
[%wtkt p=wing q=hoon r=hoon] :: ?^ if p is a cell
[%wtgl p=hoon q=hoon] :: ?< ?:(p !! q)
[%wtgr p=hoon q=hoon] :: ?> ?:(p q !!)
[%wtls p=wing q=hoon r=(list (pair spec hoon))] :: ?+ ?- w=default
[%wtpm p=(list hoon)] :: ?& loobean and
[%wtpt p=wing q=hoon r=hoon] :: ?@ if p is atom
[%wtsg p=wing q=hoon r=hoon] :: ?~ if p is null
[%wthx p=skin q=wing] :: ?# if q matches p
[%wtts p=spec q=wing] :: ?= if q matches p
[%wtzp p=hoon] :: ?! loobean not
:: :::::: special
[%zpcm p=hoon q=hoon] :: !,
[%zpgr p=hoon] :: !>
[%zpgl p=spec q=hoon] :: !<
[%zpmc p=hoon q=hoon] :: !;
[%zpts p=hoon] :: !=
[%zppt p=(list wing) q=hoon r=hoon] :: !@
[%zpwt p=$@(p=@ [p=@ q=@]) q=hoon] :: !?
[%zpzp ~] :: !!
== ::
```
#### Examples
```
> *hoon
[%zpzp ~]
> `hoon`(ream '|=([a=@ b=@] [b a])')
[ %brts
p
[ %bccl
p
[ i=[%bcts p=term=%a q=[%base p=[%atom p=~.]]]
t=~[[%bcts p=term=%b q=[%base p=[%atom p=~.]]]]
]
]
q=[%cltr p=~[[%wing p=~[%b]] [%wing p=~[%a]]]]
]
```
---
## `+$tyre`
List, term hoon
Associative list of `term` `hoon`, used in jet hint processing.
#### Source
```hoon
+$ tyre (list [p=term q=hoon]) ::
```
---
## `+$tyke`
List of 'maybe' hoons
List of `unit` `hoon`, or gaps left to be inferred, in `path` parsing. When you
use a path such as `/=base=/gen/code` the path is in fact a `tyke`, where the
`=` are inferred from your current path.
#### Source
```hoon
+$ tyke (list (unit hoon))
```
---
## `+$nock`
Virtual nock.
See the [Nock documentation](/docs/nock/definition) for details.
#### Source
```hoon
+$ nock $^ [p=nock q=nock] :: autocons
$% [%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] :: edit
[%11 p=$@(@ [p=@ q=nock]) q=nock] :: hint
[%12 p=nock q=nock] :: grab data from sky
[%0 p=@] :: axis select
== ::
```
#### Examples
```
> !=([+(.) 20 -<])
[[4 0 1] [1 20] 0 4]
> (nock !=([+(.) 20]))
[p=[%4 p=[%0 p=1]] q=[%1 p=20]]
```
---
## `+$note`
Type annotation
Used for documentation.
#### Source
```hoon
+$ note :: type annotation
$% [%help p=help] :: documentation
[%know p=stud] :: global standard
[%made p=term q=(unit (list wing))] :: structure
== ::
```
---
## `+$type`
Hoon type type
#### Source
```hoon
+$ type $~ %noun ::
$@ $? %noun :: any nouns
%void :: no noun
== ::
$% [%atom p=term q=(unit @)] :: atom / constant
[%cell p=type q=type] :: ordered pair
[%core p=type q=coil] :: object
[%face p=$@(term tune) q=type] :: namespace
[%fork p=(set type)] :: union
[%hint p=(pair type note) q=type] :: annotation
[%hold p=type q=hoon] :: lazy evaluation
== ::
```
#### Examples
```
> `type`[%cell [%atom %ud ~] [%atom %ud ~]]
#t/[@ud @ud]
```
---
## `+$tony`
`$tone` done right
An intermediate Nock computation result. Similar to a
[`$toon`](/docs/hoon/reference/stdlib/3g#toon) but without a rendered stack
trace.
#### Source
```hoon
+$ tony :: ++tone done right
$% [%0 p=tine q=*] :: success
[%1 p=(set)] :: blocks
[%2 p=(list [@ta *])] :: error ~_s
== ::
```
---
## `+$tine`
Partial noun
#### Source
```hoon
+$ tine :: partial noun
$@ ~ :: open
$% [%& p=tine q=tine] :: half-blocked
[%| p=(set)] :: fully blocked
== ::
```
---
## `+$tool`
Type decoration
#### Source
```hoon
+$ tool $@(term tune)
```
---
## `+$tune`
Complex
#### Source
```hoon
+$ tune :: complex
$~ [~ ~] ::
$: p=(map term (unit hoon)) :: aliases
q=(list hoon) :: bridges
== ::
```
---
## `+$typo`
Old type
Same as `$type`
#### Source
```hoon
+$ typo type
```
---
## `+$vase`
Type-value pair
Typed data. A `$vase` is used wherever typed data is explicitly worked with.
#### Source
```hoon
+$ vase [p=type q=*]
```
#### Examples
```
> *vase
[#t/* q=0]
> !>([2 2])
[#t/[@ud @ud] q=[2 2]]
> !>('foo')
[#t/@t q=7.303.014]
```
---
## `+$vise`
Old vase
Same as a [`$vase`](#vase).
#### Source
```hoon
+$ vise [p=typo q=*]
```
---
## `+$vial`
co/contra/in/bi
Covariant, contravariant, invariant, bivariant.
#### Source
```hoon
+$ vial ?(%read %rite %both %free)
```
---
## `+$vair`
in/contra/bi/co
Core variance.
- `%gold` - invariant payload.
- `%iron` - contravariant sample.
- `%lead` - bivariant sample.
- `%zinc` - covariant sample.
See the Hoon School lesson on [type
polymorphism](/docs/hoon/hoon-school/type-polymorphism) for more details.
#### Source
```hoon
+$ vair ?(%gold %iron %lead %zinc)
```
---
## `+$vein`
Search trace
Noun search trace.
#### Source
```hoon
+$ vein (list (unit axis))
```
---
## `+$sect`
Paragraph
Used in documentation.
#### Source
```hoon
+$ sect (list pica)
```
---
## `+$whit`
Documentation
#### Source
```hoon
+$ whit ::
$: lab=(unit term) :: label
boy=(unit (pair cord (list sect))) :: body
def=(map term (pair cord (list sect))) :: definitions
use=(set term) :: defs used
== ::
```
---
## `+$what`
Help slogan/section
#### Source
```hoon
+$ what (unit (pair cord (list sect)))
```
---
## `+$wing`
Search path
Address in subject. A `$wing` is a path to a value in the subject. A
term alone is the trivial case of a `$wing`.
#### Source
```hoon
+$ wing (list limb)
```
#### Examples
```
> (ream 'a.+.c')
[%wing p=~[%a [%.y p=3] %c]]
> (wing +:(ream 'a.+.c'))
~[%a [%.y p=3] %c]
```
---
## `+$block`
Abstract identity of resource awaited
#### Source
```hoon
+$ block
path
```
---
## `+$result`
Internal interpreter result
#### Source
```hoon
+$ result
$@(~ seminoun)
```
---
## `+$thunk`
Fragment constructor
#### Source
```hoon
+$ thunk
$-(@ud (unit noun))
```
---
## `+$doss`
Profiling
#### Source
```hoon
+$ doss
$: mon=moan :: sample count
hit=(map term @ud) :: hit points
cut=(map path hump) :: cut points
==
```
---
## `+$moan`
Profiling: sample metric
#### Source
```hoon
+$ moan :: sample metric
$: fun=@ud :: samples in C
noc=@ud :: samples in nock
glu=@ud :: samples in glue
mal=@ud :: samples in alloc
far=@ud :: samples in frag
coy=@ud :: samples in copy
euq=@ud :: samples in equal
== ::
```
---
## `+$hump`
Profiling
#### Source
```hoon
+$ hump
$: mon=moan :: sample count
out=(map path @ud) :: calls out of
inn=(map path @ud) :: calls into
==
```
---