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

## `+$bite`

Atom slice specifier.

Either a single atom representing block size, or a cell containing a block size
and an atom representing the number of blocks, called `step`. If `step` is not
supplied, it defaults to a value of 1.

#### Source

```hoon
    +$  bite  $@(bloq [=bloq =step])
```

#### Examples

```
    ::  ++end gets the least significant bits of an atom.

    > (end [1 1] 255)
    3

    > (end 1 255)
    3

    > (end 3 255)
    255

    > (end 3 65.535)
    255

    > (end [3 2] 65.535)
    65.535

    > (end [3 0] 65.535)
    0
```

## `+$bloq`

Blocksize

[`Atom`](/docs/glossary/atom) representing block size. A block of size `a` has a bitwidth of `2^a`.

#### Source

```hoon
    ++  bloq  @
```

#### Examples

```
    ::  ++met measures how many a-bloqs long an atom is.

    > (met 3 256)
    2

    > (met 3 255)
    1

    > (met 3 65.535)
    2

    > (met 2 65.536)
    > 3

    > (met 0 4)
    3

    > (met 1 4)
    2

    > (met 5 9.999.999.999)
    2

    > (met 2 0xb5)
    2
```

#### Discussion

You can think of `bloq` as a numeral system that can represent values of
`a^2^2`, where `a` is the block size. That's because a block of size
`a` contains `a^2` bits, and a binary number that is `b` bits wide can represent
`b^2` values.

A `bloq` of 0 has a bitwidth of 1. (2^0 bits; can represent 2 values.)

A `bloq` of 1 has a bitwidth of 2. (2^1 bits; can represent 4 values.)

A `bloq` of 2 has a bitwidth of 4. (2^2 bits; can represent 16 values.)

A `bloq` of 3 has a bitwidth of 8. (2^3 bits; can represent 256 values.)

And so on.

See the [bit arithmetic](/docs/hoon/reference/stdlib/2c) section for operations that use `bloq`s.

---

## `++each`

Mold of fork between two types

A mold generator. Produces a discriminated fork between two types, defaulting to
`this`.

#### Source

```hoon
++  each
  |$  [this that]
  $%  [%| p=that]
      [%& p=this]
  ==
```

#### Examples

```
> ? *(each cord time)
  ?([%.y p=@t] [%.n p=@da])
[%.y p='']
```

```
> ? *(each * tape)
  ?([%.y p=*] [%.n p=""])
[%.y p=0]
```

---

## `++gate`

Function

A [`core`](/docs/glossary/core) with one arm, `$`--the empty name--which transforms a sample noun into a
product noun. If used dryly as a type, the subject must have a sample type of
`*`.

#### Source

```hoon
    ++  gate
      $-(* *)
```

#### Examples

```
> ? gate
  <1.ddq [* <46.hgz 1.pnw %140>]>
<1.ddq [* <46.hgz 1.pnw %140>]>
```

```
> (`gate`|=(a=* [a 'b']) 1)
[1 98]
```

```
> (`gate`|=(a=@ [a 'b']) 1)
mint-nice
-need.@
-have.*
nest-fail
dojo: hoon expression failed
```

#### Discussion

A `gate` is analogous to a function in other programming languages. We created
this new jargon because other constructs in Urbit are "functions" in the
mathematical sense. Any `gate` normalizes to an iron `gate`.

