+++
title = "4c: Tank Printer"
weight = 30
template = "doc.html"
+++

## `++re`

Pretty-printing engine

Pretty-printing engine that accepts a `++tank` sample and contains arms that perform computation on it.

#### Accepts

`tac` is a `++tank`.

#### Produces

```hoon
    ++  re
      |_  tac/tank
```

#### Examples

```
    > ~(. re leaf+"ham")
    <2.gdc {tac/{$leaf ""} <402.arm 110.jyx 1.ztu $151>}>
```

---

### `++ram:re`

Flatten to tape

Flatten `++tank` out into a `++tape`.

#### Accepts

`tac` is a `++tank`, taken from sample of `++re` core.

#### Produces

A `++tape`.

#### Source

```hoon
      ++  ram
        ^-  tape
        ?-    -.tac
            $leaf  p.tac
            $palm  ram(tac [%rose [p.p.tac (weld q.p.tac r.p.tac) s.p.tac] q.tac])
            $rose
          %+  weld
            q.p.tac
          |-  ^-  tape
          ?~  q.tac
            r.p.tac
          =+  voz=$(q.tac t.q.tac)
          (weld ram(tac i.q.tac) ?~(t.q.tac voz (weld p.p.tac voz)))
        ==
      ::
```

#### Examples

```
    > ~(ram re leaf+"foo")
    "foo"
    > ~(ram re rose+["." "(" ")"]^~[leaf+"bar" leaf+"baz" leaf+"bam"])
    "(bar.baz.bam)"
```

---

### `++win:re`

Render at indent

Render at indent level `tab` and width `edg`.

#### Accepts

`tac` is a `++tank`, taken from sample of `++re` core.

`tab` and `edg` are atoms.

#### Produces

A `++wall` (`++list` of `++tapes`).

#### Source

```hoon
      ++  win
        |=  {tab/@ edg/@}
        =+  lug=`wall`~
        |^  |-  ^-  wall
            ?-    -.tac
                $leaf  (rig p.tac)
                $palm
              ?:  fit
                (rig ram)
              ?~  q.tac
                (rig q.p.tac)
              ?~  t.q.tac
                (rig(tab (add 2 tab), lug $(tac i.q.tac)) q.p.tac)
              =>  .(q.tac `(list tank)`q.tac)
              =+  lyn=(mul 2 (lent q.tac))
              =+  ^=  qyr
                  |-  ^-  wall
                  ?~  q.tac
                    lug
                  %=  ^$
                    tac  i.q.tac
                    tab  (add tab (sub lyn 2))
                    lug  $(q.tac t.q.tac, lyn (sub lyn 2))
                  ==
              (wig(lug qyr) q.p.tac)
            ::
```

#### Examples

```
    > (~(win re leaf+"samoltekon-lapdok") 0 20)
    <<"samoltekon-lapdok">>

    > (~(win re leaf+"samoltekon-lapdok") 0 10)
    <<"\/samolt\/" "  ekon-l" "  apdok" "\/      \/">>

    > (~(win re rose+["--" "[" "]"]^~[leaf+"1423" leaf+"2316"]) 0 20)
    <<"[1423--2316]">>

    > (~(win re rose+["--" "[" "]"]^~[leaf+"1423" leaf+"2316"]) 0 10)
    <<"[ 1423" "  2316" "]">>
```

---

### `++din:re`

XX document

#### Accepts

#### Produces

#### Source

        ++  din  (mod (add 2 tab) (mul 2 (div edg 3)))

---

### `++fit:re`

Fit on one line test

Determine whether `tac` fits on one line. Internal to `++win`

#### Accepts

#### Produces

#### Source

++ fit (lte (lent ram) (sub edg tab))

#### Examples

---

### `++rig:re`

Wrap in `\/`

Wrap `++tape` in `\/` if it doesn't fit at current indentation. Internal to
`++win`

#### Accepts

`tac` is a `++tank`, taken from sample of `++re` core.

`hom` is a `++tape`.

#### Produces

A `++wall` (list of `++tape`s).

#### Source

```hoon
        ++  rig
          |=  hom/tape
          ^-  wall
          ?:  & ::(lte (lent hom) (sub edg tab))
            [(runt [tab ' '] hom) lug]
          =>  .(tab (add tab 2), edg (sub edg 2))
          =+  mut=(trim (sub edg tab) hom)
          :-  (runt [(sub tab 2) ' '] ['\\' '/' (weld p.mut `_hom`['\\' '/' ~])])
          =>  .(hom q.mut)
          |-
          ?~  hom
            :-  %+  runt
                  [(sub tab 2) ' ']
                ['\\' '/' (runt [(sub edg tab) ' '] ['\\' '/' ~])]
            lug
          =>  .(mut (trim (sub edg tab) hom))
          [(runt [tab ' '] p.mut) $(hom q.mut)]
        ::
```

