# 4k: Atom Printing
## `+co`
Literal rendering engine.
`+co` contains three parts:
* A door that contains arms that operate on the sample `$coin` `.lot`.
* A core of rendering idioms.
* A core of additional formatting functions used internally.
#### Accepts
`.lot` is a `$coin`.
#### Source
The arm begins with the door:
```hoon
++ co
!:
~% %co ..co ~
=< |_ lot=coin
```
Then after that the rendering idiom core begins with:
```hoon
=| rep=tape
=< |%
```
And finally the third core:
```hoon
|%
```
***
### `+rear:co`
Prepend & render as `$tape`.
Renders a `$coin` `.lot` as a `$tape` prepended to the sample `$tape` `.rom`.
#### Accepts
`.lot` is a `$coin`, and is the sample of `+co`.
`.rom` is a `$tape`.
#### Produces
A `$tape`.
#### Source
```hoon
++ rear |=(rom=tape rend(rep rom))
```
#### Examples
```
> (~(rear co %$ %ux 200) "--ha")
"0xc8--ha"
```
***
### `+rent:co`
Render as `$knot`.
Renders a `$coin` `.lot` as a `$knot`.
#### Accepts
`.lot` is a `$coin`, and is the sample of `+co`.
#### Produces
A `$knot`.
#### Source
```hoon
++ rent ~+ `@ta`(rap 3 rend)
```
#### Examples
```
> ~(rent co %$ %ux 200)
~.0xc8
```
```
> `@t`~(rent co %$ %ux 200)
'0xc8'
```
***
### `+rend:co`
Render as `$tape`.
Renders a `$coin` `.lot` as a `$tape`.
#### Accepts
`.lot` is a `$coin`, and is the sample of `+co`.
#### Produces
A `$tape`.
#### Source
```hoon
++ rend
^- tape
~+
?: ?=(%blob -.lot)
['~' '0' ((v-co 1) (jam p.lot))]
?: ?=(%many -.lot)
:- '.'
|- ^- tape
?~ p.lot
['_' '_' rep]
['_' (weld (trip (wack rent(lot i.p.lot))) $(p.lot t.p.lot))]
=+ [yed=(end 3 p.p.lot) hay=(cut 3 [1 1] p.p.lot)]
|- ^- tape
?+ yed (z-co q.p.lot)
%c ['~' '-' (weld (rip 3 (wood (tuft q.p.lot))) rep)]
%d
?+ hay (z-co q.p.lot)
%a
=+ yod=(yore q.p.lot)
=? rep ?=(^ f.t.yod) ['.' (s-co f.t.yod)]
=? rep !&(?=(~ f) =(0 h) =(0 m) =(0 s)):t.yod
=. rep ['.' (y-co s.t.yod)]
=. rep ['.' (y-co m.t.yod)]
['.' '.' (y-co h.t.yod)]
=. rep ['.' (a-co d.t.yod)]
=. rep ['.' (a-co m.yod)]
=? rep !a.yod ['-' rep]
['~' (a-co y.yod)]
::
%r
=+ yug=(yell q.p.lot)
=? rep ?=(^ f.yug) ['.' (s-co f.yug)]
:- '~'
?: &(=(0 d.yug) =(0 m.yug) =(0 h.yug) =(0 s.yug))
['s' '0' rep]
=? rep !=(0 s.yug) ['.' 's' (a-co s.yug)]
=? rep !=(0 m.yug) ['.' 'm' (a-co m.yug)]
=? rep !=(0 h.yug) ['.' 'h' (a-co h.yug)]
=? rep !=(0 d.yug) ['.' 'd' (a-co d.yug)]
+.rep
==
::
%f
?: =(& q.p.lot)
['.' 'y' rep]
?:(=(| q.p.lot) ['.' 'n' rep] (z-co q.p.lot))
::
%n ['~' rep]
%i
?+ hay (z-co q.p.lot)
%f ((ro-co [3 10 4] |=(a=@ ~(d ne a))) q.p.lot)
%s ((ro-co [4 16 8] |=(a=@ ~(x ne a))) q.p.lot)
==
::
%p
=+ sxz=(fein:ob q.p.lot)
=+ dyx=(met 3 sxz)
:- '~'
?: (lte dyx 1)
(weld (trip (tod:po sxz)) rep)
=+ dyy=(met 4 sxz)
=| imp=@ud
|- ^- tape
?: =(imp dyy)
rep
%= $
imp +(imp)
rep =/ log (cut 4 [imp 1] sxz)
;: weld
(trip (tos:po (rsh 3 log)))
(trip (tod:po (end 3 log)))
?:(=((mod imp 4) 0) ?:(=(imp 0) "" "--") "-")
rep
== ==
::
%q
:+ '.' '~'
=; res=(pair ? tape)
(weld q.res rep)
%+ roll
=* val q.p.lot
?:(=(0 val) ~[0] (rip 3 val))
|= [q=@ s=? r=tape]
:- !s
%+ weld
(trip (?:(s tod:po tos:po) q))
?.(&(s !=(r "")) r ['-' r])
::
%r
?+ hay (z-co q.p.lot)
%d ['.' '~' (r-co (rlyd q.p.lot))]
%h ['.' '~' '~' (r-co (rlyh q.p.lot))]
%q ['.' '~' '~' '~' (r-co (rlyq q.p.lot))]
%s ['.' (r-co (rlys q.p.lot))]
==
::
%u
?: ?=(%c hay)
%+ welp ['0' 'c' (reap (pad:fa q.p.lot) '1')]
(c-co (enc:fa q.p.lot))
::
=; gam=(pair tape tape)
(weld p.gam ?:(=(0 q.p.lot) `tape`['0' ~] q.gam))
?+ hay [~ ((ox-co [10 3] |=(a=@ ~(d ne a))) q.p.lot)]
%b [['0' 'b' ~] ((ox-co [2 4] |=(a=@ ~(d ne a))) q.p.lot)]
%i [['0' 'i' ~] ((d-co 1) q.p.lot)]
%x [['0' 'x' ~] ((ox-co [16 4] |=(a=@ ~(x ne a))) q.p.lot)]
%v [['0' 'v' ~] ((ox-co [32 5] |=(a=@ ~(x ne a))) q.p.lot)]
%w [['0' 'w' ~] ((ox-co [64 5] |=(a=@ ~(w ne a))) q.p.lot)]
==
::
%s
%+ weld
?:((syn:si q.p.lot) "--" "-")
$(yed 'u', q.p.lot (abs:si q.p.lot))
::
%t
?: =('a' hay)
?: =('s' (cut 3 [2 1] p.p.lot))
(weld (rip 3 q.p.lot) rep)
['~' '.' (weld (rip 3 q.p.lot) rep)]
['~' '~' (weld (rip 3 (wood q.p.lot)) rep)]
==
```
#### Examples
```
> ~(rend co %$ %ux 200)
"0xc8"
```
```
> ~(rend co %many ~[[%$ ux+200] [%$ p+40]])
"._0xc8_~~tem__"
```
```
> ~(rend co %$ %p 32.819)
"~lasmev"
```
```
> ~(rend co %$ %ux 18)
"0x12"
```
```
> ~(rend co [%$ p=[p=%if q=0x7f00.0001]])
".127.0.0.1"
```
```
> ~(rend co %many ~[[%$ %ud 20] [%$ %uw 133] [%$ %tas 'sam']])
"._20_0w25_sam__"
```
```
> ~(rend co %blob [1 1])
"~0ph"
```
***
### `+a-co:co`
Render decimal.
Render `.dat` as a decimal integer without separators.
#### Accepts
`.dat` is an `$atom`.
#### Produces
A `$tape`
#### Source
```hoon
++ a-co |=(dat=@ ((d-co 1) dat))
```
#### Examples
```
> (a-co:co 123.456.789)
"123456789"
```
***
### `+c-co:co`
Render base58check.
Renders the given `$atom` as a base58check `$tape`.
#### Accepts
An `$atom`.
#### Produces
A `$tape`.
#### Source
```hoon
++ c-co (em-co [58 1] |=([? b=@ c=tape] [~(c ne b) c]))
```
#### Examples
```
> (enc:fa 0xdead.beef)
0xdead.beef.938b.8b0c
```
```
> (c-co:co 0xdead.beef.938b.8b0c)
"eFGDJSVvRHd"
```
***
### `+d-co:co`
Render decimal with min length.
Render `.hol` as a decimal integer without separators and with a minimum length of `.min`. If `.hol` has less than `.min` digits, leading zeros will be added to make up the difference.
#### Accepts
`.min` is an `$atom`.
`.hol` is an `$atom`.
#### Produces
A `$tape`.
#### Source
```hoon
++ d-co |=(min=@ (em-co [10 min] |=([? b=@ c=tape] [~(d ne b) c])))
```
#### Examples
```
> ((d-co:co 1) 123.456)
"123456"
```
```
> ((d-co:co 9) 123.456)
"000123456"
```
***
### `+r-co:co`
Render floating point.
Render decimal float `.a` as a `$tape`.
#### Accepts
`.a` is a `+dn`.
#### Produces
A `$tape`.
#### Source
```hoon
++ r-co
|= a=dn
?: ?=([%i *] a) (weld ?:(s.a "inf" "-inf") rep)
?: ?=([%n *] a) (weld "nan" rep)
=; rep ?:(s.a rep ['-' rep])
=/ f ((d-co 1) a.a)
=^ e e.a
=/ e=@s (sun:si (lent f))
=/ sci :(sum:si e.a e -1)
?: (syn:si (dif:si e.a --3)) [--1 sci] :: 12000 -> 12e3 e>+2
?: !(syn:si (dif:si sci -2)) [--1 sci] :: 0.001 -> 1e-3 e<-2
[(sum:si sci --1) --0] :: 1.234e2 -> '.'@3 -> 123 .4
=? rep !=(--0 e.a)
:(weld ?:((syn:si e.a) "e" "e-") ((d-co 1) (abs:si e.a)))
(weld (ed-co e f) rep)
```
#### Examples
```
> `tape`(r-co:co (rlys .3.14))
"3.14"
```
```
> `tape`(r-co:co (rlys .1.681557e-39))
"1.681557e-39"
```
***
### `+s-co:co`
Render hex list.
Render `.esc`, a list of `$atom`s, as hex with a dot before each value. Values less than two bytes in length will be padded with zeros.
#### Accepts
`.esc` is a `(list @)`.
#### Produces
A `$tape`.
#### Source
```hoon
++ s-co
|= esc=(list @) ^- tape
?~ esc rep
['.' =>(.(rep $(esc t.esc)) ((x-co 4) i.esc))]
```
#### Examples
```
> `tape`(s-co:co ~[0xdead 0xbeef 0xcafe])
".dead.beef.cafe"
```
```
> `tape`(s-co:co ~[0xa 0xb 0xc])
".000a.000b.000c"
```
```
> `tape`(s-co:co ~[0xdead.beef])
".deadbeef"
```
***
### `+v-co:co`
Render base-32 with minimum length.
Render `.hol` as base-32 with a minimum length of `.min`. If `.hol` is shorter than `.min` it will be padded with zeros.
#### Accepts
`.min` is a `@ud`.
`.hol` is an `$atom`.
#### Produces
A `$tape`.
#### Source
```hoon
++ v-co |=(min=@ (em-co [32 min] |=([? b=@ c=tape] [~(v ne b) c])))
```
#### Examples
```
> `tape`((v-co:co 1) 0v2l7.eiug3.0mbd9)
"2l7eiug30mbd9"
```
```
> `tape`((v-co:co 20) 0v2l7.eiug3.0mbd9)
"00000002l7eiug30mbd9"
```
***
### `+w-co:co`
Render base-64 with minimum length.
Render `.hol` as base-64 with a minimum length of `.min`. If `.hol` is horter than `.min` it will be padded with zeros.
#### Accepts
`.min` is a `@ud`.
`.hol` is an `$atom`.
#### Produces
A `$tape`.
#### Source
```hoon
++ w-co |=(min=@ (em-co [64 min] |=([? b=@ c=tape] [~(w ne b) c])))
```
#### Examples
```
> `tape`((w-co:co 1) 0w2.OtBSR.pPVeT)
"2OtBSRpPVeT"
```
```
> `tape`((w-co:co 20) 0w2.OtBSR.pPVeT)
"0000000002OtBSRpPVeT"
```
***
### `+x-co:co`
Render hex with minimum length.
Render `.hol` as hex with a minimum length of `.min`. If `.hol` is horter than `.min` it will be padded with zeros.
#### Accepts
`.min` is a `@ud`.
`.hol` is an `$atom`.
#### Produces
A `$tape`.
#### Source
```hoon
++ x-co |=(min=@ (em-co [16 min] |=([? b=@ c=tape] [~(x ne b) c])))
```
#### Examples
```
> `tape`((x-co:co 1) 0xdead.beef)
"deadbeef"
```
```
> `tape`((x-co:co 20) 0xdead.beef)
"000000000000deadbeef"
```
***
### `+y-co:co`
Render decimal with at least two digits.
Render `.dat` as a decimal with a minimum of two digits. If `.dat` is less than two digits it will be padded with zeros.
#### Accepts
`.dat` is an `$atom`.
#### Produces
A `$tape`.
#### Source
```hoon
++ y-co |=(dat=@ ((d-co 2) dat))
```
#### Examples
```
> (y-co:co 0)
"00"
```
```
> (y-co:co 1)
"01"
```
```
> (y-co:co 123)
"123"
```
```
> (y-co:co 123.456)
"123456"
```
***
### `+z-co:co`
Render `0x`-prefixed hex.
Render `.dat` as hex with a `0x` prefix.
#### Accepts
`.dat` is an `$atom`.
#### Produces
A `$tape`.
#### Source
```hoon
++ z-co |=(dat=@ `tape`['0' 'x' ((x-co 1) dat)])
```
#### Examples
```
> (z-co:co 123)
"0x7b"
```
```
> (z-co:co 0xdead.beef)
"0xdeadbeef"
```
```
> (z-co:co 0)
"0x0"
```
***
### `+em-co:co`
Render in numeric base.
In base `.bas`, format `.min` digits of `.hol` with `.par`. This is used internally by other rendering functions.
* `.hol` is processed least-significant digit first.
* All available digits in `.hol` will be processed, but `.min` digits can exceed the number available in `.hol`
* `.par` handles all accumulated output on each call, and can edit it, prepend or append digits, etc.
* Until `.hol` is exhausted, `.par`'s sample is `[| digit output]`, subsequently, it's `[& 0 output]`.
#### Accepts
`[bas=@ min=@]`, where `.bas` is the numeric base and `.min` is the minimum length.
`.par` is a `$gate` of `$-([? @ tape] tape)`.
`.hol` is an `$atom`.
#### Produces
A `$tape`.
#### Source
```hoon
++ em-co
|= [[bas=@ min=@] par=$-([? @ tape] tape)]
|= hol=@
^- tape
?: &(=(0 hol) =(0 min))
rep
=/ [dar=@ rad=@] (dvr hol bas)
%= $
min ?:(=(0 min) 0 (dec min))
hol dar
rep (par =(0 dar) rad rep)
==
```
#### Examples
```
> ((em-co:co [16 10] |=([? b=@ c=tape] [~(x ne b) c])) 0xbeef)
"000000beef"
```
***
### `+ed-co:co`
Format with decimal place.
Format `.int` by specifying its size with `.exp`, which may be negative. This is used internally by other rendering functions.
#### Accepts
`.exp` is a `@s`.
`.int` is a `$tape`.
#### Produces
A `$tape`.
#### Source
```hoon
++ ed-co
|= [exp=@s int=tape] ^- tape
=/ [pos=? dig=@u] [=(--1 (cmp:si exp --0)) (abs:si exp)]
?. pos
(into (weld (reap +(dig) '0') int) 1 '.')
=/ len (lent int)
?: (lth dig len) (into int dig '.')
(weld int (reap (sub dig len) '0'))
```
#### Examples
```
> (ed-co:co --3 "100")
"100"
```
```
> (ed-co:co --5 "100")
"10000"
```
```
> (ed-co:co -1 "100")
"0.0100"
```
```
> (ed-co:co -5 "100")
"0.00000100"
```
***
### `+ox-co:co`
Format dot-separated digits in numeric base.
In base `.bas`, format each digit of `.hol` with gate `.dug`, with '.' separators every `.gop` digits. This is used internally by other rendering functions.
* `.hol` is processed least-significant digit first.
* `.dug` handles individual digits, output is prepended.
* Every segment but the last is zero-padded to `.gop`.
#### Accepts
`[bas=@ gop=@]` where `.bas` is the numeric base and `.gop` is dot separator frequency.
`.dug` is a `$gate` of `$-(@ @)`.
`.hol` is an `$atom`.
#### Produces
A `$tape`.
#### Source
```hoon
++ ox-co
|= [[bas=@ gop=@] dug=$-(@ @)]
%+ em-co
[(pow bas gop) 0]
|= [top=? seg=@ res=tape]
%+ weld
?:(top ~ `tape`['.' ~])
%. seg
%+ em-co(rep res)
[bas ?:(top 0 gop)]
|=([? b=@ c=tape] [(dug b) c])
```
#### Examples
```
> ((ox-co:co [2 4] |=(a=@ ~(d ne a))) 0b1011.1101)
"1011.1101"
```
```
> ((ox-co:co [2 1] |=(a=@ ~(d ne a))) 0b1011.1101)
"1.0.1.1.1.1.0.1"
```
```
> ((ox-co:co [2 100] |=(a=@ ~(d ne a))) 0b1011.1101)
"10111101"
```
***
### `+ro-co:co`
Format dot-prefixed bloqs in numeric base.
In base `.bas`, for `.buz` bloqs 0 to `.dop`, format at least one digit of `.hol`, prefixed with `.`. This is used internally for `@i` address rendering functions.
#### Accepts
`[buz=@ bas=@ dop=@]` where `.buz` is the bloq size, `.bas` is the numeric base, and `.dop` is the number of bloqs.
`.dug` is a `$gate` of `$-(@ @)`.
`.hol` is an `$atom`.
#### Produces
A `$tape`.
#### Source
```hoon
++ ro-co
|= [[buz=@ bas=@ dop=@] dug=$-(@ @)]
|= hol=@
^- tape
?: =(0 dop)
rep
:- '.'
=/ pod (dec dop)
%. (cut buz [pod 1] hol)
%+ em-co(rep $(dop pod))
[bas 1]
|=([? b=@ c=tape] [(dug b) c])
```
#### Examples
```
> ((ro-co:co [3 10 4] |=(a=@ ~(d ne a))) .127.0.0.1)
".127.0.0.1"
```
***
---
# 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/4k.md?ask=
```
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.