# 4o: Molds

## `$abel` <a href="#abel" id="abel"></a>

Original sin: type.

Old type, same as the new `$type`.

#### Source

```hoon
+$  abel  typo
```

#### Examples

```
> *abel
#t/*
```

***

## `$alas` <a href="#alas" id="alas"></a>

Alias list.

This is the type used in `%brcb` (`|_` door) `$hoon` type for `+*` alias arms.

#### Source

```hoon
+$  alas  (list (pair term hoon))
```

***

## `$atom` <a href="#atom" id="atom"></a>

Just an `$atom`.

This is the same as `@`.

#### Source

```hoon
+$  atom  @
```

#### Examples

```
> *atom
0
```

```
> `atom`'foo'
7.303.014
```

***

## `$aura` <a href="#aura" id="aura"></a>

"Type" of an `$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` <a href="#base" id="base"></a>

Base type.

A base type that `$noun`s are built from. A `$base` is either a `$noun`, `$atom` with `$aura`, a `$cell`, loobean `$flag`, 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` <a href="#woof" id="woof"></a>

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` <a href="#chum" id="chum"></a>

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` <a href="#coil" id="coil"></a>

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` <a href="#garb" id="garb"></a>

Core metadata.

A triple of an optional name, polarity (wet/dry), and variance (`%iron`, etc).

#### Source

```hoon
+$  garb  (trel (unit term) poly vair)
```

***

## `$poly` <a href="#poly" id="poly"></a>

Polarity.

Whether a core is wet or dry.

#### Source

```hoon
+$  poly  ?(%wet %dry)
```

***

## `$foot` <a href="#foot" id="foot"></a>

Cases of arms by variance model.

#### Source

```hoon
+$  foot  $%  [%dry p=hoon]    ::  dry arm, geometric
              [%wet p=hoon]    ::  wet arm, generic
          ==
```

***

## `$link` <a href="#link" id="link"></a>

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` <a href="#crib" id="crib"></a>

Summary and details.

Summary and details for documentation.

#### Source

```hoon
+$  crib  [summary=cord details=(list sect)]
```

***

## `$help` <a href="#help" id="help"></a>

Documentation.

#### Source

```hoon
+$  help  [links=(list link) =crib]
```

***

## `$limb` <a href="#limb" id="limb"></a>

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` <a href="#null" id="null"></a>

Null, nil, etc.

Just `~`.

#### Source

```hoon
+$  null  ~
```

#### Examples

```
> *null
~
```

***

## `$onyx` <a href="#onyx" id="onyx"></a>

Arm activation.

#### Source

```hoon
+$  onyx  (list (pair type foot))
```

***

## `$opal` <a href="#opal" id="opal"></a>

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` <a href="#pica" id="pica"></a>

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` <a href="#palo" id="palo"></a>

Wing trace, match.

A [`$vein`](#vein) and a [`$opal`](#opal).

#### Source

```hoon
+$  palo  (pair vein opal)
```

***

## `$plat` <a href="#plat" id="plat"></a>

`%hoon`, `%type`, `%nock` or `%tank`.

#### Source

```hoon
+$  plat
          $?  %hoon
              %type
              %nock
              %tank
          ==
```

***

## `$pock` <a href="#pock" id="pock"></a>

Changes.

#### Source

```hoon
+$  pock  (pair axis nock)
```

***

## `$port` <a href="#port" id="port"></a>

Successful wing match.

#### Source

```hoon
+$  port  (each palo (pair type nock))
```

***

## `$spec` <a href="#spec" id="spec"></a>

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` <a href="#tent" id="tent"></a>

Model builder.

#### Source

```hoon
+$  tent
          $%  [%| p=wing q=tent r=(list spec)]    ::  ~(p q r...)
              [%& p=(list wing)]                  ::  a.b:c.d
          ==                                      ::
```

***

## `$tiki` <a href="#tiki" id="tiki"></a>

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` <a href="#skin" id="skin"></a>

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` <a href="#tome" id="tome"></a>

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` <a href="#tope" id="tope"></a>

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` <a href="#hoot" id="hoot"></a>

Hoon tools.

Container core for internally-used XML structure types. XML structure types you'd typically use directly are defined in [section 5e](https://docs.urbit.org/hoon/stdlib/5e).

#### Source

```hoon
++  hoot
  |%
```

***

### `$beer:hoot` <a href="#beerhoot" id="beerhoot"></a>

Simple embed.

Either a tape element or interpolated hoon expression in an XML attribute.

#### Source

```hoon
+$  beer  $@(char [~ p=hoon])
```

***

### `$mane:hoot` <a href="#manehoot" id="manehoot"></a>

XML name+space.

XML tag name and optional namespace.

#### Source

```hoon
+$  mane  $@(@tas [@tas @tas])
```

#### Examples

```
> (en-xml:html ;foo;)
"<foo></foo>"
```

```
> (en-xml:html ;foo_bar;)
"<foo:bar></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` <a href="#manxhoot" id="manxhoot"></a>

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;)
"<foo></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)
"<foo><bar>abc</bar><baz><xxx>hello</xxx></baz></foo>"
```

***

### `$marl:hoot` <a href="#marlhoot" id="marlhoot"></a>

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
    ==
  ==
"<baz><foo>abc</foo><bar>def</bar></baz>"
```