#### Examples

---

### `++wig:re`

`++win` render tape

Render `++tape`. Internal to `++win`.

#### Accepts

`tac` is a `++tank`, taken from sample of `++re` core.

`hom` is a `++tape`.

#### Produces

```hoon
        ++  wig
          |=  hom/tape
          ^-  wall
          ?~  lug
            (rig hom)
          =+  lin=(lent hom)
          =+  wug=:(add 1 tab lin)
          ?.  =+  mir=i.lug
              |-  ?~  mir
                    |
                  ?|(=(0 wug) ?&(=(' ' i.mir) $(mir t.mir, wug (dec wug))))
            (rig hom)       :: ^ XX regular form?
          [(runt [tab ' '] (weld hom `tape`[' ' (slag wug i.lug)])) t.lug]
        --
      --
```

---

## `++show`

```hoon
    ++  show                            ::  XX deprecated, use span
      |=  vem/*
      |^  ^-  tank
          ?:  ?=(@ vem)
            [%leaf (mesc (trip vem))]
          ?-    vem
              {s/$~ c/*}
            [%leaf '\'' (weld (mesc (tape +.vem)) `tape`['\'' ~])]
          ::
              {s/$a c/@}        [%leaf (mesc (trip c.vem))]
              {s/$b c/*}        (shop c.vem |=(a/@ ~(rub at a)))
              {s/{$c p/@} c/*}
            :+  %palm
              [['.' ~] ['-' ~] ~ ~]
            [[%leaf (mesc (trip p.s.vem))] $(vem c.vem) ~]
          ::
              {s/$d c/*}        (shop c.vem |=(a/@ ~(rud at a)))
              {s/$k c/*}        (tank c.vem)
              {s/$h c/*}
            :+  %rose
              [['/' ~] ['/' ~] ~]
            =+  yol=((list @ta) c.vem)
            (turn yol |=(a/@ta [%leaf (trip a)]))
          ::
              {s/$l c/*}        (shol c.vem)
              {s/$o c/*}
            %=    $
                vem
              :-  [%m '%h:<[%d %d].[%d %d]>']
              [-.c.vem +<-.c.vem +<+.c.vem +>-.c.vem +>+.c.vem ~]
            ==
          ::
              {s/$p c/*}        (shop c.vem |=(a/@ ~(rup at a)))
              {s/$q c/*}        (shop c.vem |=(a/@ ~(r at a)))
              {s/$r c/*}        $(vem [[%r ' ' '{' '}'] c.vem])
              {s/$t c/*}        (shop c.vem |=(a/@ ~(rt at a)))
              {s/$v c/*}        (shop c.vem |=(a/@ ~(ruv at a)))
              {s/$x c/*}        (shop c.vem |=(a/@ ~(rux at a)))
              {s/{$m p/@} c/*}  (shep p.s.vem c.vem)
              {s/{$r p/@} c/*}
            $(vem [[%r ' ' (cut 3 [0 1] p.s.vem) (cut 3 [1 1] p.s.vem)] c.vem])
          ::
              {s/{$r p/@ q/@ r/@} c/*}
            :+  %rose
              :*  p=(mesc (trip p.s.vem))
                  q=(mesc (trip q.s.vem))
                  r=(mesc (trip r.s.vem))
              ==
            |-  ^-  (list tank)
            ?@  c.vem
              ~
            [^$(vem -.c.vem) $(c.vem +.c.vem)]
          ::
              {s/$z c/*}        $(vem [[%r %$ %$ %$] c.vem])
              *                 !!
          ==
```

XX document

## `++shep`

```hoon
      ++  shep
        |=  {fom/@ gar/*}
        ^-  tank
        =+  l=(met 3 fom)
        =+  i=0
        :-  %leaf
        |-  ^-  tape
        ?:  (gte i l)
          ~
        =+  c=(cut 3 [i 1] fom)
        ?.  =(37 c)
          (weld (mesc [c ~]) $(i +(i)))
        =+  d=(cut 3 [+(i) 1] fom)
        ?.  .?(gar)
          ['\\' '#' $(i (add 2 i))]
        (weld ~(ram re (show d -.gar)) $(i (add 2 i), gar +.gar))
      ::
```

XX document

## `++shop`

```hoon
     ++  shop
        |=  {aug/* vel/$-(a/@ tape)}
        ^-  tank
        ?:  ?=(@ aug)
          [%leaf (vel aug)]
        :+  %rose
          [[' ' ~] ['[' ~] [']' ~]]
        =>  .(aug `*`aug)
        |-  ^-  (list tank)
        ?:  ?=(@ aug)
          [^$ ~]
        [^$(aug -.aug) $(aug +.aug)]
      ::
```

XX document

---