# 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](https://docs.urbit.org/hoon/2d_6#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","]"]'
```