+$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
> *atom0> `atom`'foo'7.303.014
+$aura
'type' of atom
By convention, a short name for a category of atom. aura is circularly defined, with @ta being the aura of the ASCII subset commonly used in urbit.
Source
+$ aura @ta
Examples
See also: +$base, aura reference
> `aura`'ux'~.ux
+$base
Base type
A base type that nouns are built from. A base is either a noun, atom with aura, cell, boolean, null, or an empty set.
Source
+$ 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
> *woof0> `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, varyq=type :: contextr=(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
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 Standard Library 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])')[ %brtsp[ %bcclp[ 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)) :: aliasesq=(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) :: labelboy=(unit (pair cord (list sect))) :: bodydef=(map term (pair cord (list sect))) :: definitionsuse=(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
+$ blockpath
+$result
Internal interpreter result
Source
+$ result$@(~ seminoun)
+$thunk
Fragment constructor
Source
+$ thunk$-(@ud (unit noun))
+$doss
Profiling
Source
+$ doss$: mon=moan :: sample counthit=(map term @ud) :: hit pointscut=(map path hump) :: cut points==
+$moan
Profiling: sample metric
Source
+$ moan :: sample metric$: fun=@ud :: samples in Cnoc=@ud :: samples in nockglu=@ud :: samples in gluemal=@ud :: samples in allocfar=@ud :: samples in fragcoy=@ud :: samples in copyeuq=@ud :: samples in equal== ::
+$hump
Profiling
Source
+$ hump$: mon=moan :: sample countout=(map path @ud) :: calls out ofinn=(map path @ud) :: calls into==