# 5c: Compiler Backend & Prettyprinter

## `+ut` <a href="#ut" id="ut"></a>

Hoon compiler backend.

#### Source

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

***

## `+us` <a href="#us" id="us"></a>

Pretty-printer backend.

#### Source

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

***

## `+cain` <a href="#cain" id="cain"></a>

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` <a href="#noah" id="noah"></a>

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` <a href="#onan" id="onan"></a>

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` <a href="#levi" id="levi"></a>

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 `$flag`.

#### 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` <a href="#text" id="text"></a>

Tape pretty-print.

Pretty print vase `.x` as a `$tape`.

#### Accepts

`.x` is a `$vase`.

#### Produces

A `$tape`.

#### Source

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

#### Examples

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

***

## `+seem` <a href="#seem" id="seem"></a>

Promote typo.

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

#### Accepts

`.y` is a `$typo`.

#### Produces

A `$type`.

#### Source

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

#### Examples

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

***

## `+seer` <a href="#seer" id="seer"></a>

Promote vise.

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

#### Accepts

`.x` is a `$vise`.

#### Produces

A `$vase`.

#### Source

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

#### Examples

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

***

## `+sell` <a href="#sell" id="sell"></a>

Pretty-print vase to a tank.

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

#### Accepts

`.x` 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` <a href="#skol" id="skol"></a>

Pretty-print type to tank.

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

#### Accepts

`.p` 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` <a href="#slam" id="slam"></a>

Slam a gate.

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

#### Accepts

`.t` is a gate in a `$vase`.

`.m` 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` <a href="#slab" id="slab"></a>

Test if contains.

States whether you can access named wing `.g` in type `.p` using access method `.way`.

#### Accepts

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

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

`.p` is a `$type`.

#### Produces

A `$flag`.

#### 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` <a href="#slap" id="slap"></a>

Untyped vase `.*`.

Compile hoon `.n` with subject `.x` using `.*`, producing a `$vase` of the result.

#### Accepts

`.x` is a `$noun` in a `$vase`, and is the subject.

`.n` 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` <a href="#slog" id="slog"></a>

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` <a href="#mean" id="mean"></a>

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` <a href="#road" id="road"></a>

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` <a href="#slew" id="slew"></a>

Get axis in vase.

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

#### Accepts

`.e` is an `$atom`.

`.x` 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` <a href="#slim" id="slim"></a>

Identical to `+seer`.

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

#### Accepts

`.d` is a `$vise`.

#### Produces

A `$vase`.

#### Source

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

#### Examples

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

***

## `+slit` <a href="#slit" id="slit"></a>

Type of slam.

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

#### Accepts

`.t` is a `$type`.

`.m` 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` <a href="#slob" id="slob"></a>

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` <a href="#sloe" id="sloe"></a>

Get arms in core.

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

#### Accepts

`.p` 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` <a href="#slop" id="slop"></a>

Cons two vases.

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

#### Accepts

`.d` is a `$vase`.

`.l` 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` <a href="#slot" id="slot"></a>

Got axis in vase.

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

#### Accepts

`.e` is an `$atom`.

`.x` 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` <a href="#slym" id="slym"></a>

Slam without sample-type.

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

#### Accepts

`.t` is a `$vase`.

`.m` 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` <a href="#sped" id="sped"></a>

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` <a href="#swat" id="swat"></a>

Deferred `+slap`.

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

#### Accepts

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

`.n` 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
```

***


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.urbit.org/hoon/stdlib/5c.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.