# 2d(1-5): To JSON, Wains

## `+to-wain:format` <a href="#to-wainformat" id="to-wainformat"></a>

Cord to line list

Convert `txt` to a wain, breaking on newline characters.

#### Accepts

`txt` is a `@t`.

#### Produces

A `$wain`, which is a `(list @t)`.

#### Source

```hoon
++  to-wain
  |=  txt=cord
  ^-  wain
  =/  len=@  (met 3 txt)
  =/  cut  =+(cut -(a 3, c 1, d txt))
  =/  sub  sub
  =|  [i=@ out=wain]
  |-  ^+  out
  =+  |-  ^-  j=@
      ?:  ?|  =(i len)
              =(10 (cut(b i)))
          ==
        i
      $(i +(i))
  =.  out  :_  out
    (cut(b i, c (sub j i)))
  ?:  =(j len)
    (flop out)
  $(i +(j))
```

#### Examples

```
> (to-wain:format 'foo\0abar\0abaz')
<|foo bar baz|>
```

***

## `+of-wain:format` <a href="#of-wainformat" id="of-wainformat"></a>

Line list to cord

Convert `tez` to a cord, separating each line with a newline character.

#### Accepts

`tez` is a `$wain`, which is a `(list @t)`.

#### Produces

A `@t`.

#### Source

```hoon
++  of-wain
  |=  tez=wain  ^-  cord
  (rap 3 (join '\0a' tez))
```

#### Examples

```
> (of-wain:format ~['foo' 'bar' 'baz'])
'foo\0abar\0abaz'
```

***

## `+of-wall:format` <a href="#of-wallformat" id="of-wallformat"></a>

Line list to tape

Convert `.a` to a tape, separating each line with a newline character.

#### Accepts

`.a` is a `+wall`, which is a `(list tape)`

#### Produces

A `$tape`.

#### Source

```hoon
++  of-wall
  |=  a=wall  ^-  tape
  ?~(a ~ "{i.a}\0a{$(a t.a)}")
```

#### Examples

```
> (of-wall:format ~["foo" "bar" "baz"])
"foo\0abar\0abaz\0a"
```

***

## `+json-rn:format` <a href="#json-rnformat" id="json-rnformat"></a>

json to rn parser