***

### `$mart:hoot` <a href="#marthoot" id="marthoot"></a>

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;)
"<foo class=\"bar\"></foo>"
```

***

### `$marx:hoot` <a href="#marxhoot" id="marxhoot"></a>

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;)
"<foo class=\"bar\"></foo>"
```

***

### `$mare:hoot` <a href="#marehoot" id="marehoot"></a>

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` <a href="#maruhoot" id="maruhoot"></a>

Interpolation or nodes.

If `%.y`, a [`$tuna:hoot`](#tunahoot). If `%.n`, a [`$marl:hoot`](#marlhoot).

#### Source

```hoon
+$  maru  (each tuna marl)
```

***

### `$tuna:hoot` <a href="#tunahoot" id="tunahoot"></a>

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` <a href="#hoon" id="hoon"></a>

Hoon AST.

See the [rune section](https://docs.urbit.org/hoon/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` <a href="#tyre" id="tyre"></a>

List, term hoon.

Associative list of `[term hoon]`, used in jet hint processing.

#### Source

```hoon
+$  tyre  (list [p=term q=hoon])                        ::
```

***

## `$tyke` <a href="#tyke" id="tyke"></a>

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` <a href="#nock" id="nock"></a>

Virtual nock.

See the [Nock documentation](https://docs.urbit.org/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` <a href="#note" id="note"></a>

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` <a href="#type" id="type"></a>

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` <a href="#tony" id="tony"></a>

`$tone` done right.

An intermediate Nock computation result. Similar to a [`$toon`](https://docs.urbit.org/hoon/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` <a href="#tine" id="tine"></a>

Partial `$noun`.

#### Source

```hoon
+$  tine                            ::  partial noun
          $@  ~                     ::  open
          $%  [%& p=tine q=tine]    ::  half-blocked
              [%| p=(set)]          ::  fully blocked
          ==                        ::
```

***

## `$tool` <a href="#tool" id="tool"></a>

Type decoration.

#### Source

```hoon
+$  tool  $@(term tune)
```

***

## `$tune` <a href="#tune" id="tune"></a>

Complex.

#### Source

```hoon
+$  tune                                  ::  complex
          $~  [~ ~]                       ::
          $:  p=(map term (unit hoon))    ::  aliases
              q=(list hoon)               ::  bridges
          ==                              ::
```

***

## `$typo` <a href="#typo" id="typo"></a>

Old type.

Same as `$type`

#### Source

```hoon
+$  typo  type
```

***

## `$vase` <a href="#vase" id="vase"></a>

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` <a href="#vise" id="vise"></a>

Old vase.

Same as a [`$vase`](#vase).

#### Source

```hoon
+$  vise  [p=typo q=*]
```

***

## `$vial` <a href="#vial" id="vial"></a>

co/contra/in/bi.

Covariant, contravariant, invariant, bivariant.

#### Source

```hoon
+$  vial  ?(%read %rite %both %free)
```

***

## `$vair` <a href="#vair" id="vair"></a>

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](https://docs.urbit.org/build-on-urbit/hoon-school/r-metals) for more details.

#### Source

```hoon
+$  vair  ?(%gold %iron %lead %zinc)
```

***

## `$vein` <a href="#vein" id="vein"></a>

Search trace.

Noun search trace.

#### Source

```hoon
+$  vein  (list (unit axis))
```

***

## `$sect` <a href="#sect" id="sect"></a>

Paragraph.

Used in documentation.

#### Source

```hoon
+$  sect  (list pica)
```

***

## `$whit` <a href="#whit" id="whit"></a>

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` <a href="#what" id="what"></a>

Help slogan/section.

#### Source

```hoon
+$  what  (unit (pair cord (list sect)))
```

***

## `$wing` <a href="#wing" id="wing"></a>

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` <a href="#block" id="block"></a>

Abstract identity of resource awaited.

#### Source

```hoon
+$  block
  path
```

***

## `$result` <a href="#result" id="result"></a>

Internal interpreter result.

#### Source

```hoon
+$  result
  $@(~ seminoun)
```

***

## `$thunk` <a href="#thunk" id="thunk"></a>

Fragment constructor.

#### Source

```hoon
+$  thunk
  $-(@ud (unit noun))
```

***

## `$doss` <a href="#doss" id="doss"></a>

Profiling.

#### Source

```hoon
+$  doss
  $:  mon=moan               ::  sample count
      hit=(map term @ud)     ::  hit points
      cut=(map path hump)    ::  cut points
  ==
```

***

## `$moan` <a href="#moan" id="moan"></a>

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` <a href="#hump" id="hump"></a>

Profiling.

#### Source

```hoon
+$  hump
  $:  mon=moan              ::  sample count
      out=(map path @ud)    ::  calls out of
      inn=(map path @ud)    ::  calls into
  ==
```

***