# 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](/hoon/stdlib/5e.md).

#### 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](/hoon/rune.md) 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](/nock/definition.md) 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`](/hoon/stdlib/3g.md#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](/build-on-urbit/hoon-school/r-metals.md) 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
  ==
```

***


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.urbit.org/hoon/stdlib/4o.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.