This function is used internally by [+ne](/hoon/zuse/2d_6.md#nedejsformat) and would not typically be used directly. It is a `$rule` that parses a real number string to a `+rn` in a unit.

#### Accepts

A `$nail` containing a real number.

#### Produces

An `$edge` containing a `(unit rn)`.

#### Source

```hoon
++  json-rn
  %+  knee  *rn  |.
  ;~  plug
    (easy %d)
    ;~(pose (cold | hep) (easy &))
    ;~  plug  dim:ag
      ;~  pose
        ;~  pfix  dot
          %+  sear
            |=  a=tape
            =/  b  (rust a dum:ag)
            ?~  b  ~
            (some [(lent a) u.b])
          (plus (shim '0' '9'))
        ==
        (easy [0 0])
      ==
      ;~  pose
        ;~  pfix
          (mask "eE")
          ;~  plug
            ;~(pose (cold | hep) (cold & lus) (easy &))
            ;~  pose
              ;~(pfix (plus (just '0')) dim:ag)
              dim:ag
            ==
          ==
        ==
        (easy [& 0])
      ==
    ==
  ==
```

#### Examples

```
> (rush '2.47' json-rn:format)
[~ [%d a=%.y b=[c=2 [d=2 e=47] f=%.y i=0]]]
```

```
> (rush '123' json-rn:format)
[~ [%d a=%.y b=[c=123 [d=0 e=0] f=%.y i=0]]]
```

```
> (rush 'a' json-rn:format)
~
```

***

## `+enjs:format` <a href="#enjsformat" id="enjsformat"></a>

Container arm for JSON encoders

The `+core` inside this arm contains a collection of functions for converting various types of data to `$json`. The `$json` type is defined in `lull.hoon` as:

```hoon
+$  json                    ::  normal json value
  $@  ~                     ::  null
  $%  [%a p=(list json)]    ::  array
      [%b p=?]              ::  boolean
      [%o p=(map @t json)]  ::  object
      [%n p=@ta]            ::  number
      [%s p=@t]             ::  string
  ==                        ::
```

This container arm doesn't do anything itself. The different `$json` encoding functions are documented individually below.

***

### `+frond:enjs:format` <a href="#frondenjsformat" id="frondenjsformat"></a>

Object from key-value pair

Produces a `$json` object containing `.q` with a key of `.p`.

#### Accepts

`.p` is a `@t` key.

`.q` is any `$json`.

#### Produces

A `$json` object.

#### Source

```hoon
++  frond
  |=  [p=@t q=json]
  ^-  json
  [%o [[p q] ~ ~]]
```

#### Examples

```
> (frond:enjs:format 'foo' s+'bar')
[%o p={[p='foo' q=[%s p='bar']]}]
```

```
> (en:json:html (frond:enjs:format 'foo' s+'bar'))
'{"foo":"bar"}'
```

***

### `+pairs:enjs:format` <a href="#pairsenjsformat" id="pairsenjsformat"></a>

Object from key-value pair list

Produces a `$json` object containing each key-value pair in list `.a`.

#### Accepts

`.a` is a `(list [@t json])`.

#### Produces

A `$json` object.

#### Source

```hoon
++  pairs
  |=  a=(list [p=@t q=json])
  ^-  json
  [%o (~(gas by *(map @t json)) a)]
```

#### Examples

```
> =a ~[['foo' n+~.123] ['bar' s+'abc'] ['baz' b+&]]
> (pairs:enjs:format a)
[%o p={[p='bar' q=[%s p='abc']] [p='baz' q=[%b p=%.y]] [p='foo' q=[%n p=~.123]]}]
> (en:json:html (pairs:enjs:format a))
'{"foo":123,"baz":true,"bar":"abc"}'
```

***

### `+tape:enjs:format` <a href="#tapeenjsformat" id="tapeenjsformat"></a>

String from tape

Converts `.a` into a `$json` string.

#### Accepts

`.a` is a `$tape`.

#### Produces

A `$json` string.

#### Source

```hoon
++  tape
  |=  a=^tape
  ^-  json
  [%s (crip a)]
```

#### Examples

```
> (tape:enjs:format "foo")
[%s p='foo']
```

```
> (en:json:html (tape:enjs:format "foo"))
'"foo"'
```

***

### `+wall:enjs:format` <a href="#wallenjsformat" id="wallenjsformat"></a>

String from wall

Converts `.a` to a `$json` string, separating lines with newline characters.

#### Accepts

`.a` is a `+wall`, which is a `(list tape)`.

#### Produces

A `$json` string.

#### Source

```hoon
++  wall
  |=  a=^wall
  ^-  json
  (tape (of-wall a))
```

#### Examples

```
> (wall:enjs:format ~["foo" "bar" "baz"])
[%s p='foo\0abar\0abaz\0a']
```

```
> (en:json:html (wall:enjs:format ~["foo" "bar" "baz"]))
'"foo\\nbar\\nbaz\\n"'
```

***

### `+ship:enjs:format` <a href="#shipenjsformat" id="shipenjsformat"></a>

~~String~~\* from ship

Convert ship `.a` to a `$json` ~~string~~\*.

**Note:** Currently this produces a `$json` *number* rather than string, but with the ship name rendered as text rather than a number. This is for Landscape performance reasons and may be reverted at some point.

#### Accepts

`.a` is a `@p`.

#### Produces

A `$json` ~~string~~ number but with the `@p` rendered as text rather than a number.

#### Source

```hoon
++  ship
  |=  a=^ship
  ^-  json
  [%n (rap 3 '"' (rsh [3 1] (scot %p a)) '"' ~)]
```

#### Examples

```
> (ship:enjs:format our)
[%n p=~."zod"]
```

```
> (en:json:html (ship:enjs:format our))
'"zod"'
```

***

### `+numb:enjs:format` <a href="#numbenjsformat" id="numbenjsformat"></a>

Number from unsigned

Convert `.a` to a `$json` number.

#### Accepts

`.a` is a `@u`

#### Produces

A `$json` number.

#### Source

```hoon
++  numb
  |=  a=@u
  ^-  json
  :-  %n
  ?:  =(0 a)  '0'
  %-  crip
  %-  flop
  |-  ^-  ^tape
  ?:(=(0 a) ~ [(add '0' (mod a 10)) $(a (div a 10))])
```

#### Examples

```
> (numb:enjs:format 123)
[%n p=~.123]
```

```
> (numb:enjs:format 0xffff)
[%n p=~.65535]
```

```
> (en:json:html (numb:enjs:format 123))
'123'
```

***

### `+sect:enjs:format` <a href="#sectenjsformat" id="sectenjsformat"></a>

Seconds timestamp

Convert time `.a` to a Unix seconds timestamp in a `$json` number.

#### Accepts

`.a` is a `@da`.

#### Produces

A `$json` number.

#### Source

```hoon
++  sect
  |=  a=^time
  (numb (unt:chrono:userlib a))
```

#### Examples

```
> (sect:enjs:format now)
[%n p=~.1630407271]
```

```
> (en:json:html (sect:enjs:format now))
'1630407290'
```

***

### `+time:enjs:format` <a href="#timeenjsformat" id="timeenjsformat"></a>

Millisecond timestamp

Convert time `.a` to a Unix milliseconds timestamp in a `$json` number.

#### Accepts

`.a` is a `@da`.

#### Produces

A `$json` number.

#### Source

```hoon
++  time
  |=  a=^time
  (numb (unm:chrono:userlib a))
```

#### Examples

```
> (time:enjs:format now)
[%n p=~.1630407451204]
```

```
> (en:json:html (time:enjs:format now))
'1630407462905'
```

***

### `+path:enjs:format` <a href="#pathenjsformat" id="pathenjsformat"></a>

String from path

Encode path `.a` in a `$json` string.

#### Accepts

`.a` is a `$path`

#### Produces

A `$json` string.

#### Source

```hoon
++  path
  |=  a=^path
  ^-  json
  [%s (spat a)]
```

#### Examples

```
> (path:enjs:format /foo/bar/baz)
[%s p='/foo/bar/baz']
```

```
> (en:json:html (path:enjs:format /foo/bar/baz))
'"/foo/bar/baz"'
```

***

### `+tank:enjs:format` <a href="#tankenjsformat" id="tankenjsformat"></a>

Tank as string array

Convert tank `.a` into a `$json` array of strings. The tank is passed through `+wash` with a maximum width of 80 characters specified, so may be split into multiple strings if it's too wide.

#### Accepts

`.a` is a `$tank`

#### Produces

A `$json` array of strings.

#### Source

```hoon
++  tank
  |=  a=^tank
  ^-  json
  [%a (turn (wash [0 80] a) tape)]
```

#### Examples

```
> =tan rose+[[" " "[" "]"] ~[leaf+"foo" leaf+"bar" leaf+"baz"]]
> (tank:enjs:format tan)
[%a p=~[[%s p='[foo bar baz]']]]
> (en:json:html (tank:enjs:format tan))
'["[foo bar baz]"]'
```

```
> =tan rose+[[" " "[" "]"] ~[leaf+"aaaaaaaaaaaaaaaaaaaaa" leaf+"bbbbbbbbbbbbbbbbbbb" leaf+"ccccccccccccccccccc" leaf+"dddddddddddddddddd"]]
> (en:json:html (tank:enjs:format tan))
'["[ aaaaaaaaaaaaaaaaaaaaa","  bbbbbbbbbbbbbbbbbbb","  ccccccccccccccccccc","  dddddddddddddddddd","]"]'
```


---

# 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/zuse/2d_1-5.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.