![[Home]](http://www.bayleshanks.com/cartoonbayle.png)
This cheat sheet contains lists of 'Hoon' words and symbols and short descriptions of what they are or what they do. Note that we unabashedly map Hoon concepts to the closest corresponding concept in other programming languages, even if the concepts are not quite the same. For example, in biology, bird wings and bat wings are said to be analogous but not homologous, because they have similar function but they are not quite the same and indeed the common ancestor of birds and bats did not have wings. In this table, we map analogous concepts to each other even if they are not homologous; if bat wings and bird wings were here, we would map bat wings to bird wings. For example, we map 'gate' to 'function; see the section "Gates and lambda" from Hoon tutorial section 4 for more discussion of this.
Please note that i am writing this in the process of learning Hoon, and i don't understand most of what is written here yet, so there are probably many mistakes and misconceptions in this document.
Note: this is NOT meant to become a complete language reference; it is supposed to cover only those things that you need to know in order to understand the tutorial, and perhaps a few of the other most important language constructs.
add: addition
Arm: "A core formula is called an arm. An arm is almost like an object-oriented method, but not quite - a method would be an arm that produces a function on an argument. The arm is just a function of the core, ie, a computed attribute." "a computed expression". Note that an Arm expects to be called with the entire Core that it is a part of as its subject. Can also be thought of as consisting of both a symbol (the fieldname) and also a twig (the arm itself). If we Pull a Wing in a Core and the result is computed by a formula, then that result is an Arm; but if we Pull a Wing in a Core and the result is defined as a subtree of the Core, then that result is a Leg. [1] [2] [3] [4]
Ash: geometric polymorphism. 'dry'.
Atom: a natural number. Also a type stem %atom.
Axil: 'base' tile; see table Tiles.
Axis/Axes: a type of limb which is a fieldname/field selector. [5]
Bark: naming tile; see table Tiles.
Base: see table 'Tiles'
Battery: The head of a Core; code, containing one or more Formulas.
bean: short for Loobean (boolean)
Book: "a core which contains only code and constant data". "A core whose payload is either another core, or a constant (%cube)" Contrast to Cart [6] [7]
Bulb: The tail of a kelp. [8]
Bull: alias type [9]
bunt: a tile reduction. [10]
bush: pair/tag tile; see table Tiles. [11]
by: Maps container. "++by is the container for all the map arms. The contained arms inherit its sample, the map a." "Note: ++by is not used alone, but is used to call the arms it contains." [12]
Cart: "a core containing dynamic state". Contrast to Book. [13]
Cell: ordered pair of nouns. Syntax: [a b]. Groups to the right, so e.g. [2 6 14 15] is short for [2 [6 [14 15]]]. Also a type stem %cell.
clam: a tile reduction. A clam just produces a gate which executes a whip to the given tile (e.g. it produces a closure which remembers the tile you give it, as passes that to the whip reduction when it is called) [14]
Coil: todo. see http://doc.urbit.org/doc/hoon/tut/3/
Context: todo. Also indicated by '+>', or 'gras'. [15]
Core: a "core is just a cell whose tail is data (possibly containing other cores) and whose head is code (containing one or more formulas). The tail is the payload and the head is the battery...To activate a core, pick a formula out of the battery, and use the entire core (_not_ just the payload) as the subject." or "a core is a [code data] cell - [battery payload]. Essentially, an object. The battery, at the Nock level, is a tree of formulas, each of whose subject is the core itself.". " A core is a noun of the form [battery payload] where the battery is a tree of formulas, each invoked with the entire core as the subject, and the payload is any noun.". "There are three main ways we can talk about a core: its variance model, %gold, %iron, %zinc or %lead, %gold by default; the inference approach of each of its feet, %ash or %elm, informally dry or wet, dry or ash by default; and its payload pattern, which makes it a gate, reef, book, trap or tray. There are also several ways of using cores: you can pull, kick, slam or slug them." %core is also a type stem. [16] [17] [18]
Cord: string. syntax: 'this is a string'; 'to escape a \'quote\', use \'backslash\. [19]
cube: todo type stem. Related to constants.
cue: unmarshall
dec: decrement. [20]
Dry: geometric polymorphism. ash. [21]
Elm: generic polymorphism. 'wet'. [22]
f(x): f(x) (?where f and x are alphanumerics?) is the irregular form of %=(f x). [23]
Face: todo type stem. presumably short for 'interface'
Fern: plain selection tile; see table Tiles.
Fish: a tile reduction. [24]
Foot: todo. http://web.archive.org/web/20131005080850/http://www.urbit.org/2013/08/22/Chapter-5-types.html says that the formulas in a battery are called '%foot's, but i haven't seen that elsewhere yet. [25]
Fork: todo type stem.
Formula: In Nock, Nock instructions are generally cells of the form [subject formula]. "Intuitively, the formula is your function and the subject is its argument. We call them something different because Hoon, or any other high-level language built on Nock, will build its own function calling convention which does not map directly to *[subject formula]....Basically, the subject is your data and the formula is your code.". [26]
Frond: A case within a kelp. [27]
Gate: a core serving as a function. "A gate is a trap whose payload has the form [sample context], sample being dynamic data and context being anything." I think a Gate is of the form [formula payload] (contrast to a Core, which is [battery payload], where a Battery can be a structure with many Formulas), but i'm not sure. Syntax: ++gatename to indicate the gate named 'gatename'. todo. see also table 'Gate, parts of'. see also http://doc.urbit.org/doc/hoon/tut/4/ . "Every gate is a trap. Every gate is a tray." [28] [29]
gen: todo, i see this all over the place in the tutorial, but i don't know what it is. e.g. in http://doc.urbit.org/doc/hoon/tut/6/ in ++open. Is this just an internal variable name in the interpreter for the AST we are currently processing?
Geometric polymorphism: [30]
Glyph: A punctuation character. Hoon assigns non-standard names to them, see table "Glyphs (Hoon glyph names)", below.
Gold: polymorphism with variance: invariant. [31]
Gonad: todo, see http://doc.urbit.org/doc/hoon/tut/7/
Herb: function (custom) tile; see table Tiles.
Hold: %hold is the pseudolazy evaluation type stem. [32]
homo: homogenize the type of a list. [33]
Hoon: Language name. Synonym for rune. What else?
homo: homogenize. "homogenizes the type of a list, producing its sample noun unchanged" [34]
Icon: the type of a tile? [35]
Iron: polymorphism with variance: contravariant. [36]
jam: marshall
Kelp: tag selection tile; see table Tiles. The head of a kelp must be a leaf. The head of a kelp is called a stem, and the tail is called a bulb. Cases of a kelp are called fronds. [37]
Kick: "To pull %$ - the empty name - on a core is to kick it. To replace the sample with a in gate g then kick the gate, is to slam g with a." [38]
Lead: polymorphism with variance: bivariant. [39]
Leaf: constant atom tile; see table Tiles.
Leg: "part of a typed noun (a fragment, as in Nock /)". If we Pull a Wing in a Core and the result is computed by a formula, then that result is an Arm; but if we Pull a Wing in a Core and the result is defined as a subtree of the Core, then that result is a Leg. [40] [41]
Limb: Part of a Wing. "a name or axis (which of course applies to all nouns, not just cores) is a limb. A list of limbs is a wing." "Each limb in the wing can be either a tree address (like +3, meaning Nock’s /3) or a name (like foo).". See also "name resolution" in http://doc.urbit.org/doc/hoon/tut/2/ . [42] [43]
Line: see table 'Tiles'
Loobean: boolean (note that 1 is false and 0 is true). syntax: .y == & == 0, .n ==
| === 1. [44] |
map: todo. ++ map: "A map is a tree of [p=* q=*] cells where n is the node, and l and r are branches." [45]
Mint: within the Hoon interpreter, the function (gate) ++mint contains the semantics of Hoon. That is, ++mint maps [type twig] to [type nock]. ++mint is found within ++ut. [46]
mul: multiplication
Natural hoon: a hoon which is not synthetic, e.g. which is not defined in terms of other hoons. See table below.
Nest: ++nest is the predicate function isSuperTypeOf, e.g. (nest a b) tests whether a is a supertype of b. Convention: we write (nest sut ref), e.g. 'sut' is the purported supertype and ref is the purported subtype. Nest is conservative in that it only returns True if it can prove that sut is a supertype of ref; so sometimes it may return False when sut is a supertype of ref, but it can't determine that. [47]
Nil: An odor whose only value is '~' (the atom 0).
Noun: an atom or a cell
Odor: a second type system on top of the 'real' type system that tells you whether an Atom should be interpreted as an integer, a string, etc. See also http://doc.urbit.org/doc/hoon/tut/1/, http://doc.urbit.org/doc/hoon/lan/odor/. [48] [49]
Payload: The tail of a Core. Data, possibly containing other Cores. I think a Payload is usually of the form [sample context], but i'm not sure [50].
Play: ++play is like ++mint except ++play only does type inference. [51] [52]
Product: output of a twig
Pull: "To access a wing or limb in a core is to pull it." "To pull %$ - the empty name - on a core is to kick it. To replace the sample with a in gate g then kick the gate, is to slam g with a." "(The archaic usage of "call" for slam is discouraged, but common. Please at least do not use "call" to mean pull.)" [53]
put: todo (seen in http://doc.urbit.org/doc/hoon/tut/5/ but not in http://doc.urbit.org/doc/hoon/lib/ , todo, tell them)
Reed: atom/cell tile; see table Tiles. [54]
Reef: "A stack of cores in which the core below is the context of the one above, all the way down to the innermost core whose payload is a simple constant (for hoon.hoon, always the Kelvin version)". "Every reef is a book". "A book whose payload is either another reef, or a cube, is a reef. Effectively, a reef is an entirely constant core." [55] [56]
Rune: two glyphs. The first glyph (character) in a Hoon indicates its category, see table "Rune categories" below. Runes can also be named using the Symbol syntax, using the Glyph (hoon glyph names) lookup table. Synonym: 'hoon'
Sample: the argument being passed to a function (gate). Also indicated by '+<', or 'glus'. [57]
slam: "To pull %$ - the empty name - on a core is to kick it. To replace the sample with a in gate g then kick the gate, is to slam g with a." "(The archaic usage of "call" for slam is discouraged, but common. Please at least do not use "call" to mean pull.)" "Slamming is a special case of slug, which pulls any limb on a tray after replacing the sample." [58]
snag: returns the list element found at a given list index.
span: an atom of URL-safe ASCII text (i.e. the odor @ta)
Slug: To Slug is to Pull "any limb on a tray after replacing the sample. To replace the sample with a on tray t, then pull m, is to slug t to m with a." [59]
Stem: The head of a kelp. Must be a leaf. [60]
Subject: input to a twig
Sut: short for 'subject type'
Symbol: A Hoon symbol. Syntax: the character % followed by a Term. [61]
synthetic hoon: a macro
Tape: bytestring. syntax: "this is a tape"; "concatenate tapes" . "using periods"; weld "or concatenate with" " weld"; "interpolate {{weld "wi" "th"}} double braces". [62]
Term: @tas. a string each of whose characters are one of (a) lowercase ASCII, (b) - except as the first or last character, or (c) 0-9 except as the first character. [63] (todo: perhaps he meant to say lowercase ASCII letters, not all of ASCII?). ++term produces the clam of Term. See also Symbol. [64] [65]
Tile: Syntactic sugar which is reduced to a twig (a normal AST) at compile time (the question of whether tiles are a special type of twig is tricky; on the one hand, twigs are said to be ASTs, and are said to contain tiles, and every subtree of an AST is an AST by definition; on the other hand, tiles are spoken of as different from twigs, and as being reduced to twigs; i suspect that formally speaking there are really two kinds of twigs, 'tile-less ASTs' and 'ASTs' (my terminology), and that tiles are ASTs but not tile-less ASTs, but that the word 'twig' is being used both for that i called tile-less AST and also for what i called AST). Tiles have to do with producing or identifying nouns of a type. The type that a given tile operates with respect to is called the Icon of the tile. There are 4 tile reductions: bunt (produce the default value of the icon type), clam (produce a gate which converts values of another type to values of the icon type), fish (test if a value is a member of the icon type), whip (converts values of another type to values of the icon type). See http://doc.urbit.org/doc/hoon/tut/5/. See also http://doc.urbit.org/doc/hoon/lan/tile/ . [66]
tile constructor: Todo. Hoons that construct tiles. Also called 'tile hoons'. [67]
Trap: "Any core with one arm named %$ is a trap" [68]
Tray: "A tray is any core whose payload has the form [sample context]." [69]
turn: transform. "++turn takes a list a and the clam of a noun b. ++turn produces a new list with all the values of a produced by b.". i think this like 'map' in other languages, except that the function we are mapping over the list is not b but the clam of a noun b? todo, not sure [70]
Type: type. See also Type Stem. See also http://doc.urbit.org/doc/hoon/lan/type/ . There is also Odors. To prettyprint the type of variable x in the interpreter, use ':type; x'. To print the internal type of variable x in the interpreter, use '-:!>(x)'.
Type Stem: one of %atom, %cell, %core, %cube, %face, %fork, %hold, or %bull. See also http://doc.urbit.org/doc/hoon/lan/type/ . [71] [72] [73]
Tusk: list of twigs [74]
Twig: (valid) AST, after reducing tiles. For validity conditions, see http://doc.urbit.org/doc/hoon/lan/twig/ .
Ut: within the Hoon interpreter, the gate ++ut contains ++mint. [75]
void: todo. can be produced by !!.
Weed: example tile; see table Tiles.
Wet: generic polymorphism. 'elm'. [76]
Whip: normalize. a tile reduction. see $@. [77]
Wing: a list of Limbs. a way to reference either a leg or an arm. [78]. Composed of Limbs. "A wing is a dot-separated list, reading outside to in from right to left. Each element is a limb." Limbs are joined using the period character as separator, and run from right to left; e.g. "c.b.a" means "start with a, find the value attached to field b, then within that value, find the value attached to field c". See also "name resolution" in http://doc.urbit.org/doc/hoon/tut/2/ . [79] [80]
Zinc: polymorphism with variance: covariant. [81]
0: True. Synonyms: &, .y. A Loobean (boolean) value.
0v: prefix for unsigned Base32 odor (@uv)
0w: prefix for unsigned Base64 odor (@uw)
1: False. Synonyms: |, .n. A Loobean (boolean) value.
==== Leading punctuation: | ('bar'; core construction) ====
|: False literal. Synonyms: |, .n. A Loobean (boolean) value.
|n: where n is an integer literal (actually, i'm not sure about this. Would a constant in a variable work too?). A type of axis limb. Indicates the tail of the list ocurring after the list element with index n. See also &n.
|%: core constructor syntax. "|% (barcen, or %brcn), followed by any number of arms ++ ... , followed by a terminator -- ... The arm is a symbol and a twig. The subject of the twig is the core.". "uses its own subject as the payload, creating the familiar reef effect as the stack of cores piles up" "produces a %gold core (cores, link). |% takes an associative array of names (++term) and expressions (++foot), each pair of which is called an arm. A dry, or %ash, arm is denoted with ++, a wet, or %elm, arm is denoted with +-. |% can take an arbitrary number of arms, but the arm array must be terminated with a --". [http://doc.urbit.org/doc/hoon/tut/4/] [http://doc.urbit.org/doc/hoon/lan/rune/#barcen]
|.: "create a |% with one arm, our %$" "produces a dry %gold trap (cores, link). |. takes a twig." [http://doc.urbit.org/doc/hoon/tut/3/] [http://doc.urbit.org/doc/hoon/lan/rune/#bardot]
|-: todo. Something about looping. "produces a dry %gold trap and kicks it (cores, link). |- takes a twig." [http://doc.urbit.org/doc/hoon/tut/3/] [http://doc.urbit.org/doc/hoon/lan/rune/#barhep]
|=: build a gate from a tile. "the tile in |= is always bunted to create the default sample.". |=(p q) "produces a dry %gold gate with arm twig q, sample [%bctr p].", where q is a twig, p is a tile, and bctr is compile-time bunt (i.e. the default of tile p). Often you see constructions like "|=(argument1Name=argument1Type argument2Name=argument2Type)". [http://doc.urbit.org/doc/hoon/tut/5/] [http://doc.urbit.org/doc/hoon/lan/rune/#bartis]
|*: like |= but uses generic rather than geometric polymorphism. |*(p q) "produces a vulcanized wet gate with arm twig q, sample [%bctr p], where p is a tile.". bctr is $*, which produces the bunt (default value) its argument as a compile-time constant. [http://doc.urbit.org/doc/hoon/tut/6/] [http://doc.urbit.org/doc/hoon/lan/rune/#bartar]
|_: |_(p q) means 'Use q as the subject $*(p), where $*(p) is the bunt of p computed as a compile-time constant'
$@: whip (normalize). $@(p q) normalizes wing p into tile q. [82] [83]
$: the empty symbol. "In practice, $ is used for “the nameless function or loop we’re inside.”". also, the leaf tile cell constructor. [84] [85]
$:: ($: p q) is a tile hoon that declares a tile autocons, where p and q are tiles [86]
$_: "produces the bunt (default value) for p." [89] [90]
$*: $*(p) "produces the bunt (default value) for (tile) p as a compile-time constant". "bunts tile p and folds it statically to a constant with %ktsg" todo. [91] [92]
$=: bark tile constructor. $=(p q) wraps the name p around the tile q. "a=* parses as [%bark %a %noun]." "This is another case where the tile syntax matches the twig syntax, but only in the irregular form. The twig equivalent of %bark is of course ^= (kettis, %ktts). But the tile is $=". -- [93] [94]
$|: reed tile construtor [http://doc.urbit.org/doc/hoon/lan/rune/#bucbar]
$&: bush tile constructor [95]
$%: kelp tile constructor (discriminated union). "takes a list of lines, which are labeled cases, closed by ==" [96] [97] [98] todo: there is a little typo ('labeeled') in http://doc.urbit.org/doc/hoon/lan/rune/#buccen
$?: fern tile constructor. "A non-empty list of cases; its icon is naturally a %fork. The programmer is responsible for ensuring that the cases are actually orthogonal (unlike with the structured forks, %bush, %kelp and %reed). A good general practice is to use ferns only with leaves." Has irregular form ?(). [99]. Todo: the irregular form of $? is listed in http://doc.urbit.org/doc/hoon/lan/rune/#bucwut , and in http://doc.urbit.org/doc/hoon/lan/tile/ , but not in http://doc.urbit.org/doc/hoon/lan/rune/irregular/ . Todo: http://doc.urbit.org/doc/hoon/lan/tile/ contains a broken link to http://doc.urbit.org/doc/hoon/lan/rune/#bcwt (should be http://doc.urbit.org/doc/hoon/lan/rune/#bucwut ). Todo: http://doc.urbit.org/doc/hoon/lan/rune/#bucwut says "See the discussion of tiles in chapter 9" but presumably now should say Chapter V.
$+: "a tile for a gate which accepts p and produces q". $+(p q) is equivalent to $_(|+(p _q)). [http://doc.urbit.org/doc/hoon/tut/6/] [http://doc.urbit.org/doc/hoon/lan/rune/#buclus]
$(): $ refers to "the nameless function or loop we’re inside", and this is a call to that function, e.g. a recursive call. Inside the parens is a list of pairs of parameter names and arguments, e.g. $(a b, c d) means "recursively call this function with b passed as argument 'a' and d passed as argument 'c'".
_ is not a hoon first character:
__: not a hoon. terminator for URL-safe cell syntax, e.g. [3 4] is ._3_4__
_: as a prefix, $_
%: prefix indicating a symbol, i.e. a 'cubical' constant, i.e. a constant whose type's extension is a singleton set consisting only of itself
%:: (%: p q): pull "%$ from the tray p with its sample set to q". [100]
%= "query with changes", or "resolve with changes". %=(p q) "evaluates p with the changes specified in q." . i think (but in this case i'm not very certain, in fact it think i probably got it wrong) "%= query tram" means "resolve the wing 'query' (call the result of this 'result'). 'tram' contains a list of pairs of the form 'query2 replace'. For each pair in 'tram', resolve the wing 'query2' as applied to 'result', and replace that with 'replace'. Finally, evaluation 'result' after applying all changes.", see [101] [102]. TODO: the reference manual entry at http://doc.urbit.org/doc/hoon/lan/rune/#cen says "See the explanation in Chapter 7." but i can't find a mention of '%=' in http://doc.urbit.org/doc/hoon/tut/7/ . "If q is empty, %= just pulls wing p with no changes. Otherwise, we get p with the wings in q set to the provided twigs". Irregular form of '%=(a b)' is 'a(b)'. [103]. [104]
%$: the symbol '$' (i think) [105]
%-: todo. something to do with function calling? %-(p q) "slams the gate p with [%cltr q]", where q is a list of twigs (tusk). [106] [107]
%~: %~(p q r) "pulls p from the tray q with its sample set to r". Irregular syntax ~(p q r). [108]
%*: (%* p q r) "pull the wing p from a tray q with changes r" [109]
%&: todo. http://doc.urbit.org/doc/hoon/lan/rune/#cenpam is not defined in the rune reference, although it appears in expansions given there. Tell them. Perhaps this is just the literal '&', the same as &$ is the literal '$'? Or maybe, because i see it being used like '[%& 2]', it means to select index 2 from the current subject?
:-: cell constructor. :-(a b) means [a b]. [110] [111]
:~: produces a null-terminated tuple. irregular syntax: ~[]. [112]
:_: reversed cell constructor. ':_(p q)' produces '[q p]'.
:*: produce a tuple (while also doing some black magic related to string interpolation and %clzz. [113])
:+: quoting. (:+ p q r) produces the cell [p q r]. [114]
, is not a hoon first character:
,: irregular form of $,. So ,p is short for $,p. $,p is a rune that produces a normalizing gate (clam) for p. [115]
" is not a hoon first character:
"": tape (bytestring) delimiters
.: Between strings, string concatenation. Between limbs, in a wing, concatenation of limbs into a wing. As a limb (axis), like Nock's +1, that is, a reference to the location indicated by the wing up to that point, without evaluating the function, if any; for example, see ..$. [116]. Convenience separator between triples of digits when prettyprinting integers. Convenience separator between sets of digits when prettyprinting IP addresses. Prefix for IP addresses. Prefix for floating point. Perhaps this is also for Nock '/' selection into cells (seeing the curious use of .6 in [117]?.
.: todo: i don't understand how . is used in ++weld in http://doc.urbit.org/doc/hoon/tut/6/
.~: prefix for double-precision floating point. not a hoon.
.~~: prefix for triple-precision floating point
.~~~: prefix for quad-precision floating point
._: not a hoon. prefix for URL-safe cell syntax, also separator, e.g. [3 4] is ._3_4__
..$: "refers to the nameless function we’re inside, without actually calling it.". http://web.archive.org/web/20131014210126/http://www.urbit.org/2013/08/22/Chapter-6-hoons.html
.y: True literal. Synonyms: &, .y. A Loobean (boolean) value.
.n: False literal. Synonyms: |, .n. A Loobean (boolean) value.
..$:
.+: increment an atom. Nock 4. [118]
.=: equality predicate. Nock 5. [119]
.^: "nock operator 11, which in virtual userspace nock (mock) loads a file from the global namespace" [120]
.*: "calculates the nock of subject p, formula q." Like Nock 2. [121]
.?: test if cell or atom. "if the noun is a cell, it returns the loobean & (true); if the noun is an atom, it returns the loobean
| (false).". Nock 3. [122] |
< and > are not hoon first characters:
<>: matched delimiters surrounding prettyprint syntax for a core. not a hoon.
<: Part of +-<> axis limb syntax to select via chains of head/tail. [123]
>: Part of +-<> axis limb syntax to select via chains of head/tail. [124]
-: Prefix for negative signed integer literals. Also a digit in base64 odor (@uw). Also 'head', part of +-<> axis limb syntax to select via chains of head/tail. If applied to a Core, selects the Battery; if applied to a Gate, selects the formula (todo is this correct?). What else? [125] [126] [127]
--: Prefix for positive signed integer literals. Also, terminator for core constructor syntax (see |%). not a hoon.
-.: 'head'. todo how is this different from '-', above? Usage of +-<> axis limb syntax to select via chains of head/tail. [128]
^: cell of nouns, axil constructor syntax. as a prefix in a limb, ^ means 'skip the first match we find and return the second', ^^ means 'skip the first two matches we find and return the third', etc. E.g. i think ^$ means 'the function or loop enclosing the function or loop that we are inside'. [129]
^$: see '^'. not a hoon.
^^$: see ^
^.: "(^. p q) casts q to the type of (p q)" e.g. '^.(p q)' is equivalent to '^+((a b) b'. [130] [131]
^-: type cast to icon of tile. "casts q to ~(bunt al p), ie, the icon of p." "a purely static operation with no runtime effect whatsoever.". Often you see the following at the beginning of a gate: a line "++ gatename", followed by a line "
| [gateInputArgument1Name=gateInputArgument1Type gateInputArgument2Name=gateInputArgument2Type]" to give what the input arguments are, and their types, followed by a line "^- [outputArgument1Name=outputArgument1Type outputArgument2Name=outputArgument2Type]" to give what the output arguments are, and their types. [132] [133] |
|---|
^=: variable assignment. ^=(b 0) means 'b=0'. ^=(p q) "wraps q in the toga p" [134] [135] . Note: [136] says this has irregular form p=q, but [137] says it has no irregular form. TODO: see if i am mistaken, and tell them if not.
^~: "tells the compiler to compute a constant expression at compile time" "tries to execute p statically at compile time; if this fails, p remains dynamic." [138] [139]
^|: convert a gold core into an iron core. [http://doc.urbit.org/doc/hoon/tut/6/] [http://doc.urbit.org/doc/hoon/lan/rune/#ketbar]
^&: convert a gold core into a zinc core. [140] [141]
^?: convert a gold core into a lead core. [142] [143]
^+: type cast. "casts the product of q to the type of p, verifying that it contains the type of q." [144]