# Irregular forms

While Hoon has a large amount of sugar syntax, some forms that may look irregular are actually regular wing syntax or another language feature, such as `,`.

When in doubt, you can use the [`!,` zapcom](https://docs.urbit.org/rune/zap#zapcom) rune to determine the AST to which Hoon parses an expression.

```
> !,(*hoon c.b.a)
[%wing p=~[%c %b %a]]
```

## Quick Lookup of Irregular Forms <a href="#quick-lookup-of-irregular-forms" id="quick-lookup-of-irregular-forms"></a>

| Form                 | Regular Form                                                                                                                                                             |
| -------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `_foo`               | [`$_`](https://docs.urbit.org/rune/buc#buccab), normalizes to an example                                                                                                 |
| `foo@bar`            | [`$@`](https://docs.urbit.org/rune/buc#bucpat), normalizes to a type union of an atom and a cell                                                                         |
| `foo=bar`            | [`$=`](https://docs.urbit.org/rune/buc#buctis), wraps a face around a value                                                                                              |
| `?(%foo %bar %baz)`  | [`$?`](https://docs.urbit.org/rune/buc#bucwut), forms a type union                                                                                                       |
| `(foo a b c)`        | [`%:`](https://docs.urbit.org/rune/cen#cencol), calls a gate with *n* arguments                                                                                          |
| `~(arm core arg)`    | [`%~`](https://docs.urbit.org/rune/cen#censig), pulls an arm in a door                                                                                                   |
| `foo(a 1, b 2, c 3)` | [`%=`](https://docs.urbit.org/rune/cen#centis), resolve a wing with changes                                                                                              |
| `[foo bar]`          | [`:-`](https://docs.urbit.org/rune/col#colhep), constructs a cell                                                                                                        |
| `[a b c]`            | [`:*`](https://docs.urbit.org/rune/col#coltar) or [`$:`](https://docs.urbit.org/rune/buc#buccol), constructs *n*-tuple in normal mode or its structure in structure mode |
| `~[a b c]`           | [`:~`](https://docs.urbit.org/rune/col#colsig), constructs null-terminated list                                                                                          |
| `+(42)`              | [`.+`](https://docs.urbit.org/rune/dot#dotlus), increments with Nock 4                                                                                                   |
| `=(a b)`             | [`.=`](https://docs.urbit.org/rune/dot#dottis), tests for equality with Nock 5                                                                                           |
| `` `foo`bar ``       | [`^-`](https://docs.urbit.org/rune/ket#kethep), typecasts by explicit type label                                                                                         |
| `=foo` or `foo=bar`  | [`^=`](https://docs.urbit.org/rune/ket#kettis), binds name to value                                                                                                      |
| `*foo`               | [`^*`](https://docs.urbit.org/rune/ket#kettar), bunts (produces default mold value)                                                                                      |
| `,foo`               | [`^:`](https://docs.urbit.org/rune/ket#ketcol), produces “factory” gate for type                                                                                         |
| `:(fun a b c d)`     | [`;:`](https://docs.urbit.org/rune/mic#miccol), calls binary function as *n*-ary function                                                                                |
| `foo:bar`            | [`=<`](https://docs.urbit.org/rune/tis#tisgal), composes two expressions, inverted                                                                                       |
| `\|(foo bar baz)`    | [`?\|`](https://docs.urbit.org/rune/wut#wutbar), logical OR (loobean)                                                                                                    |
| `&(foo bar baz)`     | [`?&`](https://docs.urbit.org/rune/wut#wutpam), logical AND (loobean)                                                                                                    |
| `!foo`               | [`?!`](https://docs.urbit.org/rune/wut#wutzap), logical NOT (loobean)                                                                                                    |

\
\\

**Reading guide**

Headings contain runes, phonetics and tokens. Description contains a link to the docs and a short description of the rune. Both regular and irregular forms are given.

Want to `Ctrl+F` to find out the meaning of something weird you saw? Search for "\symbol". ie `\?` or `\=`. It'll show you to the irregular forms that uses that symbol.

## `.` dot (nock) <a href="#dot-nock" id="dot-nock"></a>

Anything Nock can do, Hoon can do also.

### `.+` dotlus <a href="#dotlus" id="dotlus"></a>

[docs](https://docs.urbit.org/rune/dot#dotlus) \\+

`[%dtls p=atom]`: increment an atom with Nock 4.

Regular: `.+(p)`

Irregular: `+(p)`

### `.=` dottis <a href="#dottis" id="dottis"></a>

[docs](https://docs.urbit.org/rune/dot#dottis) \\=

`[%dtts p=hoon q=hoon]`: test for equality with Nock 5.

Regular: `.=(p q)`

Irregular: `=(p q)`

## `;` mic (make) <a href="#mic-make" id="mic-make"></a>

Miscellaneous useful macros.

### `;:` miccol <a href="#miccol" id="miccol"></a>

[docs](https://docs.urbit.org/rune/mic#miccol) \\:

`[%mccl p=hoon q=(list hoon)]`: call a binary function as an n-ary function.

Regular: `;:(p q)`

Irregular: `:(p q)`

## `:` col (cells) <a href="#col-cells" id="col-cells"></a>

The cell runes.

### `:-` colhep <a href="#colhep" id="colhep"></a>

[docs](https://docs.urbit.org/rune/col#colhep) \\\[\\]\\^\\/\\+\\\`\\\~

`[%clhp p=hoon q=hoon]`: construct a cell (2-tuple).

Regular: `:-(p q)`

Irregular:

```
  [a b]   ==>   :-(a b)
[a b c]   ==>   [a [b c]]
  a^b^c   ==>   [a b c]
    a/b   ==>   [%a b]
    a+b   ==>   [%a b]
     `a   ==>   [~ a]
 ~[a b]   ==>   [a b ~]
  [a b]~  ==>   [[a b] ~]
```

## `=` tis (flow) <a href="#tis-flow" id="tis-flow"></a>

Flow runes change the subject. All non-flow runes (except cores) pass the subject down unchanged.

### `=<` tisgal <a href="#tisgal" id="tisgal"></a>

[docs](https://docs.urbit.org/rune/tis#tisgal) \\:

`[%tsgl p=hoon q=hoon]`: compose two hoons, inverted.

Regular: `=<(p q)`

Irregular: `p:q`

## `|` bar (core) <a href="#bar-core" id="bar-core"></a>

[docs](https://docs.urbit.org/hoon/rune/bar) \\$

Core runes are flow hoon.

Technically not irregular syntax, but worth mentioning.

* `|= bartis`
* `|. bardot`
* `|- barhep`
* `|* bartar`

The above runes produce a core with a single arm, named `$` ("buc"). We can recompute this arm with changes, useful for recursion among other things. Commonly used with the irregular syntax for `%=`, `:make`, like so: `$()`.

## `%` cen (call) <a href="#cen-call" id="cen-call"></a>

The invocation family of runes.

### `%=` centis <a href="#centis" id="centis"></a>

[docs](https://docs.urbit.org/rune/cen#centis) \\(\\)

`[%cnts p=wing q=(list (pair wing hoon))]`: take a wing with changes.

Regular: `%=(p a 1)`

Irregular: `p(a 1)`

### `%~` censig <a href="#censig" id="censig"></a>

[docs](https://docs.urbit.org/rune/cen#censig) \\\~

`[%cnsg p=wing q=hoon r=hoon]`: call with multi-armed door.

Regular: `%~(p q r)`

Irregular: `~(p q r)`

### `%-` cenhep <a href="#cenhep" id="cenhep"></a>

[docs](https://docs.urbit.org/rune/cen#cenhep) \\(\\)

`[%cnhp p=hoon q=hoon]`: call a gate (function).

Regular: `%-(p q)`

Irregular: `(p q)`

Note: `(p)` becomes `$:p` (`=<($ p)`), which behaves as you would expect (function call without arguments).

## `$` buc (mold) <a href="#buc-mold" id="buc-mold"></a>

A mold is a gate (function) that helps us build simple and rigorous data structures.

### `$?` bucwut <a href="#bucwut" id="bucwut"></a>

[docs](https://docs.urbit.org/rune/buc#bucwut) \\?

`[%bcwt p=(list model)]`: mold which normalizes a general union.

Regular: `$?(p)`

Irregular: `?(p)`

### `$_` buccab <a href="#buccab" id="buccab"></a>

[docs](https://docs.urbit.org/rune/buc#buccab) \\\_

`[%bccb p=value]`: mold which normalizes to an example.

Regular: `$_(p)`

Irregular: `_p`

### `$=` buctis <a href="#buctis" id="buctis"></a>

[docs](https://docs.urbit.org/rune/buc#buctis) \\=

`[%bcts p=skin q=spec]`: wraps a face around a structure.

Regular:

```
$=(p q)
```

Irregular:

```
 p=q   ==>   $=(p q)
  =q   ==>   q=q
=p=q   ==>   p-q=q
```

## `?` wut (test) <a href="#wut-test" id="wut-test"></a>

Hoon has the usual branches and logical tests.

### `?!` wutzap <a href="#wutzap" id="wutzap"></a>

[docs](https://docs.urbit.org/rune/wut#wutzap) \\!

`[%wtzp p=hoon]`: logical not.

Regular: `?!(p)`

Irregular: `!(p)`

### `?&` wutpam <a href="#wutpam" id="wutpam"></a>

[docs](https://docs.urbit.org/rune/wut#wutpam) \\&

`[%wtpm p=(list hoon)]`: logical AND.

Regular: `?&(p)`

Irregular: `&(p)`

### `?|` wutbar <a href="#wutbar" id="wutbar"></a>

[docs](https://docs.urbit.org/rune/wut#wutbar) \\|

`[%wtbr p=(list hoon)]`: logical OR.

Regular: `?|(p)`

Irregular: `|(p)`

## `^` ket (cast) <a href="#ket-cast" id="ket-cast"></a>

Lets us adjust types without violating type constraints.

### `^:` ketcol <a href="#ketcol" id="ketcol"></a>

[docs](https://docs.urbit.org/rune/ket#ketcol) \\,

`[%ktcl p=spec]`: mold gate for type `.p`.

Regular: `^:(p)`

Irregular: `,p`

### `^-` kethep <a href="#kethep" id="kethep"></a>

[docs](https://docs.urbit.org/rune/ket#kethep) \\\`

`[%kthp p=model q=value]`: typecast by mold.

Regular: `^-(p q)`

Irregular: `` `p`q ``

### `^*` kettar <a href="#kettar" id="kettar"></a>

[docs](https://docs.urbit.org/rune/ket#kettar) \\\*

`[%kttr p=spec]`: produce bunt value of mold.

Regular: `^*(p)`

Irregular: `*p`

### `^=` kettis <a href="#kettis" id="kettis"></a>

[docs](https://docs.urbit.org/rune/ket#kettis) \\=

`[%ktts p=toga q=value]`: name a value.

Regular: `^=(p q)`

Irregular: `p=q`

## Miscellaneous <a href="#miscellaneous" id="miscellaneous"></a>

### Trivial molds <a href="#trivial-molds" id="trivial-molds"></a>

\\\*\\@\\^\\?\\\~

* `*` noun.
* `@` atom.
* `^` cell.
* `?` loobean.
* `~` null.

### Values <a href="#values" id="values"></a>

\\\~\\&\\|\\%

* `~` null.
* `&` loobean true.
* `|` loobean false.
* `%a` constant `a`, where `a` can be an ((ir)regularly defined) atom or a symbol.

See [%sand](https://docs.urbit.org/rune/constants#warm) for other irregular definitions of atoms.

### List addressing <a href="#list-addressing" id="list-addressing"></a>

\\&\\|

* `&n` *n*th element of a list.
* `|n` tail of list after *n*th element (i.e. *n* is the head).

### Limbs <a href="#limbs" id="limbs"></a>

[docs](https://docs.urbit.org/hoon/limbs/limb) \\+\\.\\^\\-

`[%limb p=(each @ud [p=@ud q=@tas])]`: attribute of subject.

* `+15` is slot 15
* `.` is the whole subject (slot 1)
* `^a` is the `.a` "of a higher scope", i.e. "resolve variable `.a`, ignoring the first one found".
* `^^p` even higher, and so on.

'Lark' syntax for slots / tree addressing:

```
+1
+2 -
+3 +
+4 -<
+5 ->
+6 +<
+7 +>
+8 -<-
...
```

### Wings <a href="#wings" id="wings"></a>

[docs](https://docs.urbit.org/hoon/limbs/wing) \\.

`[%wing p=(list limb)]`; a limb search path.

`a.b` finds limb `.a` within limb `.b` ("variable" `.a` within "variable" `.b`).

### Printing stuff <a href="#printing-stuff" id="printing-stuff"></a>

\\<\\>

* `>a b c<` produces a [tank](https://docs.urbit.org/stdlib/2q#tank) of the output of the contents (wrapped in cell if more than one item), formatted in pretty-print.

  ```hoon
  > >1 2 3<
  [%rose p=[p=" " q="[" r="]"] q=~[[%leaf p="1"] [%leaf p="2"] [%leaf p="3"]]]
  ```
* `<a b c>` produces a [tape](https://docs.urbit.org/stdlib/2q#tape) of the tank above (i.e. `<1 2 3>` is same as `~(ram re >1 2 3<)`).

  ```hoon
  > <1 2 3>
  "[1 2 3]"

  > <`(list @)`~[1 2 3]>
  "~[1 2 3]"
  ```

### `,` com <a href="#com" id="com"></a>

`,` can serve in several capacities in Hoon programs:

#### `,` as syntactic sugar

Sugar for the `^:` ketcol or `$;` bucmic runes, toggling structure and value mode. (Toggling out of structure mode is uncommon.)

```
> !,(*hoon ,[@t @t])
[ %ktcl
  p=[%bccl p=[i=[%base p=[%atom p=~.t]] t=[i=[%base p=[%atom p=~.t]] t=~]]]
]

> !,(*hoon |=(a=,[@t @t] b))
[ %brts
    p
  [ %bcts
    p=term=%a
      q
    [ %bcmc
      p=[%cltr p=[i=[%base p=[%atom p=~.t]] t=[i=[%base p=[%atom p=~.t]] t=~]]]
    ]
  ]
  q=[%cnts p=~[[%.y p=2] %a] q=~]
]

> !,(*hoon ,,[@t @t])
[ %ktcl
    p
  [ %bcmc
    p=[%cltr p=[i=[%base p=[%atom p=~.t]] t=[i=[%base p=[%atom p=~.t]] t=~]]]
  ]
]
```

(`$;` bucmic, or manual value mode, allows the use of value mode syntax to construct a mold. Concretely, it lets you build a mold out of `$hoon` instead of out of `$spec`. It is not commonly used.)

From value mode to structure mode:

```hoon
[%ktcl p=spec]
```

From structure mode to value mode:

```hoon
[%bcmc p=hoon]
```

#### `,` as wing syntax for stripping a face

For example, a line similar to the following is present in many Gall agents receiving HTTP requests via Eyre:

```
=/  ,request-line:server  (parse-request-line:server url.request.inbound-request)
```

This `,` lets you avoid using an outer face when handling the result.

```
> =/  ,@ud  1
  -
1
> !,(*hoon =/(,@ud 1 -))
[ %tsfs
  p=[%spec spec=[%bcmc p=[%base p=[%atom p=~.ud]]] skin=[%base base=%noun]]
  q=[%sand p=%ud q=1]
  r=[%cnts p=~[[%.y p=2]] q=~]
]
```

#### `,` as separator

For example, between pairs in an inline `%=` centis expression.

```hoon
$(i +(i), j (dec j))
```