See also: [`++lift`](/docs/hoon/reference/stdlib/2a#lift), [`++cork`](/docs/hoon/reference/stdlib/2n#cork)

---

## `++list`

List

A mold generator. Generates a mold of a null-terminated list of a
homogenous type.

#### Source

```hoon
++  list
  |$  [item]
  $@(~ [i=item t=(list item)])
```

#### Examples

```
> *(list)
~
```

```
> `(list @)`"abc"
~[97 98 99]
```

```
> (snag 0 "abc")
'a'
```

```
> `(list @)`[1 2 'j' ~]
~[1 2 106]
```

#### Discussion

See also: [`++turn`](/docs/hoon/reference/stdlib/2b#turn), [`++snag`](/docs/hoon/reference/stdlib/2b#snag)

---

## `++lone`

Face on mold

A mold generator. Puts face of `p` on the passed-in mold.

#### Source

```hoon
++  lone
  |$  [item]
  p=item
```

#### Examples

```
> ? *cord
@t
''
```

```
> ? *(lone cord)
  p=@t
p=''
```

```
> ? *(lone @)
  p=@
p=0
```

```
> ? *@
  @
0
```

---

## `++pair`

Mold of pair of types

A mold generator. Produces a tuple of two of the types passed in.

#### Source

```hoon
++  pair
  |$  [head tail]
  [p=head q=tail]
```

#### Examples

```
> *(pair ? cord)
[p=%.y q='']
```

```
> *(pair tape @)
[p="" q=0]
```

---

## `++pole`

Faceless [`list`](/docs/hoon/reference/stdlib/1c#list)

A mold generator. A [`list`](/docs/hoon/reference/stdlib/1c#list) without the faces `i` and `t`.

#### Source

```hoon
++  pole
  |$  [item]
  $@(~ [item (pole item)])
```

#### Examples

```
> =/(a "asdf" ?>(?=(^ a) `(lest @tD)`a))
[i='a' t=[i='s' t=[i='d' t=[i='f' t=~]]]]
```

```
> `(pole char)`"asdf"
['a' ['s' ['d' ['f' ~]]]]
```

---

## `++qual`

Mold of 4-type tuple

A mold generator. Produces a tuple of four of the types passed in.

#### Source

```hoon
++  qual
  |$  [first second third fourth]
  [p=first q=second r=third s=fourth]
```

#### Examples

```
> *(qual date time tape cord)
[p=[[a=%.y y=0] m=0 t=[d=0 h=0 m=0 s=0 f=~]] q=~2000.1.1 r="" s='']
```

```
> *(qual (list @) @u @ud @ux)
[p=~ q=0 r=0 s=0x0]
```

---

## `++quip`

Mold of pair of [`list`](/docs/hoon/reference/stdlib/1c#list) and type

A mold generator. Produces a tuple of a [`list`](/docs/hoon/reference/stdlib/1c#list) of `item` and the mold of `state`.

#### Source

```hoon
++  quip
  |$  [item state]
  [(list item) state]
```

#### Examples

```
> *(quip @ _'hi')
[~ 'hi']
```

```
> `(quip @ @ux)`[[1 2 3 4 ~] 0x10]
[~[1 2 3 4] 0x10]
```

#### Discussion

A common pattern in Hoon code is to return a `list` of changes, along with a
new state. You'll often see `quip` used in Gall apps.

---

## `++step`

Atom size or offset, in [bloq](#bloq)s.

#### Source

```
++  step
  _`@u`1
```

#### Examples

```
> `step`0
0
```

```
> `step`2
2
```

---

## `++trap`

[`Core`](/docs/glossary/core) with one arm `$`

A trap is a [`core`](/docs/glossary/core) with one arm `$`.

#### Source

```hoon
++  trap
  |$  [product]
  _|?($:product)
```

#### Examples

```
> (*trap)
<1?ruo 1.mhl [product=<1|xpg [* * *]> <46.hgz 1.pnw %140>]>
```

```
> *(*trap)
0
```

```
> (|.(42))
42
```

---

## `++tree`

Tree mold generator

A mold generator. A `tree` can be empty, or contain a node of a type and
left/right sub `tree` of the same type. Pretty-printed with `{}`.

#### Source

```hoon
++  tree
  |$  [node]
  $@(~ [n=node l=(tree node) r=(tree node)])
```

#### Examples

```
> `(tree [@ tape])`[[1 "hi"] [[2 "bye"] ~ ~] ~]
{[2 "bye"] [1 "hi"]}
```

---

## `++trel`

Mold of three types

A mold generator. A mold of the tuple of the three types passed in.

#### Source

```hoon
++  trel
  |$  [first second third]
  [p=first q=second r=third]
```

#### Examples

```
> *(trel @ud @t @s)
[p=0 q='' r=--0]
```

```
> *(trel cord bloq tape)
[p='' q=0 r=""]
```

---

## `++unit`

Maybe

A mold generator. A `unit` is either `~` or `[~ u=item]`, where `item` is the
type that was passed in.

#### Source

```hoon
++  unit
  |$  [item]
  $@(~ [~ u=item])
```

#### Examples

```
> ? *(unit time)
  u(@da)
~
```

```
> =a |=  a=@
  ^-  (unit @)
  ?~  a  ~
  [~ a]
> (a 2)
[~ 2]
```

#### Discussion

Using a `unit` allows you to specify something that may not be there.

See also: [`++bind`](/docs/hoon/reference/stdlib/2a#bind)

---