Glossary ======== ### arm A key-value pair of a name ([++term]()) to an expression ([++foot()]). Used primarily in [core]() construction. Arms can contain either functions or data. You can think of them like named properties inside an object. ------------------------------------------------------------------------ ### atom An atom is a natural number. More here..? ------------------------------------------------------------------------ ### axil An `[%axil p=base]` is a simple [`++tile`]() for a few basic icons: an atom of any odor, a noun (`*`) , a cell of nouns (`^`), a loobean (`?`), and null (`~`). ------------------------------------------------------------------------ ### battery [Cores], at the most basic level, are of the structure [battery payload]. The battery consists of the code contained within a core. ------------------------------------------------------------------------ ### `%bark` A `[%bark p=term q=tile]` is a [`++tile`]() with a name wrapped around it. Its [icon]() is a [`++face`](). The rune associated with a [`%bark`]() is [`$=`](). ------------------------------------------------------------------------ ### bunt The bunt of a [`++tile`]() produces a [`++twig`]() that creates a blank default example its [icon](). Bunting is like explicitly asking for the default value of a type. Unlike in other languages, this always exists in Hoon. See also [`$*`](). ------------------------------------------------------------------------ ### `%bush` a [`[%bush p=tile q=tile]`]() is a [`++tile`]() in which there are two kinds of [nouns](): cells whose head is a cell (`++tile` p) and cells whose head is an atom (`++tile` q). Its default value is the value of `q`, and its icon is a [`++fork`]() ------------------------------------------------------------------------ ### cell A cell is an ordered pair of nouns. ------------------------------------------------------------------------ ### clam The clam of a [`++tile`]() is a [gate]() that accepts an arbitrary [noun]() and always produces a member of the [icon]() of the `++tile`. If the gate is passed a [sample]() that is a member of the icon, it will produce that sample. If the gate is passed a noun outside of the domain of the icon, it will produced the [bunt]() of the icon. You can think of a clam as a validator function for an icon. To clam a `++tile` is to produce its clam. See also: [`$,`](). SEE ALSO!! ------------------------------------------------------------------------ ### context In [gate]() construction, an arm is pulled from a [core]() and pushed onto the subject creating a structure of [formula [sample context]], where the context is the previous subject, commonly a core. In Hoon, the whole kernel is typically included in your subject, so you can think of context in hoon in a similar way to context in the traditional functional programming sense. ------------------------------------------------------------------------ ### cons Cell constructor, similar to [cons in other functional languages](http://en.wikipedia.org/wiki/Cons). Constructs a cell containing two [`++twigs`]() into a twig that produces a cell of the results of the two original sub-twigs. ------------------------------------------------------------------------ ### core At the Nock level, a core is any [subject]() that contains both code and data, named battery and payload respectively. At the Hoon level, a core is very similar to an object with named properties that can be either functions or data. For more information, see the [`|` rune section]() of the Hoon library. ------------------------------------------------------------------------ ### `%cube` ------------------------------------------------------------------------ ### door A door is a [core]() with a sample. Door are used.../you can think of doors... ------------------------------------------------------------------------ ### dry In a dry computation, typechecking occurs at compile-time to ensure that all inputs match its [sample]() [++tile](). The formal term for dry is `%ash`. ------------------------------------------------------------------------ ### engine Engines are [core]()s that contain several [arm]()s that each perform one of a related set of operations on the core's sample. For example, there is a container engine for all of the set operations. You can think of engines as objects with methods that modify its data. ------------------------------------------------------------------------ ### `%face` ------------------------------------------------------------------------ ### fern A `[%fern p=[i=tile t=(list tile)]]` is a [`++tile`]() for 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 `%fork`s, [`%bush`](), [`%kelp`]() and [`%reed`]). ------------------------------------------------------------------------ ### fishing To fish is to test if a [noun]() matches a specific `++tile`, using the natural rune [`?=`](). Some languages call fishing "pattern matching". ------------------------------------------------------------------------ ### frond A frond is a case of a [kelp](), which is a [discriminated (or tagged) union](http://en.wikipedia.org/wiki/Tagged_union). ------------------------------------------------------------------------ ### gate A [gate]() is a [core]() with one arm [`$`]() with a [payload]() that is a cell of the form [[sample]() [context]()]. Gates are the closest thing Hoon has to functions in the traditional sense. ------------------------------------------------------------------------ ### `%gold` ------------------------------------------------------------------------ ### herb An `[%herb p=twig]`.... ------------------------------------------------------------------------ ### icon The icon of a [`++tile`]() is the type associated with that `++tile`. A `++tile` is a convenient way of specifying a type, which is its icon. `++tile`s are used in a similar way to [type signatures]() for their icons. ------------------------------------------------------------------------ ### `%iron` `%iron` is a variance type for [cores]() where their [sample]()s cannot be read. You can think of can be thought of as similar to a private function. Not quite sure about this one. ------------------------------------------------------------------------ ### `%kelp` a [`%kelp p=[i=line t=(list line)]`] is a [discriminated, or tagged, union](http://en.wikipedia.org/wiki/Tagged_union). In Hoon, the head, which is called the stem, must be a [`%leaf`](). The tail, which can be anything, is the bulb. Cases of a kelp are known as [fronds](). ------------------------------------------------------------------------ ### kick To pull the empty name `$` on a core is to kick it. You can think of kicking like calling a function with its default arguments. ------------------------------------------------------------------------ ### noun A noun is an [atom]() or a [cell](). Everything in Hoon is a noun. ------------------------------------------------------------------------ ### `%$` buc `%$`, or `$` for short, is the empty name in Hoon. ------------------------------------------------------------------------ ### leg If the result of [pulling]() something from `x` is a subtree, then it is a leg. More here? Existing doc isn't quite clear here.. ------------------------------------------------------------------------ ### `%lead` ------------------------------------------------------------------------ ### `%leaf` A `%leaf` is a [`++tile`]() consisting of an atomic constant of value `q` and odor `p`. Its icon is a [`%cube`](). The syntax for a leaf is the same as the syntax for a [`++twig`](), except that % is never required to generate a cube. For instance, as a twig, 7 has a type of [%atom %ud]; %7 has a type of [%cube 7 [%atom %ud]]. But the icon of the leaf 7 is, again, [%cube 7 [%atom %ud]]. Copied the bottom half from existing doc. Not sure about this one... ------------------------------------------------------------------------ ### loobean ------------------------------------------------------------------------ ### payload [Cores](), at the most basic level, are of the structure [battery payload]. The payload consists of the data contained within a core. You can think of the payload as similar to the data of an object. ------------------------------------------------------------------------ ### pull To access a [wing]() or [limb]() in a [core]() is to pull it. For instance, when we write `a.b.x` (a within b from x), we are pulling the wing `a.b` from `x`. ------------------------------------------------------------------------ ### `%reed` A `[%reed p=tile q=tile]` is a [`++tile`]() whose [icon]() contains two kinds of nouns: atoms of `++tile` `p` and cells of `++tile` `q`. The rune associated with reeds is [`$|`](). ------------------------------------------------------------------------ ### sample In [gate]() construction, an arm is pulled from a [core]() and pushed onto the subject creating a structure of [formula [sample context]], where the sample represents the gate's inputs. All gates are constructed with a default sample value. Thus, when we call a gate with arguments, we are actually replacing its sample. ------------------------------------------------------------------------ ### slam To pull the empty name `$` on a [gate]() `g` with its [sample]() replaced by a given input `a` is to slam `g` with `a`. You can think of slamming like passing input parameters to a function that's being called. ------------------------------------------------------------------------ ### subject All Hoon expressions a parsed into abstract syntax trees, which in Hoon are called [++twig]()s. Twigs are [nouns]() that are converted into Nock expressions, which are all of the basic form [subject formula], where the subject is the data and the formula is the program. Thus, in both Hoon and Nock, subject can refer to any piece of data that is being operated on by a formula. ------------------------------------------------------------------------ ### `++tile` A `++tile` is a convenient way of specifying a type, which is its icon. `++tile`s are used in a similar way to [type signatures]() for their icons. SOMETHING ABOUT THE DIFFERENCE BETWEEN TWIG AND TILE AUTOCONS. ------------------------------------------------------------------------ ### weed A `[%weed p=twig]` ------------------------------------------------------------------------ ### wet In wet computations, the product type is checked to be the same as the input type, rather than the [sample]() [tile](). The formal term for wet is `%elm`. ------------------------------------------------------------------------ ### wing A wing is a list of limbs. For example, when we [pull] `a.b` from `x`, `a.b` is a wing. `a` and `b` individually are both [limbs](). ------------------------------------------------------------------------