+++
title = "5c: Compiler Backend & Prettyprinter"
weight = 45
template = "doc.html"
+++

## `++ut`

Hoon compiler backend

#### Source

This core is too large to include here, refer to `hoon.hoon` for the source.

---

## `++us`

Pretty-printer backend

#### Source

This core is too large to include here, refer to `hoon.hoon` for the source.

---

## `++cain`

Tank pretty-print

Pretty-print a `vase` as a `tank` using `++deal`. This is the same as
[`++sell`](#sell).

#### Accepts

A `vase`.

#### Produces

A `tank`.

#### Source

```hoon
++  cain  sell
```

#### Examples

```
> (cain !>(['foo' 'bar']))
[%rose p=[p=" " q="[" r="]"] q=~[[%leaf p="'foo'"] [%leaf p="'bar'"]]]
```

---

## `++noah`

Tape pretty-print

Pretty-print a `vase` as a `tape`. This is the same as [`++text`](#text).

#### Accepts

A `vase`.

#### Produces

A `tape`.

#### Source

```hoon
++  noah  text
```

#### Examples

```
> (noah !>(['foo' 'bar']))
"['foo' 'bar']"
```

---

## `++onan`

Vise to vase

Convert a `vise` (old `vase`) to the new `vase`. This is the same as
[`++seer`](#seer).

#### Accepts

A `vise`.

#### Produces

A `vase`.

#### Source

```hoon
++  onan  seer
```

#### Examples

```
> (onan `vise`!>(['foo' 'bar']))
[#t/[@t @t] q=[7.303.014 7.496.034]]
```

---

## `++levi`

Type nests or crash

Check if type `b` nests under type `a`. Produces `%.y` if it nests and crashes
if it does not.

#### Accepts

`a` is a `type`.

`b` is a `type`.

#### Produces

A `?`.

#### Source

```hoon
++  levi
  |=  [a=type b=type]
  (~(nest ut a) & b)
```

#### Examples

```
> (levi -:!>('foo') -:!>(%foo))
%.y

> (levi -:!>(%foo) -:!>('foo'))
-need.%foo
-have.@t
nest-fail
```

---

## `++text`

Tape pretty-print

Pretty print vase `vax` as a `tape`.

#### Accepts

`vax` is a `vase`.

#### Produces

A `tape`.

#### Source

```hoon
++  text
  |=  vax=vase  ^-  tape
  ~(ram re (sell vax))
```

#### Examples

```
> (text !>(['foo' 'bar']))
"['foo' 'bar']"
```

---

## `++seem`

Promote typo

Convert `typo` (old type) to the new `type`.

#### Accepts

`toy` is a `typo`.

#### Produces

A `type`.

#### Source

```hoon
++  seem  |=(toy=typo `type`toy)
```

#### Examples

```
> (seem -:!>('foo'))
#t/@t
```

---

## `++seer`

Promote vise

Convert a `vise` (old `vase`) to the new `vase`.

#### Accepts

`vix` is a `vise`.

#### Produces

A `vase`.

#### Source

```hoon
++  seer  |=(vix=vise `vase`vix)
```

#### Examples

```
> (seer !>('foo'))
[#t/@t q=7.303.014]
```

---

## `++sell`

Pretty-print vase to a tank

Pretty-print vase `vax` to a `tank` using `++deal:us`.

#### Accepts

`vax` is a `vase`.

#### Produces

A `tank`.

#### Source

```hoon
++  sell
  ~/  %sell
  |=  vax=vase
  ^-  tank
  ~|  %sell
  (~(deal us p.vax) q.vax)
```

#### Examples

```
> (sell !>(['foo' 'bar']))
[%rose p=[p=" " q="[" r="]"] q=~[[%leaf p="'foo'"] [%leaf p="'bar'"]]]
```

---

## `++skol`

Pretty-print type to tank

Pretty-print type `typ` to a `tank` using `++duck:ut`.

#### Accepts

`typ` is a `type`.

#### Produces

A `tank`.

#### Source

```hoon
++  skol
  |=  typ=type
  ^-  tank
  ~(duck ut typ)
```

#### Examples

```
> (skol -:!>(['foo' 'bar']))
[%rose p=[p=" " q="[" r="]"] q=~[[%leaf p="@t"] [%leaf p="@t"]]]
```

---

## `++slam`

Slam a gate

Slam `gat`, a gate in a `vase`, with `sam`, a sample in a `vase`. Produces a
`vase` containing the result.

#### Accepts

`gat` is a gate in a `vase`.

`sam` is a noun in a `vase`.

#### Produces

A `vase`.

#### Source

```hoon
++  slam
  |=  [gat=vase sam=vase]  ^-  vase
  =+  :-  ^=  typ  ^-  type
          [%cell p.gat p.sam]
      ^=  gen  ^-  hoon
      [%cnsg [%$ ~] [%$ 2] [%$ 3] ~]
  =+  gun=(~(mint ut typ) %noun gen)
  [p.gun (slum q.gat q.sam)]
```

#### Examples

```
> (slam !>(|=([a=@ud b=@ud] [b a])) !>([1 2]))
[#t/[@ud @ud] q=[2 1]]
```

---

## `++slab`

Test if contains

States whether you can access named wing `cog` in type `typ` using access method `way`.

#### Accepts

`way` is a `?(%read %rite %both)` (A `$vial` without `%free`). This represents
the access method (read, write, or both read and write).

`cog` is a `@tas`, the name of a wing.

`typ` is a `type`.

#### Produces

A `?`.

#### Source

```hoon
++  slab
  |=  [way=?(%read %rite %both) cog=@tas typ=type]
  ?=  [%& *]
  (~(fond ut typ) way ~[cog])
```

```
> =au |=(a=@ +(a))
> (slab %read %a -:!>(au))
%.y
> (slab %rite %a -:!>(au))
%.y
> (slab %both %a -:!>(au))
%.y

> (slab %both %blah -:!>(au))
%.n

> =fe ^|(|=(a=@ +(a)))
> (slab %read %a -:!>(fe))
%.n
> (slab %rite %a -:!>(fe))
%.y
> (slab %both %a -:!>(fe))
%.n
```

---

## `++slap`

Untyped vase `.*`

Compile hoon `gen` with subject `vax` using `.*`, producing a `vase` of the
result.

#### Accepts

`vax` is a noun in a `vase`, and is the subject.

`gen` is some `hoon`.

#### Produces

A `vase`.

#### Source

```hoon
++  slap
  |=  [vax=vase gen=hoon]  ^-  vase
  =+  gun=(~(mint ut p.vax) %noun gen)
  [p.gun .*(q.vax q.gun)]
```

#### Examples

```
> (slap !>(b='foo') (ream '|=(a=@t [a b])'))
[#t/<1.qgm [a=@t b=@t]> q=[[[0 6] 0 7] 0 7.303.014]]

> !<($-(@t [@t @t]) (slap !>(b='foo') (ream '|=(a=@t [a b])')))
<1|xpg [@t @t @t @t]>

> (!<($-(@t [@t @t]) (slap !>(b='foo') (ream '|=(a=@t [a b])'))) 'bar')
['bar' 'foo']
```

---

## `++slog`

Deify printf

Prints stack trace `a` if the stack trace isn't null, then produces the other
input. `+slog` first takes `a`, producing a gate. The gate then takes some hoon.

#### Accepts

`a` is a `tang`, and is the sample of `+slog`.

`(slog a)` takes some `hoon`.

#### Produces

The result of the hoon given to `(slog a)`, with `a` printed to the terminal.

#### Source

```hoon
++  slog
  =|  pri=@
  |=  a=tang  ^+  same
  ?~(a same ~>(%slog.[pri i.a] $(a t.a)))
```

#### Examples

```
foo
> ((slog leaf+"foo" ~) (add 1 1))
2
```

#### Discussion

`slog` is intended to be put in the middle of a bunch of chained function
calls that string a piece of data through them, so that an error message will be
printed if there's one to print.

---

## `++mean`

Crash and printf

Ends the program and prints `a`, a tracing error message.

#### Accepts

`a` is a `tang`.

#### Produces

A crash, with `a` printed to the terminal.

#### Source

```hoon
++  mean
  |=  a=tang
  ^+  !!
  ?~  a  !!
  ~_(i.a $(a t.a))
```

#### Examples

```
> (mean leaf+"foo" ~)
foo
dojo: hoon expression failed
```

---

## `++road`

Evaluate trap

Evaluate a `trap`, producing the result if successful or else
crashing with a trace.

#### Accepts

A `trap`.

#### Produces

A noun.

#### Source

```hoon
++  road
  |*  =(trap *)
  ^+  $:trap
  =/  res  (mule trap)
  ?-  -.res
    %&  p.res
    %|  (mean p.res)
  ==
```

#### Examples

```
> (road |.("foo"))
"foo"

> (road |.(~|('crash!' !!)))
'crash!'
dojo: hoon expression failed
```

---

## `++slew`

Get axis in vase

Get axis `axe` in vase `vax`, producing the resulting `vase` in a `unit` which is null if
the axis cannot be retrieved.

#### Accepts

`axe` is an atom.

`vax` is a `vase`.

#### Produces

A `(unit vase)`.

#### Source

```hoon
++  slew
  |=  [axe=@ vax=vase]  ^-  (unit vase)
  ?.  |-  ^-  ?
      ?:  =(1 axe)  &
      ?.  ?=(^ q.vax)  |
      $(axe (mas axe), q.vax .*(q.vax [0 (cap axe)]))
    ~
  `[(~(peek ut p.vax) %free axe) .*(q.vax [0 axe])]
```

#### Examples

```
> (slew 3 !>(['foo' 'bar']))
[~ [#t/@t q=7.496.034]]

> !<(@t (need (slew 3 !>(['foo' 'bar']))))
'bar'

> (slew 7 !>(['foo' 'bar']))
~
```

---

## `++slim`

Identical to `++seer`

Convert a `vise` (old `vase`) to a `vase`. Identical to [`++seer`](#seer).

#### Accepts

`old` is a `vise`.

#### Produces

A `vase`.

#### Source

```hoon
++  slim
  |=  old=vise  ^-  vase
  old
```

#### Examples

```
> (slim !>('foo'))
[#t/@t q=7.303.014]
```

---

## `++slit`

Type of slam

The `type` produced if a gate of type `gat` were slammed with a sample of type `sam`.

#### Accepts

`gat` is a `type`.

`sam` is a `type`.

#### Produces

A `type`.

#### Source

```hoon
++  slit
  |=  [gat=type sam=type]
  ?>  (~(nest ut (~(peek ut gat) %free 6)) & sam)
  (~(play ut [%cell gat sam]) [%cnsg [%$ ~] [%$ 2] [%$ 3] ~])
```

#### Examples

```
> (slit -:!>(|*(a=@ [a a])) -:!>(42))
#t/[@ud @ud]

> (slit -:!>(|*(a=@ [a a])) -:!>('foo'))
#t/[@t @t]
```

---

## `++slob`

Superficial arm

#### Source

```hoon
++  slob
  |=  [cog=@tas typ=type]
  ^-  ?
  ?+  typ  |
      [%hold *]  $(typ ~(repo ut typ))
      [%hint *]  $(typ ~(repo ut typ))
      [%core *]
    |-  ^-  ?
    ?~  q.r.q.typ  |
    ?|  (~(has by q.q.n.q.r.q.typ) cog)
        $(q.r.q.typ l.q.r.q.typ)
        $(q.r.q.typ r.q.r.q.typ)
    ==
  ==
```

---

## `++sloe`

Get arms in core

Produces a list of the arms in a core of type `typ`.

#### Accepts

`typ` is a type.

#### Produces

A `(list term)`.

#### Source

```hoon
++  sloe
  |=  typ=type
  ^-  (list term)
  ?+    typ  ~
      [%hold *]  $(typ ~(repo ut typ))
      [%hint *]  $(typ ~(repo ut typ))
      [%core *]
    %-  zing
    %+  turn  ~(tap by q.r.q.typ)
      |=  [* b=tome]
    %+  turn  ~(tap by q.b)
      |=  [a=term *]
    a
  ==
```

#### Examples

```
> (sloe -:!>(|=(@ 1)))
~[%$]

> =cr |%
      ++  foo  1
      ++  bar  2
      ++  baz  3
      --

> (sloe -:!>(cr))
~[%foo %baz %bar]

> (sloe -:!>(42))
~
```

---

## `++slop`

Cons two vases

Produce the vase of a cell of vases `hed` and `tal`.

#### Accepts

`hed` is a `vase`.

`tal` is a `vase`.

#### Produces

A `vase`.

#### Source

```hoon
++  slop
  |=  [hed=vase tal=vase]
  ^-  vase
  [[%cell p.hed p.tal] [q.hed q.tal]]
```

#### Examples

```
> (slop !>('foo') !>(42))
[#t/[@t @ud] q=[7.303.014 42]]

> !<([@t @ud] (slop !>('foo') !>(42)))
['foo' 42]
```

---

## `++slot`

Got axis in vase

Get axis `axe` in vase `vax`, returning it in a `vase`. Crashes if the axis
cannot be retrieved.

#### Accepts

`axe` is an atom.

`vax` is a `vase`.

#### Produces

A `vase`.

#### Source

```hoon
++  slot
  |=  [axe=@ vax=vase]  ^-  vase
  [(~(peek ut p.vax) %free axe) .*(q.vax [0 axe])]
```

#### Examples

```
> (slot 3 !>(['foo' 'bar']))
[#t/@t q=7.496.034]

> !<(@t (slot 3 !>(['foo' 'bar'])))
'bar'

> (slot 7 !>(['foo' 'bar']))
dojo: hoon expression failed
```

---

## `++slym`

Slam without sample-type

Slam `gat`, a gate in a `vase`, with `sam`, a `noun`. The type of `sam` is
ignored and the type of the resulting vase is determined by the gate alone.

#### Accepts

`gat` is a `vase`.

`sam` is a noun.

#### Produces

A `vase`.

#### Source

```hoon
++  slym
  |=  [gat=vase sam=*]  ^-  vase
  (slap gat(+<.q sam) [%limb %$])
```

#### Examples

```
> (slym !>(|*(a=@ux [a a])) 'foo')
[#t/[@ux @ux] q=[7.303.014 7.303.014]]

> (slym !>(|*(a=@ux [a a])) "foobar")
[#t/[@ux @ux] q=[[102 111 111 98 97 114 0] 102 111 111 98 97 114 0]]
```

---

## `++sped`

Reconstruct type

#### Source

```hoon
++  sped
  |=  vax=vase
  ^-  vase
  :_  q.vax
  ?@  q.vax  (~(fuse ut p.vax) [%atom %$ ~])
  ?@  -.q.vax
    ^=  typ
    %-  ~(play ut p.vax)
    [%wtgr [%wtts [%leaf %tas -.q.vax] [%& 2]~] [%$ 1]]
  (~(fuse ut p.vax) [%cell %noun %noun])
```

---

## `++swat`

Deferred `++slap`

This is the same as [`++slap`](#slap) except `tap` is the subject `vase`
encapsulated in a `trap`, and a `(trap vase)` is produced.

#### Accepts

`tap` is a `(trap vase)`.

`gen` is `hoon`.

#### Produces

A `(trap vase)`.

#### Source

```hoon
++  swat
  |=  [tap=(trap vase) gen=hoon]
  ^-  (trap vase)
  =/  gun  (~(mint ut p:$:tap) %noun gen)
  |.  ~+
  [p.gun .*(q:$:tap q.gun)]
```

#### Examples

```
> %.  10
  !<  $-(@ @)
  %-  road
  %+  swat
    |.(!>(add-42=(cury add 42)))
  (ream '|=(a=@ (add-42 a))')
52
```

---