4o: Molds

`$abel`

Original sin: type.

Old type, same as the new $type.

Source

+$  abel  typo

Examples

> *abel
#t/*

`$alas`

Alias list.

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

Source

+$  alas  (list (pair term hoon))

`$atom`

Just an $atom.

This is the same as @.

Source

+$  atom  @

Examples

> *atom
0

> `atom`'foo'
7.303.014

`$aura`

"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

+$  aura  @ta

Examples

`$base`

Base type.

A base type that $nouns are built from. A $base is either a $noun, $atom with $aura, a $cell, loobean $flag, null (~), or an empty set.

Source

+$  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

+$  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

+$  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

+$  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

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

`$poly`

Polarity.

Whether a core is wet or dry.

Source

+$  poly  ?(%wet %dry)

`$foot`

Cases of arms by variance model.

Source

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

`$link`

Lexical segment.

Used for documentation.

Source

+$  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

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

`$help`

Documentation.

Source

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

`$limb`

Wing element.

Reference into subject by tree address or name.

Source

+$  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

+$  null  ~

Examples

> *null
~

`$onyx`

Arm activation.

Source

+$  onyx  (list (pair type foot))

`$opal`

Wing match.

Arm or leg of a wing.

Source

+$  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

+$  pica  (pair ? cord)

`$palo`

Wing trace, match.

A $vein and a $opal.

Source

+$  palo  (pair vein opal)

`$plat`

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

Source

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

`$pock`

Changes.

Source

+$  pock  (pair axis nock)

`$port`

Successful wing match.

Source

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

`$spec`

Structure definition AST.

Source

+$  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

+$  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

+$  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

+$  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

+$  tome  (pair what (map term hoon))

`$tope`

Topographic type.

Describes the structure of a $noun.

Source

+$  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 section 5e.

Source

++  hoot
  |%

`$beer:hoot`

Simple embed.

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

Source

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

`$mane:hoot`

XML name+space.

XML tag name and optional namespace.

Source

+$  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`

Dynamic XML node.

An XML element which may contain text, attributes, and other elements.

.g is a $marx:hoot (a tag) and .c is a $marl:hoot (its contents).

Source

+$  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`

Dynamic XML nodes.

A list of XML nodes - maybe with interpolation and recursion. See $tuna:hoot.

Source

+$  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`

Dynamic XML attributes.

A list of atributes for an XML tag. For each list item, .n is a $mane:hoot (an attribute name with optional namespace) and .v is a (list beer:hoot) (the attribute itself, maybe with interpolated hoon).

Source

+$  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`

Dynamic XML tag.

An XML tag with optional attributes. .n is a $mane:hoot (the tag name with optional namespace) and .a is a $mart:hoot (any XML attributes).

Source

+$  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`

Node or nodes.

If %.y, a $manx:hoot (single XML node). If %.n, a $marl:hoot (list of XML nodes).

Source

+$  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. If %.n, a $marl:hoot.

Source

+$  maru  (each tuna marl)

`$tuna:hoot`

Maybe interpolation.

Kinds of nodes. Either an ordinary $manx:hoot, or else a plain tape, a $marl:hoot, or a function call.

Source

+$  tuna
    $~  [[%$ ~] ~]
    $^  manx
    $:  ?(%tape %manx %marl %call)
        p=hoon
    ==

`$hoon`

Hoon AST.

See the rune section of the Hoon reference for details of what many of these relate to.

Source

+$  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

+$  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

+$  tyke  (list (unit hoon))

`$nock`

Virtual nock.

See the Nock documentation for details.

Source

+$  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

+$  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

+$  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 but without a rendered stack trace.

Source

+$  tony                               ::  ++tone done right
          $%  [%0 p=tine q=*]          ::  success
              [%1 p=(set)]             ::  blocks
              [%2 p=(list [@ta *])]    ::  error ~_s
          ==                           ::

`$tine`

Partial $noun.

Source

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

`$tool`

Type decoration.

Source

+$  tool  $@(term tune)

`$tune`

Complex.

Source

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

`$typo`

Old type.

Same as $type

Source

+$  typo  type

`$vase`

Type-value pair.

Typed data. A $vase is used wherever typed data is explicitly worked with.

Source

+$  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.

Source

+$  vise  [p=typo q=*]

`$vial`

co/contra/in/bi.

Covariant, contravariant, invariant, bivariant.

Source

+$  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 for more details.

Source

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

`$vein`

Search trace.

Noun search trace.

Source

+$  vein  (list (unit axis))

`$sect`

Paragraph.

Used in documentation.

Source

+$  sect  (list pica)

`$whit`

Documentation.

Source

+$  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

+$  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

+$  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

+$  block
  path

`$result`

Internal interpreter result.

Source

+$  result
  $@(~ seminoun)

`$thunk`

Fragment constructor.

Source

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

`$doss`

Profiling.

Source

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

`$moan`

Profiling: sample metric.

Source

+$  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

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

Previous4n: Virtualization Next5a: Compiler Utilities

Last updated 4 months ago