+++
title = "3g: Molds and Mold-Builders"
weight = 27
template = "doc.html"
+++

## `+$coin`

Noun-literal syntax cases

Syntax cases for nouns-literal: atoms, jammed nouns, and nestable tuples. Parsed
and printed using `++so` and `++co` cores.

#### Source

```hoon
+$  coin  $~  [%$ %ud 0]
          $%  [%$ p=dime]
              [%blob p=*]
              [%many p=(list coin)]
```

#### Examples

```
> `coin`(need (slay '~s1'))
[%$ p=[p=~.dr q=18.446.744.073.709.551.616]]

> `coin`(need (slay '0x2b59'))
[%$ p=[p=~.ux q=11.097]]

> ~(rend co [%many ~[[%$ %ud 1] [%$ %tas 'a'] [%$ %s -2]]])
"._1_a_-2__"
> ._1_a_-2__
[1 %a -2]

> `@uv`(jam [3 4])
0v2cd1

> (slay '~02cd1')
[~ u=[%blob p=[3 4]]]

> ~02cd1
[3 4]
```

---

## `+$dime`

Aura-atom pair

Used in `++coin`. Convenience methods
[`++scot`](/docs/hoon/reference/stdlib/4m#scot) and
[`++scow`](/docs/hoon/reference/stdlib/4m#scow) print dimes as `++cord` and
`++tape`, respectively. [`++slat`](/docs/hoon/reference/stdlib/4m#slat),
[`++slav`](/docs/hoon/reference/stdlib/4m#slav), and
[`++slaw`](/docs/hoon/reference/stdlib/4m#slaw) are used to parse atoms of
specific auras.

#### Source

```hoon
+$  dime  [p=@ta q=@]
```

#### Examples

```
> +>:(slay '0x123')
p=[p=~.ux q=291]
```

---

## `+$edge`

Parsing location metadata. Parsing location input `p` and optional result `p.q` and parsing continuation `q.q`.

#### Source

```hoon
+$  edge  [p=hair q=(unit [p=* q=nail])]
```

#### Examples

```
> *edge
[p=[p=0 q=0] q=~]

> (tall:vast [1 1] "a b")
[p=[p=1 q=3] q=[~ u=[p=[%wing p=~[%a]] q=[p=[p=1 q=2] q=" b"]]]]
```

#### Discussion

See also: [$rule](#rule).

---

## `+$hair`

Parsing line and column

A pair of two `@ud` used in parsing indicating line and column number.

#### Source

```hoon
+$  hair  [p=@ud q=@ud]
```

#### Examples

```
> *hair
[p=0 q=0]

> `hair`[1 1]                                               :: parsing starts at [1 1] as a convention.
[p=1 q=1]

> ((plus ace) [1 1] "   --")
[p=[p=1 q=4] q=[~ u=[p=[~~. "  "] q=[p=[p=1 q=4] q="--"]]]]

> `hair`p:((plus ace) [1 1] "   --")
[p=1 q=4]
```

---

## `++like`

Generic edge

Generates an [`$edge`](#edge) with a parsed result set to a specific type.

#### Source

```hoon
++  like  |*  a=$-(* *)
          |:  b=`*`[(hair) ~]
          :-  p=(hair -.b)
          ^=  q
          ?@  +.b  ~
          :-  ~
          u=[p=(a +>-.b) q=[p=(hair -.b) q=(tape +.b)]]
```

#### Examples

```
> *(like char)
[p=[p=0 q=0] q=~]

> (ace [1 1] " a")
[p=[p=1 q=2] q=[~ u=[p=' ' q=[p=[p=1 q=2] q="a"]]]]

> `(like char)`(ace [1 1] " a")
[p=[p=1 q=2] q=[~ [p=~~. q=[p=[p=1 q=2] q="a"]]]]

> `(like ,@)`(ace [1 1] " a")
[p=[p=1 q=2] q=[~ u=[p=32 q=[p=[p=1 q=2] q="a"]]]]
```

---

## `+$nail`

Location, remainder of parsed text

Indicates parsing position `p`, and remaining text to be parsed `q`.

#### Source

```hoon
+$  nail  [p=hair q=tape]
```

#### Examples

```
> +<:;~(plug cab cab)
c=[p=[p=0 q=0] q=""]
```

---

## `+$pint`

Parsing range

A `$pint` is a pair of [`$hair`](#hair), indicating from `p` to `q`. Mostly used for
stack traces.

#### Source

```hoon
+$  pint  [p=[p=@ q=@] q=[p=@ q=@]]
```

#### Examples

```
> !:(!!)                                                    :: !! always produces a crash
/~zod/base/~2014.9.20..01.22.04..52e3/:<[1 4].[1 6]>

> `pint`[[1 4] [1 6]]
[p=[p=1 q=4] q=[p=1 q=6]]
```

---

## `+$rule`

Parsing rule

An empty parsing rule, but used to check that parsing rules match this with `_`.

#### Source

```hoon
+$  rule  _|:($:nail $:edge)
```

#### Examples

```
> ([|=(a=nail [p.a ~ u=['a' a]])]:|6 [1 1] "hi")
[[p=1 q=1] ~ u=['a' p=[p=1 q=1] q="hi"]]
```

---

## `+$spot`

Stack trace line

The stack trace that is printed after crashing.

#### Source

```hoon
    ++  spot  [p=path q=pint]
```

#### Examples

```
> !:  !!                                                    :: !! always produces a crash
/~zod/base/~2018.8.8..21.42.40..7852:<[1 5].[1 7]>
! exit
```

---

## `+$tone`

Nock result, error report

Produces either success (`%0`), a block with list of requests blocked on (`%1`),
or failure with an error report (`%2`).

#### Source

```hoon
+$  tone  $%  [%0 product=*]
              [%1 block=*]
              [%2 trace=(list [@ta *])]
          ==
```

#### Examples

```
> (mink [[20 21] 0 3] $~)
[%0 product=21]
```

```
> (mink [[1 2] !=(!:(+(.)))] ,~)
[%2 trace=~[[~.spot [[1.685.027.454 1.702.060.386 20.241.306.789.072.368.304.935.424.358.627.395.315.601.229.215.400.789.787.861.332.606 0] [1 20] 1 24]]]]
```

---

## `+$toon`

Nock result, stack trace

Produces either success (`%0`), a block with list of requests blocked on (`%1`),
or failure with a stack trace (`%2`).

#### Source

```hoon
+$  toon  $%  [%0 p=*]              ::  success
              [%1 p=*]              ::  block
              [%2 p=(list tank)]    ::  stack trace
          ==                        ::
```

#### Examples

```
> (mock [[20 21] 0 3] $~)
[%0 p=21]
```

```
> (mock [[1 2] !=(!:(+(.)))] ,~)
[ %2
    p
  ~[
    [ %rose
      p=[p=":" q="" r=""]
      q=[i=[%rose p=[p="/" q="/" r=""] q=[i=[%leaf p="~zod"] t=[i=[%leaf p="base"] t=[i=[%leaf p="~2021.10.16..10.03.16..59ee"] t=~]]]] t=[i=[%leaf p="<[1 20].[1 24]>"] t=~]]
    ]
  ]
]
```

---

## `++wonk`

Product from edge

Pull result out of a [`$edge`](#edge), or crash if there's no result.

#### Source

```hoon
++  wonk  =+  veq=$:edge
          |@  ++  $  ?~(q.veq !! p.u.q.veq)
          --
```

#### Examples

```
> (wide:vast [1 1] "(add 2 2)")
[p=[p=1 q=10] q=[~ [p=[%cncl p=[%wing p=~[%add]] q=~[[%sand p=%ud q=2] [%sand p=%ud q=2]]] q=[p=[p=1 q=10] q=""]]]]
```

```
> (wonk (wide:vast [1 1] "(add 2 2)"))
[%cncl p=[%wing p=~[%add]] q=~[[%sand p=%ud q=2] [%sand p=%ud q=2]]]
```

#### Discussion

See also: [`$edge`](#edge)

---