git.iko.soy/urbit.org
on master help sign in
Merge pull request #1111 from tinnus-napbus/zuse-json-docs

add zuse reference with json functions

commit6290281d9901f3b7462983e8b3e2eb199cf00fec authorpoprox <51337059+drbeefsupreme@users.noreply.github.com> dateMon 4 Oct 2021, 16:36 (5 years ago) parent2d47252862459d
8 files changed+4392−3
compare with master
unifiedsplit
content/docs/hoon/reference/_index.md+6−3 content/docs/hoon/reference/zuse/2d_1-5.md+587 content/docs/hoon/reference/zuse/2d_6.md+1551 content/docs/hoon/reference/zuse/2d_7.md+1307 content/docs/hoon/reference/zuse/2e_2-3.md+67 content/docs/hoon/reference/zuse/_index.md+31 content/docs/hoon/reference/zuse/table-of-contents.md+247 lib/glossary.js+596
content/docs/hoon/reference/_index.md+6−3
@@ -36,15 +36,18 @@ The full story on Hoon's type system.
3636
3737A list of aura types for atoms.
3838
39−### [Runes](/docs/hoon/reference/rune/)
39+## [Runes](/docs/hoon/reference/rune/)
4040
4141Syntax and semantics for Hoon's rune system.
4242
43−### [Limbs and Wings](/docs/hoon/reference/limbs/)
43+## [Limbs and Wings](/docs/hoon/reference/limbs/)
4444
4545How to find data inside Hoon subjects.
4646
47−### [Standard Library](/docs/hoon/reference/stdlib/)
47+## [Standard Library](/docs/hoon/reference/stdlib/)
4848
4949Reference material for the Hoon standard library.
5050
51+## [Zuse](/docs/hoon/reference/zuse/)
52+
53+Reference material for the Zuse library.
content/docs/hoon/reference/zuse/2d_1-5.mdnew file+587
@@ -0,0 +1,587 @@
1++++
2+title = "2d(1-5): To JSON, Wains"
3+weight = 40
4+template = "doc.html"
5++++
6+
7+## `++to-wain:format`
8+
9+Cord to line list
10+
11+Convert `txt` to a wain, breaking on newline characters.
12+
13+#### Accepts
14+
15+`txt` is a `@t`.
16+
17+#### Produces
18+
19+A `wain`, which is a `(list @t)`.
20+
21+#### Source
22+
23+```hoon
24+++ to-wain
25+ |= txt=cord
26+ ^- wain
27+ =/ len=@ (met 3 txt)
28+ =/ cut =+(cut -(a 3, c 1, d txt))
29+ =/ sub sub
30+ =| [i=@ out=wain]
31+ |- ^+ out
32+ =+ |- ^- j=@
33+ ?: ?| =(i len)
34+ =(10 (cut(b i)))
35+ ==
36+ i
37+ $(i +(i))
38+ =. out :_ out
39+ (cut(b i, c (sub j i)))
40+ ?: =(j len)
41+ (flop out)
42+ $(i +(j))
43+```
44+
45+#### Examples
46+
47+```
48+> (to-wain:format 'foo\0abar\0abaz')
49+<|foo bar baz|>
50+```
51+
52+---
53+
54+## `++of-wain:format`
55+
56+Line list to cord
57+
58+Convert `tez` to a cord, separating each line with a newline character.
59+
60+#### Accepts
61+
62+`tez` is a `wain`, which is a `(list @t)`.
63+
64+#### Produces
65+
66+A `@t`.
67+
68+#### Source
69+
70+```hoon
71+++ of-wain
72+ |= tez=wain ^- cord
73+ (rap 3 (join '\0a' tez))
74+```
75+
76+#### Examples
77+
78+```
79+> (of-wain:format ~['foo' 'bar' 'baz'])
80+'foo\0abar\0abaz'
81+```
82+
83+---
84+
85+## `++of-wall:format`
86+
87+Line list to tape
88+
89+Convert `a` to a tape, separating each line with a newline character.
90+
91+#### Accepts
92+
93+`a` is a `wall`, which is a `(list tape)`
94+
95+#### Produces
96+
97+A `tape`.
98+
99+#### Source
100+
101+```hoon
102+++ of-wall
103+ |= a=wall ^- tape
104+ ?~(a ~ "{i.a}\0a{$(a t.a)}")
105+```
106+
107+#### Examples
108+
109+```
110+> (of-wall:format ~["foo" "bar" "baz"])
111+"foo\0abar\0abaz\0a"
112+```
113+
114+---
115+
116+## `++json-rn:format`
117+
118+json to rn parser
119+
120+This function is used internally by [+ne](/docs/hoon/reference/zuse/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.
121+
122+#### Accepts
123+
124+A `nail` containing a real number.
125+
126+#### Produces
127+
128+An `edge` containing a `(unit rn)`.
129+
130+#### Source
131+
132+```hoon
133+++ json-rn
134+ %+ knee *rn |.
135+ ;~ plug
136+ (easy %d)
137+ ;~(pose (cold | hep) (easy &))
138+ ;~ plug dim:ag
139+ ;~ pose
140+ ;~ pfix dot
141+ %+ sear
142+ |= a=tape
143+ =/ b (rust a dum:ag)
144+ ?~ b ~
145+ (some [(lent a) u.b])
146+ (plus (shim '0' '9'))
147+ ==
148+ (easy [0 0])
149+ ==
150+ ;~ pose
151+ ;~ pfix
152+ (mask "eE")
153+ ;~ plug
154+ ;~(pose (cold | hep) (cold & lus) (easy &))
155+ ;~ pose
156+ ;~(pfix (plus (just '0')) dim:ag)
157+ dim:ag
158+ ==
159+ ==
160+ ==
161+ (easy [& 0])
162+ ==
163+ ==
164+ ==
165+```
166+
167+#### Examples
168+
169+```
170+> (rush '2.47' json-rn:format)
171+[~ [%d a=%.y b=[c=2 [d=2 e=47] f=%.y i=0]]]
172+```
173+
174+```
175+> (rush '123' json-rn:format)
176+[~ [%d a=%.y b=[c=123 [d=0 e=0] f=%.y i=0]]]
177+```
178+
179+```
180+> (rush 'a' json-rn:format)
181+~
182+```
183+
184+---
185+
186+## `++enjs:format`
187+
188+Container arm for JSON encoders
189+
190+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:
191+
192+```hoon
193++$ json :: normal json value
194+ $@ ~ :: null
195+ $% [%a p=(list json)] :: array
196+ [%b p=?] :: boolean
197+ [%o p=(map @t json)] :: object
198+ [%n p=@ta] :: number
199+ [%s p=@t] :: string
200+ == ::
201+```
202+
203+This container arm doesn't do anything itself. The different `json` encoding functions are documented individually below.
204+
205+---
206+
207+### `++frond:enjs:format`
208+
209+Object from key-value pair
210+
211+Produces a `json` object containing `q` with a key of `p`.
212+
213+#### Accepts
214+
215+`p` is a `@t` key.
216+
217+`q` is any `json`.
218+
219+#### Produces
220+
221+A `json` object.
222+
223+#### Source
224+
225+```hoon
226+++ frond
227+ |= [p=@t q=json]
228+ ^- json
229+ [%o [[p q] ~ ~]]
230+```
231+
232+#### Examples
233+
234+```
235+> (frond:enjs:format 'foo' s+'bar')
236+[%o p={[p='foo' q=[%s p='bar']]}]
237+```
238+
239+```
240+> (crip (en-json:html (frond:enjs:format 'foo' s+'bar')))
241+'{"foo":"bar"}'
242+```
243+
244+---
245+
246+### `++pairs:enjs:format`
247+
248+Object from key-value pair list
249+
250+Produces a `json` object containing each key-value pair in list `a`.
251+
252+#### Accepts
253+
254+`a` is a `(list [@t json])`.
255+
256+#### Produces
257+
258+A `json` object.
259+
260+#### Source
261+
262+```hoon
263+++ pairs
264+ |= a=(list [p=@t q=json])
265+ ^- json
266+ [%o (~(gas by *(map @t json)) a)]
267+```
268+
269+#### Examples
270+
271+```
272+> =a ~[['foo' n+~.123] ['bar' s+'abc'] ['baz' b+&]]
273+> (pairs:enjs:format a)
274+[%o p={[p='bar' q=[%s p='abc']] [p='baz' q=[%b p=%.y]] [p='foo' q=[%n p=~.123]]}]
275+> (crip (en-json:html (pairs:enjs:format a)))
276+'{"foo":123,"baz":true,"bar":"abc"}'
277+```
278+
279+---
280+
281+### `++tape:enjs:format`
282+
283+String from tape
284+
285+Converts `a` into a `json` string.
286+
287+#### Accepts
288+
289+`a` is a `tape`.
290+
291+#### Produces
292+
293+A `json` string.
294+
295+#### Source
296+
297+```hoon
298+++ tape
299+ |= a=^tape
300+ ^- json
301+ [%s (crip a)]
302+```
303+
304+#### Examples
305+
306+```
307+> (tape:enjs:format "foo")
308+[%s p='foo']
309+```
310+
311+```
312+> (crip (en-json:html (tape:enjs:format "foo")))
313+'"foo"'
314+```
315+
316+---
317+
318+### `++wall:enjs:format`
319+
320+String from wall
321+
322+Converts `a` to a `json` string, separating lines with newline characters.
323+
324+#### Accepts
325+
326+`a` is a `wall`, which is a `(list tape)`.
327+
328+#### Produces
329+
330+A `json` string.
331+
332+#### Source
333+
334+```hoon
335+++ wall
336+ |= a=^wall
337+ ^- json
338+ (tape (of-wall a))
339+```
340+
341+#### Examples
342+
343+```
344+> (wall:enjs:format ~["foo" "bar" "baz"])
345+[%s p='foo\0abar\0abaz\0a']
346+```
347+
348+```
349+> (crip (en-json:html (wall:enjs:format ~["foo" "bar" "baz"])))
350+'"foo\\nbar\\nbaz\\n"'
351+```
352+
353+---
354+
355+### `++ship:enjs:format`
356+
357+~~String~~\* from ship
358+
359+Convert ship `a` to a `json` ~~string~~\*.
360+
361+**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.
362+
363+#### Accepts
364+
365+`a` is a `@p`.
366+
367+#### Produces
368+
369+A `json` ~~string~~ number but with the `@p` rendered as text rather than a number.
370+
371+#### Source
372+
373+```hoon
374+++ ship
375+ |= a=^ship
376+ ^- json
377+ [%n (rap 3 '"' (rsh [3 1] (scot %p a)) '"' ~)]
378+```
379+
380+#### Examples
381+
382+```
383+> (ship:enjs:format our)
384+[%n p=~."zod"]
385+```
386+
387+```
388+> (crip (en-json:html (ship:enjs:format our)))
389+'"zod"'
390+```
391+
392+---
393+
394+### `++numb:enjs:format`
395+
396+Number from unsigned
397+
398+Convert `a` to a `json` number.
399+
400+#### Accepts
401+
402+`a` is a `@u`
403+
404+#### Produces
405+
406+A `json` number.
407+
408+#### Source
409+
410+```hoon
411+++ numb
412+ |= a=@u
413+ ^- json
414+ :- %n
415+ ?: =(0 a) '0'
416+ %- crip
417+ %- flop
418+ |- ^- ^tape
419+ ?:(=(0 a) ~ [(add '0' (mod a 10)) $(a (div a 10))])
420+```
421+
422+#### Examples
423+
424+```
425+> (numb:enjs:format 123)
426+[%n p=~.123]
427+```
428+
429+```
430+> (numb:enjs:format 0xffff)
431+[%n p=~.65535]
432+```
433+
434+```
435+> (crip (en-json:html (numb:enjs:format 123)))
436+'123'
437+```
438+
439+---
440+
441+### `++sect:enjs:format`
442+
443+Seconds timestamp
444+
445+Convert time `a` to a Unix seconds timestamp in a `json` number.
446+
447+#### Accepts
448+
449+`a` is a `@da`.
450+
451+#### Produces
452+
453+A `json` number.
454+
455+#### Source
456+
457+```hoon
458+++ sect
459+ |= a=^time
460+ (numb (unt:chrono:userlib a))
461+```
462+
463+#### Examples
464+
465+```
466+> (sect:enjs:format now)
467+[%n p=~.1630407271]
468+```
469+
470+```
471+> (crip (en-json:html (sect:enjs:format now)))
472+'1630407290'
473+```
474+
475+---
476+
477+### `++time:enjs:format`
478+
479+Millisecond timestamp
480+
481+Convert time `a` to a Unix milliseconds timestamp in a `json` number.
482+
483+#### Accepts
484+
485+`a` is a `@da`.
486+
487+#### Produces
488+
489+A `json` number.
490+
491+#### Source
492+
493+```hoon
494+++ time
495+ |= a=^time
496+ (numb (unm:chrono:userlib a))
497+```
498+
499+#### Examples
500+
501+```
502+> (time:enjs:format now)
503+[%n p=~.1630407451204]
504+```
505+
506+```
507+> (crip (en-json:html (time:enjs:format now)))
508+'1630407462905'
509+```
510+
511+---
512+
513+### `++path:enjs:format`
514+
515+String from path
516+
517+Encode path `a` in a `json` string.
518+
519+#### Accepts
520+
521+`a` is a `path`
522+
523+#### Produces
524+
525+A `json` string.
526+
527+#### Source
528+
529+```hoon
530+++ path
531+ |= a=^path
532+ ^- json
533+ [%s (spat a)]
534+```
535+
536+#### Examples
537+
538+```
539+> (path:enjs:format /foo/bar/baz)
540+[%s p='/foo/bar/baz']
541+```
542+
543+```
544+> (crip (en-json:html (path:enjs:format /foo/bar/baz)))
545+'"/foo/bar/baz"'
546+```
547+
548+---
549+
550+### `++tank:enjs:format`
551+
552+Tank as string array
553+
554+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.
555+
556+#### Accepts
557+
558+`a` is a `tank`
559+
560+#### Produces
561+
562+A `json` array of strings.
563+
564+#### Source
565+
566+```hoon
567+++ tank
568+ |= a=^tank
569+ ^- json
570+ [%a (turn (wash [0 80] a) tape)]
571+```
572+
573+#### Examples
574+
575+```
576+> =tan rose+[[" " "[" "]"] ~[leaf+"foo" leaf+"bar" leaf+"baz"]]
577+> (tank:enjs:format tan)
578+[%a p=~[[%s p='[foo bar baz]']]]
579+> (crip (en-json:html (tank:enjs:format tan)))
580+'["[foo bar baz]"]'
581+```
582+
583+```
584+> =tan rose+[[" " "[" "]"] ~[leaf+"aaaaaaaaaaaaaaaaaaaaa" leaf+"bbbbbbbbbbbbbbbbbbb" leaf+"ccccccccccccccccccc" leaf+"dddddddddddddddddd"]]
585+> (crip (en-json:html (tank:enjs:format tan)))
586+'["[ aaaaaaaaaaaaaaaaaaaaa"," bbbbbbbbbbbbbbbbbbb"," ccccccccccccccccccc"," dddddddddddddddddd","]"]'
587+```
content/docs/hoon/reference/zuse/2d_6.mdnew file+1551
@@ -0,0 +1,1551 @@
1++++
2+title = "2d(6): From JSON"
3+weight = 42
4+template = "doc.html"
5++++
6+
7+## `++dejs:format`
8+
9+Container arm for JSON decoding reparsers
10+
11+The `core` inside this arm contains a large collection of functions for converting `json` data to other kinds of nouns. The `json` type is defined in `lull.hoon` as:
12+
13+```hoon
14++$ json :: normal json value
15+ $@ ~ :: null
16+ $% [%a p=(list json)] :: array
17+ [%b p=?] :: boolean
18+ [%o p=(map @t json)] :: object
19+ [%n p=@ta] :: number
20+ [%s p=@t] :: string
21+ == ::
22+```
23+
24+This container arm doesn't do anything by itself. It just contains the core with the rest of the `+dejs` functions which are documented below, plus it defines a couple of things for those functions:
25+
26+```hoon
27+=> |% ++ grub *
28+ ++ fist $-(json grub)
29+ -- ::
30+```
31+
32+A `fist` is a `gate` which takes `json` and produces a `grub`. Apart from a handful of exceptions, all of the functions below are `fist`s. If the functions below aren't adequate for a particular use case, custom `fist`s can easily be written, as long as they conform to the `$-(json grub)` type definition.
33+
34+A `grub` is just defined as `*`, and is the type of the product of a `fist`. In the case of `+dejs`, it can be absolutely any `noun`.
35+
36+Keep in mind that `+grub:dejs:format` and `+fist:dejs:format` defined here (and subsequently referred to as simply `fist` and `grub`) are different to `+grub:dejs-soft:format` and `+fist:dejs-soft:format` for the [+dejs-soft](/docs/hoon/reference/zuse/2d_7) functions, which return `unit`s.
37+
38+---
39+
40+### `++ar:dejs:format`
41+
42+Array as list
43+
44+Convert array `jon` to a list, decoding each item in `jon` with `wit`.
45+
46+The `+ar` function is a wet gate that takes `wit` and produces a new gate which takes `jon`.
47+
48+#### Accepts
49+
50+`wit` is a `fist` and is the sample of the wet gate.
51+
52+`jon` is a `json` array containing the kind of `json` that `wit` handles. `jon` is the sample of the gate produced by the wet gate.
53+
54+#### Produces
55+
56+A `(list [type])` where `[type]` is the type produced by `wit`.
57+
58+#### Source
59+
60+```hoon
61+++ ar
62+ |* wit=fist
63+ |= jon=json ^- (list _(wit *json))
64+ ?> ?=([%a *] jon)
65+ (turn p.jon wit)
66+```
67+
68+#### Examples
69+
70+```
71+> ((ar so):dejs:format a+[s+'foo' s+'bar' s+'baz' ~])
72+<|foo bar baz|>
73+```
74+
75+---
76+
77+### `++as:dejs:format`
78+
79+Array as set
80+
81+Convert array `jon` to a set, decoding each item in `jon` with `a`.
82+
83+The `+as` function is a wet gate that takes `a` and produces a new gate which takes `jon`.
84+
85+#### Accepts
86+
87+`a` is a `fist`, and is the sample of the wet gate.
88+
89+`jon` is a `json` array containing the kind of `json` that `a` takes. `jon` is the sample of the gate produced by the wet gate.
90+
91+#### Produces
92+
93+A `(set [type])` where `[type]` is the type produced by `a`.
94+
95+#### Source
96+
97+```hoon
98+++ as
99+ |* a=fist
100+ (cu ~(gas in *(set _$:a)) (ar a))
101+```
102+
103+#### Examples
104+
105+```
106+> ((as so):dejs:format a+[s+'foo' s+'bar' s+'baz' ~])
107+[n='baz' l={'bar'} r={'foo'}]
108+```
109+
110+---
111+
112+### `++at:dejs:format`
113+
114+Array as tuple
115+
116+Convert array `jon` to a tuple, decoding each item in the array with the corresponding `fist` in list `wil`.
117+
118+The `+at` function is a wet gate that takes `wil` and produces a new gate which takes `jon`.
119+
120+#### Accepts
121+
122+`wil` is a `(pole fist)`, and is the sample of the wet gate. A `pole` is a faceless list.
123+
124+`jon` is a `json` array whose elements are the same kinds of `json` accepted by the `fist`s in `wil` and in the same order. `jon` is the sample of the gate produced by the wet gate.
125+
126+#### Produces
127+
128+A tuple of the same types and in the same order as those produced by the `fist`s in `wil`.
129+
130+#### Source
131+
132+```hoon
133+++ at
134+ |* wil=(pole fist)
135+ |= jon=json
136+ ?> ?=([%a *] jon)
137+ ((at-raw wil) p.jon)
138+```
139+
140+#### Examples
141+
142+```
143+> ((at ~[so ni bo]):dejs:format a+[s+'foo' n+'123' b+& ~])
144+['foo' 123 %.y]
145+```
146+
147+```
148+> ((at ~[so ni bo]):dejs:format a+[b+& s+'foo' n+'123' ~])
149+dojo: hoon expression failed
150+```
151+
152+---
153+
154+### `++at-raw:dejs:format`
155+
156+Array as tuple, raw
157+
158+This function is used internally by `+at` and would not typically be used directly.
159+
160+`+at-raw` converts list `jol` to a tuple, decoding each item in the list with the corresponding function in list `wil`.
161+
162+The `+at-raw` function is a wet gate that takes `wil` and produces a new gate which takes `jol`.
163+
164+#### Accepts
165+
166+`wil` is a `(pole fist)`, and the sample of the wet gate. A `pole` is a faceless list.
167+
168+`jol` is a `(list json)` whose items are the same kinds of `json` accepted by the `fist`s in `wil` and in the same order. `jol` is the sample of the gate produced by the wet gate.
169+
170+#### Produces
171+
172+A tuple of the types and in the same order as those produced by the `fist`s in `wil`.
173+
174+#### Source
175+
176+```hoon
177+++ at-raw
178+ |* wil=(pole fist)
179+ |= jol=(list json)
180+ ?~ jol !!
181+ ?- wil
182+ :: [wit=* t=*]
183+ [* t=*]
184+ => .(wil [wit *]=wil)
185+ ?~ t.wil ?^(t.jol !! (wit.wil i.jol))
186+ [(wit.wil i.jol) ((at-raw t.wil) t.jol)]
187+ ==
188+```
189+
190+#### Examples
191+
192+```
193+> ((at-raw ~[so ni bo]):dejs:format ~[s+'foo' n+'123' b+&])
194+['foo' 123 %.y]
195+```
196+
197+```
198+> ((at-raw ~[so ni bo]):dejs:format ~[n+'123' s+'foo' b+&])
199+dojo: hoon expression failed
200+```
201+
202+---
203+
204+### `++bo:dejs:format`
205+
206+Boolean
207+
208+Convert boolean `jon` to a `?`.
209+
210+#### Accepts
211+
212+`jon` is a `json` boolean.
213+
214+#### Produces
215+
216+A `?`.
217+
218+#### Source
219+
220+```hoon
221+++ bo
222+ |=(jon=json ?>(?=([%b *] jon) p.jon))
223+```
224+
225+#### Examples
226+
227+```
228+> (bo:dejs:format b+|)
229+%.n
230+```
231+
232+---
233+
234+### `++bu:dejs:format`
235+
236+Boolean NOT
237+
238+Convert the logical NOT of boolean `jon` to a `?`.
239+
240+#### Accepts
241+
242+`jon` is a `json` boolean.
243+
244+#### Produces
245+
246+A `?`.
247+
248+#### Source
249+
250+```hoon
251+++ bu
252+ |=(jon=json ?>(?=([%b *] jon) !p.jon))
253+```
254+
255+#### Examples
256+
257+```
258+> (bu:dejs:format [%b %.y])
259+%.n
260+```
261+
262+---
263+
264+### `++ci:dejs:format`
265+
266+Maybe transform
267+
268+Decode `jon` with `wit`, then transform it with gate `poq` which produces a `unit`. Crash if the `unit` is `~` or else unwrap it and produce its data.
269+
270+The `+ci` function is a wet gate that takes a `poq` and `wit` and produces a new gate that takes `jon`.
271+
272+#### Accepts
273+
274+`poq` is a `gate` that produces a `unit`.
275+
276+`wit` is a `fist`.
277+
278+The wet gate takes `[poq=gate wit=fist]`.
279+
280+`jon` is `json` of the kind accepted by `wit`. `jon` is the sample of the gate produced by the wet gate.
281+
282+#### Produces
283+
284+If gate `poq` produces `(unit [type])`, produce `[type]` or else crash.
285+
286+#### Source
287+
288+```hoon
289+++ ci
290+ |* [poq=gate wit=fist]
291+ |= jon=json
292+ (need (poq (wit jon)))
293+```
294+
295+#### Examples
296+
297+```
298+> ((ci |=(a=? ?:(=(a &) `'foo' ~)) bo):dejs:format b+&)
299+'foo'
300+```
301+
302+```
303+> ((ci |=(a=? ?:(=(a &) `'foo' ~)) bo):dejs:format b+|)
304+dojo: hoon expression failed
305+```
306+
307+---
308+
309+### `++cu:dejs:format`
310+
311+Transform
312+
313+Decode `jon` with `wit`, then transform it with gate `poq`.
314+
315+The `+cu` function is a wet gate that takes `poq` and `wit` and produces a new gate that takes `jon`.
316+
317+#### Accepts
318+
319+`poq` is a `gate`.
320+
321+`wit` is a `fist`.
322+
323+The wet gate takes `[poq=gate wit=fist]`.
324+
325+`jon` is `json` of the kind handled by `wit`. `jon` is the sample of the gate produced by the wet gate.
326+
327+#### Produces
328+
329+The type produced by the gate given in `poq`.
330+
331+#### Source
332+
333+```hoon
334+++ cu
335+ |* [poq=gate wit=fist]
336+ |= jon=json
337+ (poq (wit jon))
338+```
339+
340+#### Examples
341+
342+```
343+> ((cu |=(=@t [t t t]) so):dejs:format s+'foo')
344+['foo' 'foo' 'foo']
345+```
346+
347+---
348+
349+### `++di:dejs:format`
350+
351+Millisecond date
352+
353+Convert number `jon`, containing a Unix milliseconds timestamp, to a date.
354+
355+#### Accepts
356+
357+`jon` is a `json` number.
358+
359+#### Produces
360+
361+A `@da`.
362+
363+#### Source
364+
365+```hoon
366+++ di
367+ (cu from-unix-ms:chrono:userlib ni)
368+```
369+
370+#### Examples
371+
372+```
373+> =time (time:enjs:format now)
374+> time
375+[%n p=~.1630471202176]
376+> (di:dejs:format time)
377+~2021.9.1..04.40.02..2d0e.5604.1893.74bc
378+```
379+
380+---
381+
382+### `++du:dejs:format`
383+
384+Second date
385+
386+Convert number `jon`, containing a Unix seconds timestamp, to a date.
387+
388+#### Accepts
389+
390+`jon` is a `json` number.
391+
392+#### Produces
393+
394+A `@da`.
395+
396+#### Source
397+
398+```hoon
399+++ du
400+ (cu from-unix:chrono:userlib ni)
401+```
402+
403+#### Examples
404+
405+```
406+> =sec (sect:enjs:format now)
407+> sec
408+[%n p=~.1630471524]
409+> (du:dejs:format sec)
410+~2021.9.1..04.45.24
411+```
412+
413+---
414+
415+### `++mu:dejs:format`
416+
417+True unit
418+
419+Decode `jon` with `wit`, then wrap it in a `unit`. Produce `~` if `jon` is `~`.
420+
421+The `+mu` function is a wet gate that takes `wit` and produces a gate which takes `jon`.
422+
423+#### Accepts
424+
425+`wit` is a `fist`.
426+
427+The wet gate takes `wit=fist`.
428+
429+`jon` is `json` of the kind `wit` handles. `jon` is the sample of the gate produced by the wet gate.
430+
431+#### Produces
432+
433+A `(unit [type])`, where `[type]` is the type produced by the `fist` specified in `wit`.
434+
435+#### Source
436+
437+```hoon
438+++ mu
439+ |* wit=fist
440+ |= jon=json
441+ ?~(jon ~ (some (wit jon)))
442+```
443+
444+#### Examples
445+
446+```
447+> ((mu so):dejs:format s+'foo')
448+[~ 'foo']
449+```
450+
451+```
452+> ((mu so):dejs:format ~)
453+~
454+```
455+
456+---
457+
458+### `++ne:dejs:format`
459+
460+Number as real
461+
462+Convert number `jon` to a `@rd`.
463+
464+#### Accepts
465+
466+`jon` is a `json` number.
467+
468+#### Produces
469+
470+A `@rd`.
471+
472+#### Source
473+
474+```hoon
475+++ ne
476+ |= jon=json
477+ ^- @rd
478+ ?> ?=([%n *] jon)
479+ (rash p.jon (cook ryld (cook royl-cell:^so json-rn)))
480+```
481+
482+#### Examples
483+
484+```
485+> (ne:dejs:format n+'123')
486+.~123
487+```
488+
489+```
490+> (ne:dejs:format n+'2.47')
491+.~2.47
492+```
493+
494+---
495+
496+### `++ni:dejs:format`
497+
498+Number as integer
499+
500+Convert number `jon` to a `@ud`. `jon` must be an integer or it will crash.
501+
502+#### Accepts
503+
504+`jon` is a `json` number.
505+
506+#### Produces
507+
508+A `@ud`.
509+
510+#### Source
511+
512+```hoon
513+++ ni
514+ |= jon=json
515+ ?> ?=([%n *] jon)
516+ (rash p.jon dem)
517+```
518+
519+#### Examples
520+
521+```
522+> (ni:dejs:format n+'123')
523+123
524+```
525+
526+```
527+> (ni:dejs:format n+'2.47')
528+{1 2}
529+syntax error
530+```
531+
532+---
533+
534+### `++no:dejs:format`
535+
536+Number as knot
537+
538+Convert number `jon` to a `@ta`.
539+
540+#### Accepts
541+
542+`jon` is a `json` number.
543+
544+#### Produces
545+
546+A `@ta`.
547+
548+#### Source
549+
550+```hoon
551+++ no
552+ |=(jon=json ?>(?=([%n *] jon) p.jon))
553+```
554+
555+#### Examples
556+
557+```
558+> (no:dejs:format n+'2.47')
559+~.2.47
560+```
561+
562+```
563+> (no:dejs:format n+'123')
564+~.123
565+```
566+
567+---
568+
569+### `++nu:dejs:format`
570+
571+Parse string as hex
572+
573+Parse string `jon` as hexadecimal or crash.
574+
575+#### Accepts
576+
577+`jon` is a `json` string.
578+
579+#### Produces
580+
581+A `@`.
582+
583+#### Source
584+
585+```hoon
586+++ nu
587+ |= jon=json
588+ ?> ?=([%s *] jon)
589+ (rash p.jon hex)
590+```
591+
592+#### Examples
593+
594+```
595+> `@ux`(nu:dejs:format s+'DEADBEEF')
596+0xdead.beef
597+```
598+
599+```
600+> `@ux`(nu:dejs:format s+'deadbeef')
601+0xdead.beef
602+```
603+
604+```
605+> `@ux`(nu:dejs:format s+'0xdeadbeef')
606+{1 2}
607+syntax error
608+```
609+
610+---
611+
612+### `++of:dejs:format`
613+
614+Object as frond
615+
616+Convert object `jon`, which contains a single key-value pair, to a key-value tuple using the `fist` in `wer` which matches the key.
617+
618+The `+of` function is a wet gate that takes a list of pairs of keys and `fist`s and produces a new gate that takes `json`.
619+
620+**Note:** While technically the type of an item in the list `wer` is specified as `[cord fist]`, actually using a `cord` may result in incorrect type inferrence. Instead, you'll want to format it as a `@tas` like `%foo`, so the type system correctly interprets it as a tagged union. If the key contains characters that would be invalid in an ordinary `@tas`, you can format it like `%'foo_bar'` - a `%` then single quotes.
621+
622+#### Accepts
623+
624+`wer` is a `(pole [cord fist])`, and is the sample of the wet gate. A `pole` is a faceless `list`.
625+
626+`jon` is a `json` object containing a single key. `jon` is the sample of the gate produced by the wet gate.
627+
628+#### Produces
629+
630+A `[@t [type]]` where `[type]` is the type produced by the matching `fist`.
631+
632+#### Source
633+
634+```hoon
635+++ of
636+ |* wer=(pole [cord fist])
637+ |= jon=json
638+ ?> ?=([%o [@ *] ~ ~] jon)
639+ |-
640+ ?- wer
641+ :: [[key=@t wit=*] t=*]
642+ [[key=@t *] t=*]
643+ => .(wer [[* wit] *]=wer)
644+ ?: =(key.wer p.n.p.jon)
645+ [key.wer ~|(key+key.wer (wit.wer q.n.p.jon))]
646+ ?~ t.wer ~|(bad-key+p.n.p.jon !!)
647+ ((of t.wer) jon)
648+ ==
649+```
650+
651+#### Examples
652+
653+First, let's store some objects containing key-value pairs:
654+
655+```
656+> =obj-1 o+(malt ['foo' s+'hello']~)
657+> (crip (en-json:html obj-1))
658+'{"foo":"hello"}'
659+```
660+
661+```
662+> =obj-2 o+(malt ~[['bar' a+~[n+'123' n+'456']]])
663+> (crip (en-json:html obj-2))
664+'{"bar":[123,456]}'
665+```
666+
667+```
668+> =obj-3 o+(malt ['baz' b+&]~)
669+> (crip (en-json:html obj-3))
670+'{"baz":true}'
671+```
672+
673+Next, let's construct a `+of` function and try it on our objects:
674+
675+```
676+> ((of ~[foo+so bar+(ar ni)]):dejs:format obj-1)
677+[%'foo' 'hello']
678+```
679+
680+```
681+> ((of ~[foo+so bar+(ar ni)]):dejs:format obj-2)
682+[%'bar' ~[123 456]]
683+```
684+
685+```
686+> ((of ~[foo+so bar+(ar ni)]):dejs:format obj-3)
687+[%bad-key 'baz']
688+dojo: hoon expression failed
689+```
690+
691+---
692+
693+### `++ot:dejs:format`
694+
695+Object as tuple.
696+
697+Convert object `jon` to a tuple by decoding each value with the matching `fist` in `wer`. Each key in `wer` must be matched to a key in `jon`. On the other hand, if there are keys in `jon` with no corresponding key in `wer`, they'll simply be ignored.
698+
699+The `+ot` function is a wet gate that takes a list of key-`fist` pairs, and produces a gate which takes `json`.
700+
701+**Note:** While technically the type of an item in the list `wer` is specified as `[cord fist]`, actually using a `cord` may result in incorrect type inferrence. Instead, you'll want to format it as a `@tas` like `%foo`, so the type system correctly interprets it as a tagged union. If the key contains characters that would be invalid in an ordinary `@tas`, you can format it like `%'foo_bar'` - a `%` then single quotes.
702+
703+#### Accepts
704+
705+`wer` is a `(pole [cord fist])`, and is the sample of the wet gate. A `pole` is a faceless list.
706+
707+`jon` is a `json` object, and is the sample of the gate produced by the wet gate.
708+
709+#### Produces
710+
711+A tuple where the type of each item is the product of the corresponding `fist` in `wer`. The order of items in the tuple will match the order of items in `wer`.
712+
713+#### Source
714+
715+```hoon
716+++ ot
717+ |* wer=(pole [cord fist])
718+ |= jon=json
719+ ?> ?=([%o *] jon)
720+ ((ot-raw wer) p.jon)
721+```
722+
723+#### Examples
724+
725+```
726+> %- (ot ~[foo+so bar+ni]):dejs:format
727+ o+(malt (limo ~[['bar' n+'123'] ['foo' s+'hello'] ['baz' b+&]]))
728+['hello' 123]
729+```
730+
731+```
732+> %- (ot ~[foo+so bar+ni]):dejs:format
733+ o+(malt (limo ~[['bar' n+'123'] ['baz' b+&]]))
734+[%key 'foo']
735+dojo: hoon expression failed
736+```
737+
738+---
739+
740+### `++ot-raw:dejs:format`
741+
742+Object as tuple, raw
743+
744+This function is used internally by [+ot](#otdejsformat) and would not typically be used directly.
745+
746+`+ot-raw` converts map `jom` to a tuple by decoding each value with the matching `fist` in `wer`. Each key in `wer` must be matched to a key in the given map. On the other hand, if there are keys in the map with no corresponding key in `wer`, they'll simply be ignored.
747+
748+The `+ot-raw` function is a wet gate that takes a list of key-`fist` pairs, and produces a gate which takes a map of keys to `json`.
749+
750+**Note:** While technically the type of an item in the list `wer` is specified as `[cord fist]`, actually using a `cord` may result in incorrect type inferrence. Instead, you'll want to format it as a `@tas` like `%foo`, so the type system correctly interprets it as a tagged union. If the key contains characters that would be invalid in an ordinary `@tas`, you can format it like `%'foo_bar'` - a `%` then single quotes.
751+
752+#### Accepts
753+
754+`wer` is a `(pole [cord fist])`, and is the sample of the wet gate. A `pole` is a faceless list.
755+
756+`jom` is a `(map @t json)`, and is the sample of the gate produced by the wet gate.
757+
758+#### Produces
759+
760+A tuple where the type of each item is the product of the corresponding `fist` in `wer`. The order of items in the tuple will match the order of items in `wer`.
761+
762+#### Source
763+
764+```hoon
765+++ ot-raw
766+ |* wer=(pole [cord fist])
767+ |= jom=(map @t json)
768+ ?- wer
769+ :: [[key=@t wit=*] t=*]
770+ [[key=@t *] t=*]
771+ => .(wer [[* wit] *]=wer)
772+ =/ ten ~|(key+key.wer (wit.wer (~(got by jom) key.wer)))
773+ ?~(t.wer ten [ten ((ot-raw t.wer) jom)])
774+ ==
775+```
776+
777+#### Examples
778+
779+```
780+> %- (ot-raw ~[foo+so bar+ni]):dejs:format
781+ (malt (limo ~[['bar' n+'123'] ['foo' s+'hello'] ['baz' b+&]]))
782+['hello' 123]
783+```
784+
785+```
786+> %- (ot-raw ~[foo+so bar+ni]):dejs:format
787+ (malt (limo ~[['bar' n+'123'] ['baz' b+&]]))
788+[%key 'foo']
789+dojo: hoon expression failed
790+```
791+
792+---
793+
794+### `++ou:dejs:format`
795+
796+Object of units
797+
798+Convert object `jon` to a tuple by decoding each value with the function in `wer` that matches its key. Keys in `jon` with no matching key in `wer` are ignored. This is the same as [+ot](#otdejsformat) except that:
799+
800+- It wraps each value in `jon` in a `unit` before passing it to the corresponding function in `wer`.
801+- If a key in `wer` has no matching key in `jon`, it passes `~` to that function.
802+
803+Therefore, the functions must take a `(unit json)` rather than just `json`, so they are not `fist`s but rather `$-((unit json) grub)` (despite what the source code says). There are two `+dejs` functions that can be used in `+ou` and take `unit`s: [+uf](#ufdejsformat) and [+un](#undejsformat). Both of them wrap `fist`s like `(uf so)` or `(un so)`. The former, `+uf`, lets you replace a null `unit` with something of your choosing. The latter, `+un`, crashes if the `unit` is null. Using both in a `+ou` allows you to set some values as mandatory and others as optional, replacing any missing optional ones with whatever you want. This is the ultimate purpose of `+ou`.
804+
805+The `+ou` function is a wet gate that takes a list of key-function pairs, and produces a gate which takes `json`.
806+
807+**Note:** While technically the type of an item in the list `wer` is specified as `[cord fist]`, actually using a `cord` may result in incorrect type inferrence. Instead, you'll want to format it as a `@tas` like `%foo`, so the type system correctly interprets it as a tagged union. If the key contains characters that would be invalid in an ordinary `@tas`, you can format it like `%'foo_bar'` - a `%` then single quotes.
808+
809+#### Accepts
810+
811+`wer` is a `(pole [cord $-((unit json) grub)])`, despite saying `(pole [cord fist])` in the source code. `wer` is the sample of the wet gate. A `pole` is a faceless list.
812+
813+`jon` is a `json` object, and is the sample of the gate produced by the wet gate.
814+
815+#### Produces
816+
817+A tuple where the type of each item is the product of the corresponding function in `wer`. The order of items in the tuple will match the order of items in `wer`.
818+
819+#### Source
820+
821+```hoon
822+++ ou
823+ |* wer=(pole [cord fist])
824+ |= jon=json
825+ ?> ?=([%o *] jon)
826+ ((ou-raw wer) p.jon)
827+```
828+
829+#### Examples
830+
831+```
832+> %- (ou ~[foo+(un so) bar+(uf missing+ni)]):dejs:format
833+ o+(malt (limo ~[['foo' s+'hello']]))
834+['hello' %missing]
835+```
836+
837+```
838+> %- (ou ~[foo+(un so) bar+(uf missing+ni)]):dejs:format
839+ o+(malt (limo ~[['bar' n+'123']]))
840+[%key 'foo']
841+dojo: hoon expression failed
842+```
843+
844+```
845+> %- (ou ~[foo+(un so) bar+(uf missing+ni)]):dejs:format
846+ o+(malt (limo ~[['foo' s+'hello'] ['bar' n+'123']]))
847+['hello' 123]
848+```
849+
850+---
851+
852+### `++ou-raw:dejs:format`
853+
854+Object of units, raw
855+
856+This function is used internally by [+ou](#oudejsformat), you would not typically use it directly.
857+
858+Convert map `jom` to a tuple by decoding each value with the function in `wer` that matches its key. Keys in `jom` with no matching key in `wer` are ignored. This is the same as [+ot-raw](#ot-rawdejsformat) except that:
859+
860+- It wraps each value in `jom` in a `unit` before passing it to the corresponding function in `wer`.
861+- If a key in `wer` has no matching key in `jom`, it passes `~` to that function.
862+
863+Therefore, the functions must take a `(unit json)` rather than just `json`, so they are not `fist`s but rather `$-((unit json) grub)` (despite what the source code says). There are two `+dejs` functions that can be used in `+ou-raw` and take `unit`s: [+uf](#ufdejsformat) and [+un](#undejsformat). Both of them wrap `fist`s like `(uf so)` or `(un so)`. The former, `+uf`, lets you replace a null `unit` with something of your choosing. The latter, `+un`, crashes if the `unit` is null. Using both in a `+ou-raw` allows you to set some values as mandatory and others as optional, replacing any missing optional ones with whatever you want.
864+
865+The `+ou-raw` function is a wet gate that takes a list of key-function pairs, and produces a gate which takes a map of `@t` keys to `json`.
866+
867+**Note:** While technically the type of an item in the list `wer` is specified as `[cord fist]`, actually using a `cord` may result in incorrect type inferrence. Instead, you'll want to format it as a `@tas` like `%foo`, so the type system correctly interprets it as a tagged union. If the key contains characters that would be invalid in an ordinary `@tas`, you can format it like `%'foo_bar'` - a `%` then single quotes.
868+
869+#### Accepts
870+
871+`wer` is a `(pole [cord $-((unit json) grub)])`, despite saying `(pole [cord fist])` in the source code. `wer` is the sample of the wet gate. A `pole` is a faceless list.
872+
873+`jon` is a `(map @t json)`, and is the sample of the gate produced by the wet gate.
874+
875+#### Produces
876+
877+A tuple where the type of each item is the product of the corresponding function in `wer`. The order of items in the tuple will match the order of items in `wer`.
878+
879+#### Source
880+
881+```hoon
882+++ ou-raw
883+ |* wer=(pole [cord fist])
884+ |= jom=(map @t json)
885+ ?- wer
886+ :: [[key=@t wit=*] t=*]
887+ [[key=@t *] t=*]
888+ => .(wer [[* wit] *]=wer)
889+ =/ ten ~|(key+key.wer (wit.wer (~(get by jom) key.wer)))
890+ ?~(t.wer ten [ten ((ou-raw t.wer) jom)])
891+ ==
892+```
893+
894+#### Examples
895+
896+```
897+> %- (ou-raw ~[foo+(un so) bar+(uf missing+ni)]):dejs:format
898+ (malt (limo ~[['foo' s+'hello']]))
899+['hello' %missing]
900+```
901+
902+```
903+> %- (ou-raw ~[foo+(un so) bar+(uf missing+ni)]):dejs:format
904+ (malt (limo ~[['bar' n+'123']]))
905+[%key 'foo']
906+dojo: hoon expression failed
907+```
908+
909+```
910+> %- (ou-raw ~[foo+(un so) bar+(uf missing+ni)]):dejs:format
911+ (malt (limo ~[['foo' s+'hello'] ['bar' n+'123']]))
912+['hello' 123]
913+```
914+
915+---
916+
917+### `++oj:dejs:format`
918+
919+Object as jug
920+
921+Convert `jon`, an object of arrays, to a `jug`. Decode each element in each array with `fist`.
922+
923+The `+oj` function is a wet gate that takes `fist` and produces a gate that takes `jon`.
924+
925+#### Accepts
926+
927+`fist` is a `fist`, and is the sample of the wet gate.
928+
929+`jon` is a `json` object of arrays. Each element in each array is of the same `json` kind. `jon` is the sample of the gate produced by the wet gate.
930+
931+#### Produces
932+
933+A `(jug cord [type])`, where `[type]` is the type produced by `fist`.
934+
935+#### Source
936+
937+```hoon
938+++ oj
939+ |* =fist
940+ ^- $-(json (jug cord _(fist *json)))
941+ (om (as fist))
942+```
943+
944+#### Examples
945+
946+```
947+> =jon (need (de-json:html '{"foo":["aaa","bbb","ccc"],"bar":["xxx","yyy","zzz"]}'))
948+> ((oj so):dejs:format jon)
949+{[p='bar' q={'xxx' 'zzz' 'yyy'}] [p='foo' q={'bbb' 'ccc' 'aaa'}]}
950+```
951+
952+---
953+
954+### `++om:dejs:format`
955+
956+Object as map
957+
958+Convert object `jon` to a map, decoding each value with `wit`.
959+
960+The `+om` function is a wet gate that takes `wit` and produces a gate that takes `jon`.
961+
962+#### Accepts
963+
964+`wit` is a `fist`, and is the sample of the wet gate.
965+
966+`jon` is a `json` object whose values are the kind of `json` that `wit` takes. `jon` is the sample of the gate produced by the wet gate.
967+
968+#### Produces
969+
970+A `(map cord [type])`, where `[type]` is the type produced by `wit`.
971+
972+#### Source
973+
974+```hoon
975+++ om
976+ |* wit=fist
977+ |= jon=json
978+ ?> ?=([%o *] jon)
979+ (~(run by p.jon) wit)
980+```
981+
982+#### Examples
983+
984+```
985+> =jon (need (de-json:html '{"foo":"aaa","bar":"bbb"}'))
986+> ((om so):dejs:format jon)
987+{[p='bar' q='bbb'] [p='foo' q='aaa']}
988+```
989+
990+---
991+
992+### `++op:dejs:format`
993+
994+Parse keys of map
995+
996+Convert object `jon` to a map, parsing each key with `fel` and decoding each value with `wit`.
997+
998+The `+op` function is a wet gate that takes `fel` and `wit`, and produces a gate that takes `jon`.
999+
1000+#### Accepts
1001+
1002+The wet gate takes a cell of `[fel wil]`, where `fel` is a parsing `rule` and `wil` is a `fist`.
1003+
1004+`jon` is a `json` object, whose keys are parsable by `fel` and whose values are `json` of the kind `wit` takes. `jon` is the sample of the gate produced by the wet gate.
1005+
1006+#### Produces
1007+
1008+A `(map [a] [b])` where `[a]` is the type produced by `fel` and `[b]` is the type produced by `wit`.
1009+
1010+#### Source
1011+
1012+```hoon
1013+++ op
1014+ |* [fel=rule wit=fist]
1015+ |= jon=json ^- (map _(wonk *fel) _*wit)
1016+ =/ jom ((om wit) jon)
1017+ %- malt
1018+ %+ turn ~(tap by jom)
1019+ |* [a=cord b=*]
1020+ => .(+< [a b]=+<)
1021+ [(rash a fel) b]
1022+```
1023+
1024+#### Examples
1025+
1026+```
1027+> =jon (need (de-json:html '{"123":"aaa","456":"bbb"}'))
1028+> ((op dem so):dejs:format jon)
1029+{[p=456 q='bbb'] [p=123 q='aaa']}
1030+```
1031+
1032+---
1033+
1034+### `++pa:dejs:format`
1035+
1036+String as path
1037+
1038+Convert `jon` and parse to a path.
1039+
1040+#### Accepts
1041+
1042+`jon` is a `json` string encoding a `path`.
1043+
1044+#### Produces
1045+
1046+A `(list @)` which can be cast to a `path`.
1047+
1048+#### Source
1049+
1050+```hoon
1051+++ pa
1052+ (su stap)
1053+```
1054+
1055+#### Examples
1056+
1057+```
1058+> `path`(pa:dejs:format s+'/foo/bar/baz')
1059+/foo/bar/baz
1060+```
1061+
1062+---
1063+
1064+### `++pe:dejs:format`
1065+
1066+Prefix
1067+
1068+Decode `jon` with `wit`, and prefix the result with `pre`.
1069+
1070+The `+pe` function is a wet gate that takes `pre` and `wit`, and produces a gate that takes `jon`.
1071+
1072+#### Accepts
1073+
1074+The wet gate takes a cell of `[pre wit]`, where `pre` is any noun and `wit` is a `fist`.
1075+
1076+`jon` is `json` of the kind accepted by `wit`. `jon` is the sample of the gate produced by the wet gate.
1077+
1078+#### Produces
1079+
1080+A cell of `[[a] [b]]`, where `[a]` is the noun given in `pre` and `[b]` is the type produced by `wit`.
1081+
1082+#### Source
1083+
1084+```hoon
1085+++ pe
1086+ |* [pre=* wit=fist]
1087+ (cu |*(* [pre +<]) wit)
1088+```
1089+
1090+#### Examples
1091+
1092+```
1093+> ((pe %foo so):dejs:format s+'bar')
1094+[%foo 'bar']
1095+```
1096+
1097+---
1098+
1099+### `++sa:dejs:format`
1100+
1101+String as tape
1102+
1103+Convert `jon` to a `tape`.
1104+
1105+#### Accepts
1106+
1107+`jon` is a `json` string.
1108+
1109+#### Produces
1110+
1111+A `tape`.
1112+
1113+#### Source
1114+
1115+```hoon
1116+++ sa
1117+ |=(jon=json ?>(?=([%s *] jon) (trip p.jon)))
1118+```
1119+
1120+#### Examples
1121+
1122+```
1123+> (sa:dejs:format s+'foo')
1124+"foo"
1125+```
1126+
1127+---
1128+
1129+### `++sd:dejs:format`
1130+
1131+String `@ud` as date
1132+
1133+Convert `jon` to a `@da`, parsing it as a date in `@ud` form.
1134+
1135+#### Accepts
1136+
1137+`jon` is a `json` string encoding a date in `@ud` form.
1138+
1139+#### Produces
1140+
1141+A `@da`.
1142+
1143+#### Source
1144+
1145+```hoon
1146+++ sd
1147+ |= jon=json
1148+ ^- @da
1149+ ?> ?=(%s -.jon)
1150+ `@da`(rash p.jon dem:ag)
1151+```
1152+
1153+#### Examples
1154+
1155+```
1156+> (sd:dejs:format s+(scot %ud now))
1157+~2021.9.8..01.02.41..e5db
1158+```
1159+
1160+---
1161+
1162+### `++se:dejs:format`
1163+
1164+String as aura
1165+
1166+Convert and parse `jon` to an atom of the type specified in `aur`.
1167+
1168+The `+se` function is a gate within a gate. The first gate takes `aur` and the second takes `jon`.
1169+
1170+#### Accepts
1171+
1172+`aur` is a `@tas` denoting an aura like `%ud`, `%tas`, `%p`, etc. `aur` is the sample of the first gate
1173+
1174+`jon` is a `json` string encoding an atom of the type specified in `aur`. `jon` is the sample of the second nested gate.
1175+
1176+#### Produces
1177+
1178+A `@` which can then be cast to the type specified in `aur`.
1179+
1180+#### Source
1181+
1182+```hoon
1183+++ se
1184+ |= aur=@tas
1185+ |= jon=json
1186+ ?>(?=([%s *] jon) (slav aur p.jon))
1187+```
1188+
1189+#### Examples
1190+
1191+```
1192+> `@p`((se %p):dejs:format s+(scot %p our))
1193+~zod
1194+```
1195+
1196+```
1197+> `@da`((se %da):dejs:format s+(scot %da now))
1198+~2021.9.8..01.12.28..4f6a
1199+```
1200+
1201+---
1202+
1203+### `++so:dejs:format`
1204+
1205+String as cord
1206+
1207+Convert `jon` to a cord.
1208+
1209+#### Accepts
1210+
1211+`jon` is a `json` string.
1212+
1213+#### Produces
1214+
1215+A `@t`.
1216+
1217+#### Source
1218+
1219+```hoon
1220+++ so
1221+ |=(jon=json ?>(?=([%s *] jon) p.jon))
1222+```
1223+
1224+#### Examples
1225+
1226+```
1227+> (so:dejs:format s+'foo')
1228+'foo'
1229+```
1230+
1231+---
1232+
1233+### `++su:dejs:format`
1234+
1235+Parse string
1236+
1237+Convert and parse `jon` with `sab`.
1238+
1239+The `+su` function is a wet gate that takes `sab`, and produces a gate that takes `jon`.
1240+
1241+#### Accepts
1242+
1243+`sab` is a parsing `rule`, and is the sample of the wet gate.
1244+
1245+`jon` is a `json` string, and is the sample of the gate produced by the wet gate.
1246+
1247+#### Produces
1248+
1249+The type produced by `sab`.
1250+
1251+#### Source
1252+
1253+```hoon
1254+++ su
1255+ |* sab=rule
1256+ |= jon=json ^+ (wonk *sab)
1257+ ?> ?=([%s *] jon)
1258+ (rash p.jon sab)
1259+```
1260+
1261+#### Examples
1262+
1263+```
1264+> ((su dem):dejs:format s+'123456')
1265+123.456
1266+```
1267+
1268+```
1269+> `@ub`((su bin):dejs:format s+'00001011101110001101')
1270+0b1011.1011.1000.1101
1271+```
1272+
1273+---
1274+
1275+### `++uf:dejs:format`
1276+
1277+Unit fall
1278+
1279+Convert the `json` data in unit `jon` with `wit` unless `jon` is `~`, in which case return `def`. Note this deals with `(unit json)` rather than the usual `json`. This would typically be used inside a [+ou](#oudejsformat) function to replace missing values with the given values.
1280+
1281+The `+uf` function is a wet gate that takes `def` and `wit`, and produces a gate that takes `jon`.
1282+
1283+#### Accepts
1284+
1285+The wet gate takes a cell of `[def wit]`, where `def` is any `noun` and `wit` is a `fist`.
1286+
1287+`jon` is a `(unit json)`, and is the sample of the gate produced by the wet gate.
1288+
1289+#### Produces
1290+
1291+Either the type produced by `wit`, or else the `noun` given in `def` if `jon` is null.
1292+
1293+#### Source
1294+
1295+```hoon
1296+++ uf
1297+ |* [def=* wit=fist]
1298+ |= jon=(unit json)
1299+ ?~(jon def (wit u.jon))
1300+```
1301+
1302+#### Examples
1303+
1304+```
1305+> ((uf %missing so):dejs:format `s+'foo')
1306+'foo'
1307+```
1308+
1309+```
1310+> ((uf %missing so):dejs:format ~)
1311+%missing
1312+```
1313+
1314+---
1315+
1316+### `++un:dejs:format`
1317+
1318+Unit need
1319+
1320+Convert the `json` data in unit `jon` with `wit` unless `jon` is `~`, in which case crash. Note this deals with `(unit json)` rather than the usual `json`. This would typically be used inside a [+ou](#oudejsformat) function and in conjunction with [+uf](#ufdejsformat) to specify mandatory values.
1321+
1322+The `+un` function is a wet gate that takes `wit` and produces a gate that takes `jon`.
1323+
1324+#### Accepts
1325+
1326+`wit` is a `fist`, and is the sample of the wet gate.
1327+
1328+`jon` is a `(unit json)`, and is the sample of the gate returned by the wet gate.
1329+
1330+#### Produces
1331+
1332+The type produced by `wit` or crash if `jon` is null.
1333+
1334+#### Source
1335+
1336+```hoon
1337+++ un
1338+ |* wit=fist
1339+ |= jon=(unit json)
1340+ (wit (need jon))
1341+```
1342+
1343+#### Examples
1344+
1345+```
1346+> ((un so):dejs:format `s+'foo')
1347+'foo'
1348+```
1349+
1350+```
1351+> ((un so):dejs:format ~)
1352+dojo: hoon expression failed
1353+```
1354+
1355+---
1356+
1357+### `++ul:dejs:format`
1358+
1359+Null
1360+
1361+Return `~` if `jon` is null or else crash.
1362+
1363+#### Accepts
1364+
1365+`jon` is null `json`.
1366+
1367+#### Produces
1368+
1369+`~` if `jon` is null, otherwise crashes.
1370+
1371+#### Source
1372+
1373+```hoon
1374+++ ul
1375+ |=(jon=json ?~(jon ~ !!))
1376+```
1377+
1378+#### Examples
1379+
1380+```
1381+> (ul:dejs:format ~)
1382+~
1383+```
1384+
1385+```
1386+> (ul:dejs:format b+&)
1387+dojo: hoon expression failed
1388+```
1389+
1390+---
1391+
1392+### `++za:dejs:format`
1393+
1394+Full unit pole
1395+
1396+Check whether all units in list `pod` are non-null. This is used internally by some functions and would not typically be used directly.
1397+
1398+#### Accepts
1399+
1400+`pod` is a `(pole (unit))`. A `pole` is a faceless list.
1401+
1402+#### Produces
1403+
1404+A `?`, which is `%.n` if any of the `unit`s in `pod` are `~`, and `%.y` otherwise.
1405+
1406+#### Source
1407+
1408+```hoon
1409+++ za
1410+ |* pod=(pole (unit))
1411+ ?~ pod &
1412+ ?~ -.pod |
1413+ (za +.pod)
1414+```
1415+
1416+#### Examples
1417+
1418+```
1419+> (za:dejs:format ~[`1 `2 `3 `4])
1420+%.y
1421+```
1422+
1423+```
1424+> (za:dejs:format ~)
1425+%.y
1426+```
1427+
1428+```
1429+> (za:dejs:format ~[`1 `2 ~ `4])
1430+%.n
1431+```
1432+
1433+---
1434+
1435+### `++zl:dejs:format`
1436+
1437+Collapse unit list
1438+
1439+Convert `lut`, a list of units, to a `(unit (list))` by stripping the unit from each item. The resulting unit is null if any of the units in the list are null. This is used internally by some functions, you would not typically use it directly.
1440+
1441+#### Accepts
1442+
1443+A `(list (unit))`.
1444+
1445+#### Produces
1446+
1447+A `(unit (list))` which is null if any of the units in `lut` were null.
1448+
1449+#### Source
1450+
1451+```hoon
1452+++ zl
1453+ |* lut=(list (unit))
1454+ ?. |- ^- ?
1455+ ?~(lut & ?~(i.lut | $(lut t.lut)))
1456+ ~
1457+ %- some
1458+ |-
1459+ ?~ lut ~
1460+ [i=u:+.i.lut t=$(lut t.lut)]
1461+```
1462+
1463+#### Examples
1464+
1465+```
1466+> (zl:dejs:format (limo ~[`1 `2 `3 `4 `5 `6]))
1467+[~ [i=1 t=~[2 3 4 5 6]]]
1468+```
1469+
1470+```
1471+> (zl:dejs:format (limo ~[`1 `2 ~ `4 `5 `6]))
1472+~
1473+```
1474+
1475+---
1476+
1477+### `++zp:dejs:format`
1478+
1479+Unit tuple
1480+
1481+Convert `but`, a list of units, to a tuple by stripping the unit from each item. Crashes if any of the units are null. This is used internally by some functions, you would not typically use it directly.
1482+
1483+#### Accepts
1484+
1485+`but` is a `(pole (unit))`. A `pole` is a faceless list.
1486+
1487+#### Produces
1488+
1489+A tuple containing each unwrapped element from the original list, or crashes if any of the units were null.
1490+
1491+#### Source
1492+
1493+```hoon
1494+++ zp
1495+ |* but=(pole (unit))
1496+ ?~ but !!
1497+ ?~ +.but
1498+ u:->.but
1499+ [u:->.but (zp +.but)]
1500+```
1501+
1502+#### Examples
1503+
1504+```
1505+> (zp:dejs:format ~[`1 `2 `3 `4 `5 `6])
1506+[1 2 3 4 5 6]
1507+```
1508+
1509+```
1510+> (zp:dejs:format ~[`1 `2 ~ `4 `5 `6])
1511+mull-none
1512+dojo: hoon expression failed
1513+```
1514+
1515+---
1516+
1517+### `++zm:dejs:format`
1518+
1519+Collapse unit map
1520+
1521+Strip units from values in `lum`, a map of units. Returns null if any of the units are null. This is used internally by some functions, you would not typically use it directly.
1522+
1523+#### Accepts
1524+
1525+`lum` is a `(map term (unit))`
1526+
1527+#### Produces
1528+
1529+A `(unit (map term [type]))`, where `[type]` is the type the units in `lum` contained. Produces `~` if any of the units were null.
1530+
1531+#### Source
1532+
1533+```hoon
1534+++ zm
1535+ |* lum=(map term (unit))
1536+ ?: (~(rep by lum) |=([[@ a=(unit)] b=_|] |(b ?=(~ a))))
1537+ ~
1538+ (some (~(run by lum) need))
1539+```
1540+
1541+#### Examples
1542+
1543+```
1544+> (zm:dejs:format (malt ~[['foo' `1] ['bar' `2]]))
1545+[~ {[p='bar' q=2] [p='foo' q=1]}]
1546+```
1547+
1548+```
1549+> (zm:dejs:format (malt (limo ~[['foo' `1] ['bar' ~]])))
1550+~
1551+```
content/docs/hoon/reference/zuse/2d_7.mdnew file+1307
@@ -0,0 +1,1307 @@
1++++
2+title = "2d(7): From JSON (unit)"
3+weight = 44
4+template = "doc.html"
5++++
6+
7+## `++dejs-soft:format`
8+
9+Container arm for unitized JSON decoding reparsers
10+
11+The `core` inside this arm contains a large collection of functions for converting `json` data to `unit`s of various kinds. The `json` type is defined in `lull.hoon` as:
12+
13+```hoon
14++$ json :: normal json value
15+ $@ ~ :: null
16+ $% [%a p=(list json)] :: array
17+ [%b p=?] :: boolean
18+ [%o p=(map @t json)] :: object
19+ [%n p=@ta] :: number
20+ [%s p=@t] :: string
21+ == ::
22+```
23+
24+This container arm doesn't do anything by itself. It just contains the core with the rest of the `+dejs-soft` functions which are documented below, plus it defines a couple of things for those functions:
25+
26+```hoon
27+=> |% ++ grub (unit *)
28+ ++ fist $-(json grub)
29+ --
30+```
31+
32+A `fist` is a `gate` which takes `json` and produces a `grub`. Apart from a handful of exceptions, all of the functions below are `fist`s. If the functions below aren't adequate for a particular use case, custom `fist`s can easily be written, as long as they conform to the `$-(json grub)` type definition.
33+
34+A `grub` is just defined as `(unit *)`, and is the type of the product of a `fist`. In the case of `+dejs-soft`, it can be any noun in a `unit`.
35+
36+Keep in mind that `+grub:dejs-soft:format` and `+fist:dejs-soft:format` defined here (and subsequently referred to as simply `fist` and `grub`) are different to `+grub:dejs:format` and `+fist:dejs:format` for the [+dejs](/docs/hoon/reference/zuse/2d_6) functions, which simply return `noun`s rather than `unit`s.
37+
38+---
39+
40+### `++ar:dejs-soft:format`
41+
42+Array as list (in unit)
43+
44+Convert array `jon` to a list, decoding each item in `jon` with `wit`. The result is wrapped in a unit which is null if the decoding failed.
45+
46+The `+ar` function is a wet gate that takes `wit` and produces a new gate which takes `jon`.
47+
48+#### Accepts
49+
50+`wit` is a `fist` and is the sample of the wet gate.
51+
52+`jon` is a `json` array containing the kind of `json` that `wit` handles. `jon` is the sample of the gate produced by the wet gate.
53+
54+#### Produces
55+
56+A `(unit (list [type]))` where `[type]` is the type produced by `wit`. The `unit` is null if decoding fails.
57+
58+#### Source
59+
60+```hoon
61+++ ar
62+ |* wit=fist
63+ |= jon=json
64+ ?. ?=([%a *] jon) ~
65+ %- zl
66+ |-
67+ ?~ p.jon ~
68+ [i=(wit i.p.jon) t=$(p.jon t.p.jon)]
69+```
70+
71+#### Examples
72+
73+```
74+> ((ar so):dejs-soft:format a+~[s+'foo' s+'bar' s+'baz'])
75+[~ [i='foo' t=<|bar baz|>]]
76+```
77+
78+```
79+> ((ar so):dejs-soft:format a+~[n+'123' s+'bar' s+'baz'])
80+~
81+```
82+
83+---
84+
85+### `++at:dejs-soft:format`
86+
87+Array as tuple (in unit)
88+
89+Convert array `jon` to a tuple, decoding each item in the array with the corresponding `fist` in list `wil`. The result is wrapped in a unit which is null if the decoding failed.
90+
91+The `+at` function is a wet gate that takes `wil` and produces a new gate which takes `jon`.
92+
93+#### Accepts
94+
95+`wil` is a `(pole fist)`, and is the sample of the wet gate. A `pole` is a faceless list.
96+
97+`jon` is a `json` array whose elements are the same kinds of `json` accepted by the `fist`s in `wil` and in the same order. `jon` is the sample of the gate produced by the wet gate.
98+
99+#### Produces
100+
101+A `(unit [n])` where `[n]` is a tuple containing items of the same type and in the same order as those produced by the `fist`s in `wil`. The `unit` is null if decoding failed.
102+
103+#### Source
104+
105+```hoon
106+++ at
107+ |* wil=(pole fist)
108+ |= jon=json
109+ ?. ?=([%a *] jon) ~
110+ ?. =((lent wil) (lent p.jon)) ~
111+ =+ raw=((at-raw wil) p.jon)
112+ ?.((za raw) ~ (some (zp raw)))
113+```
114+
115+#### Examples
116+
117+```
118+> ((at ~[so ni bo]):dejs-soft:format a+~[s+'foo' n+'123' b+&])
119+[~ ['foo' 123 %.y]]
120+```
121+
122+```
123+> ((at ~[so ni bo]):dejs-soft:format a+~[n+'123' s+'foo' b+&])
124+~
125+```
126+
127+---
128+
129+### `++at-raw:dejs-soft:format`
130+
131+Array as tuple, raw (unitized)
132+
133+This function is used internally by [+at](#atdejs-softformat) and would not typically be used directly.
134+
135+`+at-raw` converts list `jol` to a new list, decoding each item in the list with the corresponding function in list `wil`. Each item in the list gets wrapped in a unit, and any item whose decoding fails is null.
136+
137+The `+at-raw` function is a wet gate that takes `wil` and produces a new gate which takes `jol`.
138+
139+#### Accepts
140+
141+`wil` is a `(pole fist)`, and the sample of the wet gate. A `pole` is a faceless list.
142+
143+`jol` is a `(list json)` whose items are the same kinds of `json` accepted by the `fist`s in `wil` and in the same order. `jol` is the sample of the gate produced by the wet gate.
144+
145+#### Produces
146+
147+A list of the types and in the same order as those produced by the `fist`s in `wil`. Each item is wrapped in a unit and any item whose decoding fails is null.
148+
149+#### Source
150+
151+```hoon
152+++ at-raw
153+ |* wil=(pole fist)
154+ |= jol=(list json)
155+ ?~ wil ~
156+ :- ?~(jol ~ (-.wil i.jol))
157+ ((at-raw +.wil) ?~(jol ~ t.jol))
158+```
159+
160+#### Examples
161+
162+```
163+> ((at-raw ~[so ni bo]):dejs-soft:format ~[s+'foo' n+'123' b+&])
164+[[~ 'foo'] [~ 123] [~ %.y] ~]
165+```
166+
167+```
168+> ((at-raw ~[so ni bo]):dejs-soft:format ~[s+'foo' b+| b+&])
169+[[~ 'foo'] ~ [~ %.y] ~]
170+```
171+
172+---
173+
174+### `++bo:dejs-soft:format`
175+
176+Boolean (in unit)
177+
178+Convert boolean `jon` to a `?` and wrap the result in a unit. If decoding fails the unit is null.
179+
180+#### Accepts
181+
182+`jon` is a `json` boolean.
183+
184+#### Produces
185+
186+A `?` wrapped in a `unit`. The unit is null if the decoding failed.
187+
188+#### Source
189+
190+```hoon
191+++ bo
192+ |=(jon=json ?.(?=([%b *] jon) ~ [~ u=p.jon]))
193+```
194+
195+#### Examples
196+
197+```
198+> (bo:dejs-soft:format b+|)
199+[~ %.n]
200+```
201+
202+```
203+> (bo:dejs-soft:format n+'123')
204+~
205+```
206+
207+---
208+
209+### `++bu:dejs-soft:format`
210+
211+Boolean NOT (in unit)
212+
213+Convert the logical NOT of boolean `jon` to a `?`. The result is wrapped in a unit, if the decoding fails the unit is null.
214+
215+#### Accepts
216+
217+`jon` is a `json` boolean.
218+
219+#### Produces
220+
221+A `(unit ?)`. The `unit` is `~` if the decoding failed.
222+
223+#### Source
224+
225+```hoon
226+++ bu
227+ |=(jon=json ?.(?=([%b *] jon) ~ [~ u=!p.jon]))
228+```
229+
230+#### Examples
231+
232+```
233+> (bu:dejs-soft:format b+&)
234+[~ %.n]
235+```
236+
237+```
238+> (bu:dejs-soft:format n+'123')
239+~
240+```
241+
242+---
243+
244+### `++ci:dejs-soft:format`
245+
246+Maybe transform (in unit)
247+
248+Decode `jon` with `wit`, then transform it with gate `poq` which produces a unit. If the unit is null or the decoding fails it produces `~`, otherwise it produces the unit.
249+
250+The `+ci` function is a wet gate that takes a `poq` and `wit` and produces a new gate that takes `jon`.
251+
252+#### Accepts
253+
254+The wet gate takes `[poq wit]`, where `poq` is a `gate` that produces a `unit` and `wit` is a `fist`.
255+
256+`jon` is `json` of the kind accepted by `wit`. `jon` is the sample of the gate produced by the wet gate.
257+
258+#### Produces
259+
260+Produces `(unit [type])`, where `[type]` is the type of the data in the `unit` produced by `poq`. The `unit` is `~` if the decoding failed or if the `unit` produced by `poq` is `~`.
261+
262+#### Source
263+
264+```hoon
265+++ ci
266+ |* [poq=gate wit=fist]
267+ |= jon=json
268+ (biff (wit jon) poq)
269+```
270+
271+#### Examples
272+
273+```
274+> ((ci |=(a=? ?:(=(a &) `'foo' ~)) bo):dejs-soft:format b+&)
275+[~ 'foo']
276+```
277+
278+```
279+> ((ci |=(a=? ?:(=(a &) `'foo' ~)) bo):dejs-soft:format b+|)
280+~
281+```
282+
283+```
284+> ((ci |=(a=? ?:(=(a &) `'foo' ~)) bo):dejs-soft:format n+'123')
285+~
286+```
287+
288+---
289+
290+### `++cu:dejs-soft:format`
291+
292+Transform (in unit)
293+
294+Decode `jon` with `wit`, then transform it with gate `poq`. The result is wrapped in a unit, which is null if the decoding failed.
295+
296+The `+cu` function is a wet gate that takes `poq` and `wit` and produces a new gate that takes `jon`.
297+
298+#### Accepts
299+
300+The wet gate takes `[poq wit]`, where `poq` is a `gate` and `wit` is a `fist`.
301+
302+`jon` is `json` of the kind handled by `wit`. `jon` is the sample of the gate produced by the wet gate.
303+
304+#### Produces
305+
306+`(unit [type])`, where `[type]` is the type produced by the gate given in `poq`. The `unit` is `~` if the decoding failed.
307+
308+#### Source
309+
310+```hoon
311+++ cu
312+ |* [poq=gate wit=fist]
313+ |= jon=json
314+ (bind (wit jon) poq)
315+```
316+
317+#### Examples
318+
319+```
320+> ((cu |=(a=? ?:(=(a &) 'foo' ~)) bo):dejs-soft:format b+&)
321+[~ 'foo']
322+```
323+
324+```
325+> ((cu |=(a=? ?:(=(a &) 'foo' ~)) bo):dejs-soft:format b+|)
326+[~ ~]
327+```
328+
329+```
330+> ((cu |=(a=? ?:(=(a &) 'foo' ~)) bo):dejs-soft:format n+'123')
331+~
332+```
333+
334+---
335+
336+### `++da:dejs-soft:format`
337+
338+UTC date (in unit)
339+
340+Convert string `jon` to a `@da`, parsing it as a UTC date & time string, e.g.`'Thu, 09 Sep 2021 05:58:52'`. Note the inclusion of a timezone offset like `+1200` will pass the parser but will be ignored. The result is wrapped in a unit, which is null if decoding or parsing failed.
341+
342+#### Accepts
343+
344+`jon` is a `json` string encoding a UTC date & time string.
345+
346+#### Produces
347+
348+A `@da`.
349+
350+#### Examples
351+
352+```
353+> (da:dejs-soft:format s+'Thu, 09 Sep 2021 05:58:52')
354+[~ ~2021.9.9..05.58.52]
355+```
356+
357+```
358+> (da:dejs-soft:format s+'09 Sep 2021 05:58:52')
359+[~ ~2021.9.9..05.58.52]
360+```
361+
362+```
363+> (da:dejs-soft:format s+'Thu, 09 Sep 2021 05:58:52 +1200')
364+[~ ~2021.9.9..05.58.52]
365+```
366+
367+```
368+> (da:dejs-soft:format s+'gkjeagkja')
369+~
370+```
371+
372+```
373+> (da:dejs-soft:format b+&)
374+~
375+```
376+
377+---
378+
379+### `++dank:dejs-soft:format`
380+
381+Tank (in unit)
382+
383+Convert `jon`, a `json`-encoded `tank`, to a `tank`. The result is wrapped in a unit and is null if decoding failed.
384+
385+#### Accepts
386+
387+`jon` is `json`.
388+
389+#### Produces
390+
391+A `(unit tank)`. The `unit` is `~` if decoding failed.
392+
393+#### Source
394+
395+```hoon
396+++ dank
397+ ^- $-(json (unit tank))
398+ %+ re *tank |. ~+
399+ %- of :~
400+ leaf+sa
401+ palm+(ot style+(ot mid+sa cap+sa open+sa close+sa ~) lines+(ar dank) ~)
402+ rose+(ot style+(ot mid+sa open+sa close+sa ~) lines+(ar dank) ~)
403+ ==
404+```
405+
406+#### Examples
407+
408+```
409+> =js-txt '{"rose":{"lines":[{"leaf":"foo"},{"leaf":"bar"},{"leaf":"baz"}],"style":{"mid":" ","close":"]","open":"["}}}'
410+> (dank:dejs-soft:format (need (de-json:html js-txt)))
411+[~ [%rose p=[p=" " q="[" r="]"] q=~[[%leaf p="foo"] [%leaf p="bar"] [%leaf p="baz"]]]]
412+> ~(ram re (need (dank:dejs-soft:format (need (de-json:html js-txt)))))
413+"[foo bar baz]"
414+```
415+
416+```
417+> (dank:dejs-soft:format (need (de-json:html '{"leaf":"foo"}')))
418+[~ [%leaf p="foo"]]
419+> ~(ram re (need (dank:dejs-soft:format (need (de-json:html '{"leaf":"foo"}')))))
420+"foo"
421+```
422+
423+```
424+> (dank:dejs-soft:format n+'123')
425+~
426+```
427+
428+---
429+
430+### `++di:dejs-soft:format`
431+
432+Millisecond date (in unit)
433+
434+Convert number `jon` containing milliseconds to a date. The result is wrapped in a unit which is null if decoding failed.
435+
436+#### Accepts
437+
438+`jon` is a `json` number.
439+
440+#### Produces
441+
442+A `(unit @da)`. The `unit` is `~` if decoding failed.
443+
444+#### Source
445+
446+```hoon
447+++ di
448+ (cu from-unix-ms:chrono:userlib ni)
449+```
450+
451+#### Examples
452+
453+```
454+> =time (time:enjs:format now)
455+> time
456+[%n p=~.1631177855330]
457+> (di:dejs-soft:format time)
458+[~ ~2021.9.9..08.57.35..547a.e147.ae14.7ae1]
459+```
460+
461+```
462+> (di:dejs-soft:format b+&)
463+~
464+```
465+
466+---
467+
468+### `++mu:dejs-soft:format`
469+
470+True unit (in unit)
471+
472+Decode `jon` with `wit`, then wrap it in two units. The inner unit is null if `jon` was null, the outer unit is null if decoding failed.
473+
474+The `+mu` function is a wet gate that takes `wit` and produces a gate which takes `jon`.
475+
476+#### Accepts
477+
478+`wit` is a `fist`, and is the sample of the wet gate.
479+
480+`jon` is `json` of the kind `wit` handles. `jon` is the sample of the gate produced by the wet gate.
481+
482+#### Produces
483+
484+A `(unit (unit [type]))`, where `[type]` is the type produced by `wit`. The inner `unit` is `~` if `jon` was null, the outer `unit` is `~` if decoding failed.
485+
486+#### Source
487+
488+```hoon
489+++ mu
490+ |* wit=fist
491+ |= jon=json
492+ ?~(jon (some ~) (bind (wit jon) some))
493+```
494+
495+#### Examples
496+
497+```
498+> ((mu so):dejs-soft:format s+'foo')
499+[~ [~ u='foo']]
500+```
501+
502+```
503+> ((mu so):dejs-soft:format ~)
504+[~ u=~]
505+```
506+
507+```
508+> ((mu so):dejs-soft:format b+&)
509+~
510+```
511+
512+---
513+
514+### `++ne:dejs-soft:format`
515+
516+Number as real (in unit)
517+
518+Convert number `jon` to a `@rd` and wrap the result in a unit. The unit is null if decoding failed.
519+
520+#### Accepts
521+
522+`jon` is a `json` number.
523+
524+#### Produces
525+
526+A `(unit @rd)`. The `unit` is `~` if decoding failed.
527+
528+#### Source
529+
530+```hoon
531+++ ne
532+ |= jon=json
533+ ^- (unit @rd)
534+ ?. ?=([%n *] jon) ~
535+ (rush p.jon (cook ryld (cook royl-cell:^so json-rn)))
536+```
537+
538+#### Examples
539+
540+```
541+> (ne:dejs-soft:format n+'123')
542+[~ .~123]
543+```
544+
545+```
546+> (ne:dejs-soft:format n+'2.47')
547+[~ .~2.47]
548+```
549+
550+```
551+> (ne:dejs-soft:format b+&)
552+~
553+```
554+
555+---
556+
557+### `++ni:dejs-soft:format`
558+
559+Number as integer (in unit)
560+
561+Convert number `jon` to a `@ud` and wrap it in a unit. If `jon` is not an integer or if decoding otherwise failed, the unit is null.
562+
563+#### Accepts
564+
565+`jon` is a `json` number.
566+
567+#### Produces
568+
569+A `(unit @ud)`. The `unit` is `~` if `jon` was not an integer or if decoding otherwise failed.
570+
571+#### Source
572+
573+```hoon
574+++ ni
575+ |= jon=json
576+ ?. ?=([%n *] jon) ~
577+ (rush p.jon dem)
578+```
579+
580+#### Examples
581+
582+```
583+> (ni:dejs-soft:format n+'123')
584+[~ 123]
585+```
586+
587+```
588+> (ni:dejs-soft:format n+'2.47')
589+~
590+```
591+
592+```
593+> (ni:dejs-soft:format b+&)
594+~
595+```
596+
597+---
598+
599+### `++no:dejs-soft:format`
600+
601+Number as knot (in unit)
602+
603+Convert number `jon` to a `@ta` and wrap it in a unit. The result is null if decoding failed.
604+
605+#### Accepts
606+
607+`jon` is a `json` number.
608+
609+#### Produces
610+
611+A `(unit @ta)`. The `unit` is `~` if decoding failed.
612+
613+#### Source
614+
615+```hoon
616+++ no
617+ |= jon=json
618+ ?. ?=([%n *] jon) ~
619+ (some p.jon)
620+```
621+
622+#### Examples
623+
624+```
625+> (no:dejs-soft:format n+'2.47')
626+[~ ~.2.47]
627+```
628+
629+```
630+> (no:dejs-soft:format n+'123')
631+[~ ~.123]
632+```
633+
634+```
635+> (no:dejs-soft:format b+&)
636+~
637+```
638+
639+---
640+
641+### `++of:dejs-soft:format`
642+
643+Object as frond (in unit)
644+
645+Convert object `jon`, which contains a single key-value pair, to a key-value tuple using the `fist` in `wer` which matches the key. The result is wrapped in a unit which is null if the key couldn't be found in `wer` or if the decoding failed.
646+
647+The `+of` function is a wet gate that takes a list of pairs of keys and `fist`s and produces a new gate that takes `json`.
648+
649+**Note:** While technically the type of an item in the list `wer` is specified as `[cord fist]`, actually using a `cord` may result in incorrect type inferrence. Instead, you'll want to format it as a `@tas` like `%foo`, so the type system correctly interprets it as a tagged union. If the key contains characters that would be invalid in an ordinary `@tas`, you can format it like `%'foo_bar'` - a `%` then single quotes.
650+
651+#### Accepts
652+
653+`wer` is a `(pole [cord fist])`, and is the sample of the wet gate. A `pole` is a faceless `list`.
654+
655+`jon` is a `json` object containing a single key. `jon` is the sample of the gate produced by the wet gate.
656+
657+#### Produces
658+
659+A `(unit [@t [type]])` where `[type]` is the type produced by the matching `fist`. The `unit` is `~` if decoding failed or the key could not be found.
660+
661+#### Source
662+
663+```hoon
664+++ of
665+ |* wer=(pole [cord fist])
666+ |= jon=json
667+ ?. ?=([%o [@ *] ~ ~] jon) ~
668+ |-
669+ ?~ wer ~
670+ ?: =(-.-.wer p.n.p.jon)
671+ ((pe -.-.wer +.-.wer) q.n.p.jon)
672+ ((of +.wer) jon)
673+```
674+
675+#### Examples
676+
677+First, let's store some objects containing key-value pairs:
678+
679+```
680+> =obj-1 o+(malt ['foo' s+'hello']~)
681+> (crip (en-json:html obj-1))
682+'{"foo":"hello"}'
683+```
684+
685+```
686+> =obj-2 o+(malt ~[['bar' a+~[n+'123' n+'456']]])
687+> (crip (en-json:html obj-2))
688+'{"bar":[123,456]}'
689+```
690+
691+```
692+> =obj-3 o+(malt ['baz' b+&]~)
693+> (crip (en-json:html obj-3))
694+'{"baz":true}'
695+```
696+
697+Next, let's construct a `+of` function and try it on our objects:
698+
699+```
700+> ((of ~[foo+so bar+(ar ni)]):dejs-soft:format obj-1)
701+[~ [%foo 'hello']]
702+```
703+
704+```
705+> ((of ~[foo+so bar+(ar ni)]):dejs-soft:format obj-2)
706+[~ [%bar [i=123 t=~[456]]]]
707+```
708+
709+```
710+> ((of ~[foo+so bar+(ar ni)]):dejs-soft:format obj-3)
711+~
712+```
713+
714+```
715+> ((of ~[foo+so bar+(ar ni)]):dejs-soft:format b+&)
716+~
717+```
718+
719+---
720+
721+### `++ot:dejs-soft:format`
722+
723+Object as tuple (in unit)
724+
725+Convert object `jon` to a tuple by decoding each value with the matching `fist` in `wer`. Each key in `wer` must be matched to a key in `jon`. On the other hand, if there are keys in `jon` with no corresponding key in `wer`, they'll simply be ignored. The result is wrapped in a unit which is null if decoding failed.
726+
727+The `+ot` function is a wet gate that takes a list of key-`fist` pairs, and produces a gate which takes `json`.
728+
729+**Note:** While technically the type of an item in the list `wer` is specified as `[cord fist]`, actually using a `cord` may result in incorrect type inferrence. Instead, you'll want to format it as a `@tas` like `%foo`, so the type system correctly interprets it as a tagged union. If the key contains characters that would be invalid in an ordinary `@tas`, you can format it like `%'foo_bar'` - a `%` then single quotes.
730+
731+#### Accepts
732+
733+`wer` is a `(pole [cord fist])`, and is the sample of the wet gate. A `pole` is a faceless list.
734+
735+`jon` is a `json` object, and is the sample of the gate produced by the wet gate.
736+
737+#### Produces
738+
739+A `(unit [tuple])` where the type of each item in `[tuple]` is the product of the corresponding `fist` in `wer`. The order of items in the tuple will match the order of items in `wer`. The `unit` is `~` if decoding failed.
740+
741+#### Source
742+
743+```hoon
744+++ ot
745+ |* wer=(pole [cord fist])
746+ |= jon=json
747+ ?. ?=([%o *] jon) ~
748+ =+ raw=((ot-raw wer) p.jon)
749+ ?.((za raw) ~ (some (zp raw)))
750+```
751+
752+#### Examples
753+
754+```
755+> %- (ot ~[foo+so bar+ni]):dejs-soft:format
756+ o+(malt (limo ~[['bar' n+'123'] ['foo' s+'hello'] ['baz' b+&]]))
757+[~ ['hello' 123]]
758+```
759+
760+```
761+> %- (ot ~[foo+so bar+ni]):dejs-soft:format
762+ o+(malt (limo ~[['bar' n+'123'] ['baz' b+&]]))
763+~
764+```
765+
766+---
767+
768+### `++ot-raw:dejs-soft:format`
769+
770+Object as list of units, raw
771+
772+This function is used internally by [+ot](#otdejs-softformat) and would not typically be used directly.
773+
774+`+ot-raw` converts map `jom` to a list of units by decoding each value with the matching `fist` in `wer`, then wrapping them in a unit. Any key in `wer` which cannot be matched to a key in `jon` is null in the resulting list. If there are keys in `jom` with no corresponding key in `wer`, they'll simply be ignored.
775+
776+The `+ot-raw` function is a wet gate that takes a list of key-`fist` pairs, and produces a gate which takes a map of keys to `json`.
777+
778+**Note:** While technically the type of an item in the list `wer` is specified as `[cord fist]`, actually using a `cord` may result in incorrect type inferrence. Instead, you'll want to format it as a `@tas` like `%foo`, so the type system correctly interprets it as a tagged union. If the key contains characters that would be invalid in an ordinary `@tas`, you can format it like `%'foo_bar'` - a `%` then single quotes.
779+
780+#### Accepts
781+
782+`wer` is a `(pole [cord fist])`, and is the sample of the wet gate. A `pole` is a faceless list.
783+
784+`jom` is a `(map @t json)`, and is the sample of the gate produced by the wet gate.
785+
786+#### Produces
787+
788+A `(list (unit))`, where the type of the data in each `unit` is the product of the corresponding `fist` in `wer`. The order of items in the list will match the order of items in `wer`. Any keys in `wer` which couldn't be matched will be `~` in the resulting list.
789+
790+#### Source
791+
792+```hoon
793+++ ot-raw
794+ |* wer=(pole [cord fist])
795+ |= jom=(map @t json)
796+ ?~ wer ~
797+ =+ ten=(~(get by jom) -.-.wer)
798+ [?~(ten ~ (+.-.wer u.ten)) ((ot-raw +.wer) jom)]
799+```
800+
801+#### Examples
802+
803+```
804+> %- (ot-raw ~[foo+so bar+ni]):dejs-soft:format
805+ (malt (limo ~[['bar' n+'123'] ['foo' s+'hello'] ['baz' b+&]]))
806+[[~ 'hello'] [~ 123] ~]
807+```
808+
809+```
810+> %- (ot-raw ~[foo+so bar+ni]):dejs-soft:format
811+ (malt (limo ~[['bar' n+'123'] ['baz' b+&]]))
812+[~ [~ 123] ~]
813+```
814+
815+---
816+
817+### `++om:dejs-soft:format`
818+
819+Object as map (in unit)
820+
821+Convert object `jon` to a map, decoding each value with `wit`. The result is wrapped in a unit which is null if decoding failed.
822+
823+The `+om` function is a wet gate that takes `wit` and produces a gate that takes `jon`.
824+
825+#### Accepts
826+
827+`wit` is a `fist`, and is the sample of the wet gate.
828+
829+`jon` is a `json` object whose values are the kind of `json` that `wit` takes. `jon` is the sample of the gate produced by the wet gate.
830+
831+#### Produces
832+
833+A `(unit (map @t [type]))`, where `[type]` is the type produced by `wit`. The `unit` is `~` if decoding failed.
834+
835+#### Source
836+
837+```hoon
838+++ om
839+ |* wit=fist
840+ |= jon=json
841+ ?. ?=([%o *] jon) ~
842+ (zm (~(run by p.jon) wit))
843+```
844+
845+#### Examples
846+
847+```
848+> =jon (need (de-json:html '{"foo":"aaa","bar":"bbb"}'))
849+> ((om so):dejs-soft:format jon)
850+[~ {[p='bar' q='bbb'] [p='foo' q='aaa']}]
851+```
852+
853+```
854+> ((om so):dejs-soft:format b+&)
855+~
856+```
857+
858+---
859+
860+### `++op:dejs-soft:format`
861+
862+Parse keys of map (in unit)
863+
864+Convert object `jon` to a map, parsing each key with `fel` and decoding each value with `wit`. The result is wrapped in a unit which is null if decoding or parsing failed.
865+
866+The `+op` function is a wet gate that takes `fel` and `wit`, and produces a gate that takes `jon`.
867+
868+#### Accepts
869+
870+The wet gate takes a cell of `[fel wil]`, where `fel` is a parsing `rule` and `wil` is a `fist`.
871+
872+`jon` is a `json` object, whose keys are parsable by `fel` and whose values are `json` of the kind `wit` takes. `jon` is the sample of the gate produced by the wet gate.
873+
874+#### Produces
875+
876+A `(unit (map [a] [b]))` where `[a]` is the type produced by `fel` and `[b]` is the type produced by `wit`. The `unit` is `~` if decoding or parsing failed.
877+
878+#### Source
879+
880+```hoon
881+++ op
882+ |* [fel=rule wit=fist]
883+ |= jon=json ^- (map _(wonk *fel) _*wit)
884+ =/ jom ((om wit) jon)
885+ %- malt
886+ %+ turn ~(tap by jom)
887+ |* [a=cord b=*]
888+ => .(+< [a b]=+<)
889+ [(rash a fel) b]
890+```
891+
892+#### Examples
893+
894+```
895+> =jon (need (de-json:html '{"123":"aaa","456":"bbb"}'))
896+> ((op dem so):dejs-soft:format jon)
897+[~ u={[p=456 q='bbb'] [p=123 q='aaa']}]
898+```
899+
900+---
901+
902+### `++pe:dejs-soft:format`
903+
904+Prefix (in unit)
905+
906+Decode `jon` with `wit`, prefix it with `pre`, then wrap the result in a unit which is null if decoding failed.
907+
908+The `+pe` function is a wet gate that takes `pre` and `wit`, and produces a gate that takes `jon`.
909+
910+#### Accepts
911+
912+The wet gate takes a cell of `[pre wit]`, where `pre` is any noun and `wit` is a `fist`.
913+
914+`jon` is `json` of the kind accepted by `wit`. `jon` is the sample of the gate produced by the wet gate.
915+
916+#### Produces
917+
918+A `(unit [[a] [b]])`, where `[a]` is the noun given in `pre` and `[b]` is the type produced by `wit`. The `unit` is `~` if decoding failed.
919+
920+#### Source
921+
922+```hoon
923+++ pe
924+ |* [pre=* wit=fist]
925+ (cu |*(* [pre +<]) wit)
926+```
927+
928+#### Examples
929+
930+```
931+> ((pe %foo so):dejs-soft:format s+'abc')
932+[~ [%foo 'abc']]
933+```
934+
935+```
936+> ((pe %foo so):dejs-soft:format b+&)
937+~
938+```
939+
940+---
941+
942+### `++re:dejs-soft:format`
943+
944+Recursive reparser
945+
946+This function facilitates recursion in other `fist`s. It is used internally by some functions and would not typically be used directly. `jon` is decoded by the `fist` in the trap `sef` and cast to the type of the noun given in `gar`. The result is wrapped in a unit which is null if decoding failed.
947+
948+`+re` is a wet gate that takes a cell of `gar` and `sef`, and produces a gate which takes `jon`.
949+
950+#### Accepts
951+
952+`gar` is any `noun`, its type determines the return type.
953+
954+`sef` is a `|.(fist)`.
955+
956+The wet gate takes `[gar sef]`.
957+
958+`jon` is `json` of the kind handled by the `fist` in `sef`, and is the sample of the gate produced by the wet gate.
959+
960+#### Produces
961+
962+A `(unit [type])` where `[type]` is the type of `gar`.
963+
964+#### Source
965+
966+```hoon
967+++ re
968+ |* [gar=* sef=_|.(fist)]
969+ |= jon=json
970+ ^- (unit _gar)
971+ ((sef) jon)
972+```
973+
974+#### Examples
975+
976+The basic format looks like so:
977+
978+```
979+> ((re *@t |.(so)):dejs-soft:format s+'abc')
980+[~ 'abc']
981+```
982+
983+```
984+> ((re *@t |.(so)):dejs-soft:format b+&)
985+~
986+```
987+
988+For a recursive example, see its usage in the source of [+dank](#dankdejs-softformat).
989+
990+---
991+
992+### `++sa:dejs-soft:format`
993+
994+String as tape (in unit)
995+
996+Convert `jon` to a `tape` and wrap the result in a unit, which is null if the decoding failed.
997+
998+#### Accepts
999+
1000+`jon` is a `json` string.
1001+
1002+#### Produces
1003+
1004+A `(unit tape)`. The `unit` is `~` if decoding failed.
1005+
1006+#### Source
1007+
1008+```hoon
1009+++ sa
1010+ |= jon=json
1011+ ?.(?=([%s *] jon) ~ (some (trip p.jon)))
1012+```
1013+
1014+#### Examples
1015+
1016+```
1017+> (sa:dejs-soft:format s+'foo')
1018+[~ "foo"]
1019+```
1020+
1021+```
1022+> (sa:dejs-soft:format b+&)
1023+~
1024+```
1025+
1026+---
1027+
1028+### `++so:dejs-soft:format`
1029+
1030+String as cord (in unit)
1031+
1032+Convert `jon` to a cord and wrap it in a unit. The unit is null if decoding failed.
1033+
1034+#### Accepts
1035+
1036+`jon` is a `json` string.
1037+
1038+#### Produces
1039+
1040+A `(unit @t)`. The `unit` is `~` if decoding failed.
1041+
1042+#### Source
1043+
1044+```hoon
1045+++ so
1046+ |= jon=json
1047+ ?.(?=([%s *] jon) ~ (some p.jon))
1048+```
1049+
1050+#### Examples
1051+
1052+```
1053+> (so:dejs-soft:format s+'foo')
1054+[~ 'foo']
1055+```
1056+
1057+```
1058+> (so:dejs-soft:format b+&)
1059+~
1060+```
1061+
1062+---
1063+
1064+### `++su:dejs-soft:format`
1065+
1066+Parse string (in unit)
1067+
1068+Convert and parse `jon` with `sab`, then wrap the result in a unit. The unit is null if parsing or decoding failed.
1069+
1070+The `+su` function is a wet gate that takes `sab`, and produces a gate that takes `jon`.
1071+
1072+#### Accepts
1073+
1074+`sab` is a parsing `rule`, and is the sample of the wet gate.
1075+
1076+`jon` is a `json` string, and is the sample of the gate produced by the wet gate.
1077+
1078+#### Produces
1079+
1080+A `(unit [type])`, where `[type]` is the type produced by `sab`.
1081+
1082+#### Source
1083+
1084+```hoon
1085+++ su
1086+ |* sab=rule
1087+ |= jon=json
1088+ ?. ?=([%s *] jon) ~
1089+ (rush p.jon sab)
1090+```
1091+
1092+#### Examples
1093+
1094+```
1095+> ((su dem):dejs-soft:format s+'123456')
1096+[~ 123.456]
1097+```
1098+
1099+```
1100+> `(unit @ub)`((su bin):dejs-soft:format s+'00001011101110001101')
1101+[~ 0b1011.1011.1000.1101]
1102+```
1103+
1104+```
1105+> ((su dem):dejs-soft:format s+'abc')
1106+~
1107+```
1108+
1109+```
1110+> ((su dem):dejs-soft:format b+&)
1111+~
1112+```
1113+
1114+---
1115+
1116+### `++ul:dejs-soft:format`
1117+
1118+Null (in unit)
1119+
1120+Return `[~ ~]` if `jon` is null or else return `~`.
1121+
1122+#### Accepts
1123+
1124+`jon` is null `json`.
1125+
1126+#### Produces
1127+
1128+A `(unit ~)`. The `unit` is `~` if `jon` is not `~`.
1129+
1130+#### Source
1131+
1132+```hoon
1133+++ ul |=(jon=json ?~(jon (some ~) ~))
1134+```
1135+
1136+#### Examples
1137+
1138+```
1139+> (ul:dejs-soft:format ~)
1140+[~ ~]
1141+```
1142+
1143+```
1144+> (ul:dejs-soft:format b+&)
1145+~
1146+```
1147+
1148+### `++za:dejs-soft:format`
1149+
1150+Full unit pole
1151+
1152+Check whether all units in list `pod` are non-null. This is used internally by some functions and would not typically be used directly.
1153+
1154+#### Accepts
1155+
1156+`pod` is a `(pole (unit))`. A `pole` is a faceless list.
1157+
1158+#### Produces
1159+
1160+A `?`, which is `%.n` if any of the `unit`s in `pod` are `~`, and `%.y` otherwise.
1161+
1162+#### Source
1163+
1164+```hoon
1165+++ za
1166+ |* pod=(pole (unit))
1167+ ?~ pod &
1168+ ?~ -.pod |
1169+ (za +.pod)
1170+```
1171+
1172+#### Examples
1173+
1174+```
1175+> (za:dejs-soft:format ~[`1 `2 `3 `4])
1176+%.y
1177+```
1178+
1179+```
1180+> (za:dejs-soft:format ~)
1181+%.y
1182+```
1183+
1184+```
1185+> (za:dejs-soft:format ~[`1 `2 ~ `4])
1186+%.n
1187+```
1188+
1189+---
1190+
1191+### `++zl:dejs-soft:format`
1192+
1193+Collapse unit list
1194+
1195+Convert `lut`, a list of units, to a `(unit (list))` by stripping the unit from each item. The resulting unit is null if any of the units in the list are null. This is used internally by some functions, you would not typically use it directly.
1196+
1197+#### Accepts
1198+
1199+A `(list (unit))`.
1200+
1201+#### Produces
1202+
1203+A `(unit (list))` which is null if any of the units in `lut` were null.
1204+
1205+#### Source
1206+
1207+```hoon
1208+++ zl
1209+ |* lut=(list (unit))
1210+ ?. |- ^- ?
1211+ ?~(lut & ?~(i.lut | $(lut t.lut)))
1212+ ~
1213+ %- some
1214+ |-
1215+ ?~ lut ~
1216+ [i=u:+.i.lut t=$(lut t.lut)]
1217+```
1218+
1219+#### Examples
1220+
1221+```
1222+> (zl:dejs-soft:format (limo ~[`1 `2 `3 `4 `5 `6]))
1223+[~ [i=1 t=~[2 3 4 5 6]]]
1224+```
1225+
1226+```
1227+> (zl:dejs-soft:format (limo ~[`1 `2 ~ `4 `5 `6]))
1228+~
1229+```
1230+
1231+---
1232+
1233+### `++zp:dejs-soft:format`
1234+
1235+Unit tuple
1236+
1237+Convert `but`, a list of units, to a tuple by stripping the unit from each item. Crashes if any of the units are null. This is used internally by some functions, you would not typically use it directly.
1238+
1239+#### Accepts
1240+
1241+`but` is a `(pole (unit))`. A `pole` is a faceless list.
1242+
1243+#### Produces
1244+
1245+A tuple containing each unwrapped element from the original list, or crashes if any of the units were null.
1246+
1247+#### Source
1248+
1249+```hoon
1250+++ zp
1251+ |* but=(pole (unit))
1252+ ?~ but !!
1253+ ?~ +.but
1254+ u:->.but
1255+ [u:->.but (zp +.but)]
1256+```
1257+
1258+#### Examples
1259+
1260+```
1261+> (zp:dejs-soft:format ~[`1 `2 `3 `4 `5 `6])
1262+[1 2 3 4 5 6]
1263+```
1264+
1265+```
1266+> (zp:dejs-soft:format ~[`1 `2 ~ `4 `5 `6])
1267+mull-none
1268+dojo: hoon expression failed
1269+```
1270+
1271+---
1272+
1273+### `++zm:dejs-soft:format`
1274+
1275+Collapse unit map
1276+
1277+Strip units from values in `lum`, a map of units. Returns null if any of the units are null. This is used internally by some functions, you would not typically use it directly.
1278+
1279+#### Accepts
1280+
1281+`lum` is a `(map term (unit))`
1282+
1283+#### Produces
1284+
1285+A `(unit (map term [type]))`, where `[type]` is the type the units in `lum` contained. Produces `~` if any of the units were null.
1286+
1287+#### Source
1288+
1289+```hoon
1290+++ zm
1291+ |* lum=(map term (unit))
1292+ ?: (~(rep by lum) |=([[@ a=(unit)] b=_|] |(b ?=(~ a))))
1293+ ~
1294+ (some (~(run by lum) need))
1295+```
1296+
1297+#### Examples
1298+
1299+```
1300+> (zm:dejs-soft:format (malt ~[['foo' `1] ['bar' `2]]))
1301+[~ {[p='bar' q=2] [p='foo' q=1]}]
1302+```
1303+
1304+```
1305+> (zm:dejs-soft:format (malt (limo ~[['foo' `1] ['bar' ~]])))
1306+~
1307+```
content/docs/hoon/reference/zuse/2e_2-3.mdnew file+67
@@ -0,0 +1,67 @@
1++++
2+title = "2e(2-3): Print & Parse JSON"
3+weight = 50
4+template = "doc.html"
5++++
6+
7+## `++en-json:html`
8+
9+Print json
10+
11+Encode `val`, a `json` structure, in a `tape`.
12+
13+#### Accepts
14+
15+`val` is any `json`.
16+
17+#### Produces
18+
19+A `tape`.
20+
21+#### Source
22+
23+This is a very large function, refer to `zuse.hoon` for the source code.
24+
25+#### Examples
26+
27+```
28+> (en-json:html s+'foo')
29+"\"foo\""
30+```
31+
32+```
33+> (en-json:html o+(malt (limo ~[['foo' s+'xxx'] ['bar' n+'123'] ['baz' b+&]])))
34+"\{\"foo\":\"xxx\",\"baz\":true,\"bar\":123}"
35+```
36+
37+---
38+
39+## `++de-json:html`
40+
41+Parse json
42+
43+Parse cord `a` to a `json` structure. The result is wrapped in a unit which is null if parsing failed.
44+
45+#### Accepts
46+
47+`a` is a `cord` in which JSON is encoded.
48+
49+#### Produces
50+
51+A `(unit json)`. The `unit` is `~` if parsing failed.
52+
53+#### Source
54+
55+This is a very large function, refer to `zuse.hoon` for the source code.
56+
57+#### Examples
58+
59+```
60+> (de-json:html '{"foo":"xxx","baz":true,"bar":123}')
61+[~ [%o p={[p='bar' q=[%n p=~.123]] [p='baz' q=[%b p=%.y]] [p='foo' q=[%s p='xxx']]}]]
62+```
63+
64+```
65+> (de-json:html '"foo"')
66+[~ [%s p='foo']]
67+```
content/docs/hoon/reference/zuse/_index.mdnew file+31
@@ -0,0 +1,31 @@
1++++
2+title = "Zuse"
3+weight = 50
4+sort_by = "weight"
5+template = "sections/docs/chapters.html"
6+insert_anchor_links = "right"
7++++
8+
9+Documentation for the `zuse.hoon` library.
10+
11+[Table of Contents](/docs/hoon/reference/zuse/table-of-contents)
12+
13+### 2d: Formatting functions
14+
15+[2d(1-5): To JSON, Wains](/docs/hoon/reference/zuse/2d_1-5)
16+
17+Functions for encoding/decoding line-lists and various JSON encoding functions.
18+
19+[2d(6): From JSON](/docs/hoon/reference/zuse/2d_6)
20+
21+Functions for decoding `json`.
22+
23+[2d(7): From JSON (unit)](/docs/hoon/reference/zuse/2d_7)
24+
25+Functions for decoding `json` to `unit`s.
26+
27+### 2e: Web Text Functions
28+
29+[2e(2-3): Print & Parse JSON](/docs/hoon/reference/zuse/2e_2-3)
30+
31+Print `json` and parse JSON.
content/docs/hoon/reference/zuse/table-of-contents.mdnew file+247
@@ -0,0 +1,247 @@
1++++
2+title = "Table of Contents"
3+weight = 0
4+sort_by = "weight"
5+template = "doc.html"
6++++
7+
8+Documentation for the Zuse library.
9+
10+Can be navigated [alphabetically](#alphabetical) or [by section](#by-section).
11+
12+## Alphabetical
13+
14+### a
15+
16+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_7/#ardejs-softformat' title="Decode json (unit): Array as list"><code>++ar:dejs-soft:format</code></a>
17+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#ardejsformat' title="Decode json: Array as list"><code>++ar:dejs:format</code></a>
18+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#asdejsformat' title="Decode json: Array as set"><code>++as:dejs:format</code></a>
19+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_7/#at-rawdejs-softformat' title="Decode json (unit): Array as tuple, raw"><code>++at-raw:dejs-soft:format</code></a>
20+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#at-rawdejsformat' title="Decode json: Array as tuple, raw"><code>++at-raw:dejs:format</code></a>
21+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_7/#atdejs-softformat' title="Decode json (unit): Array as tuple"><code>++at:dejs-soft:format</code></a>
22+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#atdejsformat' title="Decode json: Array as tuple"><code>++at:dejs:format</code></a>
23+
24+### b
25+
26+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_7/#bodejs-softformat' title="Decode json (unit): Boolean"><code>++bo:dejs-soft:format</code></a>
27+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#bodejsformat' title="Decode json: Boolean"><code>++bo:dejs:format</code></a>
28+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_7/#budejs-softformat' title="Decode json (unit): Boolean NOT"><code>++bu:dejs-soft:format</code></a>
29+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#budejsformat' title="Decode json: Boolean NOT"><code>++bu:dejs:format</code></a>
30+
31+### c
32+
33+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_7/#cidejs-softformat' title="Decode json (unit): Maybe transform"><code>++ci:dejs-soft:format</code></a>
34+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#cidejsformat' title="Decode json: Maybe transform"><code>++ci:dejs:format</code></a>
35+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_7/#cudejs-softformat' title="Decode json (unit): Transform"><code>++cu:dejs-soft:format</code></a>
36+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#cudejsformat' title="Decode json: Transform"><code>++cu:dejs:format</code></a>
37+
38+### d
39+
40+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_7/#dadejs-softformat' title="Decode json (unit): UTC date"><code>++da:dejs-soft:format</code></a>
41+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_7/#dankdejs-softformat' title="Decode json (unit): Tank"><code>++dank:dejs-soft:format</code></a>
42+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_7/#dejs-softformat' title="Container arm for unitized JSON decoding reparsers"><code>++dejs-soft:format</code></a>
43+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#dejsformat' title="Container arm for JSON decoding reparsers"><code>++dejs:format</code></a>
44+<a class="tooltip" href='/docs/hoon/reference/zuse/2e_2-3/#de-jsonhtml' title="Parse JSON"><code>++de-json:html</code></a>
45+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_7/#didejs-softformat' title="Decode json (unit): Millisecond date"><code>++di:dejs-soft:format</code></a>
46+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#didejsformat' title="Decode json: Millisecond date"><code>++di:dejs:format</code></a>
47+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#dudejsformat' title="Decode json: Second date"><code>++du:dejs:format</code></a>
48+
49+### e
50+
51+<a class="tooltip" href='/docs/hoon/reference/zuse/2e_2-3/#en-jsonhtml' title="Parse JSON"><code>++en-json:html</code></a>
52+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_1-5/#enjsformat' title="Container arm for JSON encoders"><code>++enjs:format</code></a>
53+
54+### f
55+
56+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_1-5/#frondenjsformat' title="Encode json: Object from key-value pair"><code>++frond:enjs:format</code></a>
57+
58+### j
59+
60+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_1-5/#json-rnformat' title="Json to rn parser"><code>++json-rn:format</code></a>
61+
62+### m
63+
64+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_7/#mudejs-softformat' title="Decode json (unit): True unit"><code>++mu:dejs-soft:format</code></a>
65+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#mudejsformat' title="Decode json: True unit"><code>++mu:dejs:format</code></a>
66+
67+### n
68+
69+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_7/#nedejs-softformat' title="Decode json (unit): Number as real"><code>++ne:dejs-soft:format</code></a>
70+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#nedejsformat' title="Decode json: Number as real"><code>++ne:dejs:format</code></a>
71+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_7/#nidejs-softformat' title="Decode json (unit): Number as integer"><code>++ni:dejs-soft:format</code></a>
72+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#nidejsformat' title="Decode json: Number as integer"><code>++ni:dejs:format</code></a>
73+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_7/#nodejs-softformat' title="Decode json (unit): Number as knot"><code>++no:dejs-soft:format</code></a>
74+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#nodejsformat' title="Decode json: Number as knot"><code>++no:dejs:format</code></a>
75+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#nudejsformat' title="Decode json: Parse string as hex"><code>++nu:dejs:format</code></a>
76+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_1-5/#numbenjsformat' title="Encode json: Number from unsigned"><code>++numb:enjs:format</code></a>
77+
78+### o
79+
80+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_1-5/#of-wainformat' title="Line list to cord"><code>++of-wain:format</code></a>
81+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_1-5/#of-wallformat' title="Line list to tape"><code>++of-wall:format</code></a>
82+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_7/#ofdejs-softformat' title="Decode json (unit): Object as frond"><code>++of:dejs-soft:format</code></a>
83+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#ofdejsformat' title="Decode json: Object as frond"><code>++of:dejs:format</code></a>
84+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#ojdejsformat' title="Decode json: Object as jug"><code>++oj:dejs:format</code></a>
85+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_7/#omdejs-softformat' title="Decode json (unit): Object as map"><code>++om:dejs-soft:format</code></a>
86+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#omdejsformat' title="Decode json: Object as map"><code>++om:dejs:format</code></a>
87+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_7/#opdejs-softformat' title="Decode json (unit): Parse keys of map"><code>++op:dejs-soft:format</code></a>
88+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#opdejsformat' title="Decode json: Parse keys of map"><code>++op:dejs:format</code></a>
89+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_7/#ot-rawdejs-softformat' title="Decode json (unit): Object as list of units, raw"><code>++ot-raw:dejs-soft:format</code></a>
90+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#ot-rawdejsformat' title="Decode json: Object as tuple, raw"><code>++ot-raw:dejs:format</code></a>
91+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_7/#otdejs-softformat' title="Decode json (unit): Object as tuple"><code>++ot:dejs-soft:format</code></a>
92+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#otdejsformat' title="Decode json: Object as tuple"><code>++ot:dejs:format</code></a>
93+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#ou-rawdejsformat' title="Decode json: Object of units, raw"><code>++ou-raw:dejs:format</code></a>
94+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#oudejsformat' title="Decode json: Object of units"><code>++ou:dejs:format</code></a>
95+
96+### p
97+
98+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#padejsformat' title="Decode json: String as path"><code>++pa:dejs:format</code></a>
99+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_1-5/#pairsenjsformat' title="Encode json: Object from key-value pair list"><code>++pairs:enjs:format</code></a>
100+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_1-5/#pathenjsformat' title="Encode json: String from path"><code>++path:enjs:format</code></a>
101+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_7/#pedejs-softformat' title="Decode json (unit): Prefix"><code>++pe:dejs-soft:format</code></a>
102+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#pedejsformat' title="Decode json: Prefix"><code>++pe:dejs:format</code></a>
103+
104+### r
105+
106+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_7/#redejs-softformat' title="Decode json (unit): Recursive reparser"><code>++re:dejs-soft:format</code></a>
107+
108+### s
109+
110+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_7/#sadejs-softformat' title="Decode json (unit): String as tape"><code>++sa:dejs-soft:format</code></a>
111+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#sedejsformat' title="Decode json: String as tape"><code>++sa:dejs:format</code></a>
112+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#sddejsformat' title="Decode json: String @ud as date"><code>++sd:dejs:format</code></a>
113+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#sedejsformat' title="Decode json: String as aura"><code>++se:dejs:format</code></a>
114+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_1-5/#sectenjsformat' title="Encode json: Seconds timestamp"><code>++sect:enjs:format</code></a>
115+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_1-5/#shipenjsformat' title="Encode json: String from ship"><code>++ship:enjs:format</code></a>
116+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_7/#sodejs-softformat' title="Decode json (unit): String as cord"><code>++so:dejs-soft:format</code></a>
117+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#sodejsformat' title="Decode json: String as cord"><code>++so:dejs:format</code></a>
118+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_7/#sudejs-softformat' title="Decode json (unit): Parse string"><code>++su:dejs-soft:format</code></a>
119+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#sudejsformat' title="Decode json: Parse string"><code>++su:dejs:format</code></a>
120+
121+### t
122+
123+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_1-5/#tankenjsformat' title="Encode json: Tank as string array"><code>++tank:enjs:format</code></a>
124+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_1-5/#tapeenjsformat' title="Encode json: String from tape"><code>++tape:enjs:format</code></a>
125+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_1-5/#timeenjsformat' title="Encode json: Millisecond timestamp"><code>++time:enjs:format</code></a>
126+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_1-5/#to-wainformat' title="Cord to line list"><code>++to-wain:format</code></a>
127+
128+### u
129+
130+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#ufdejsformat' title="Decode json: Unit fall"><code>++uf:dejs:format</code></a>
131+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_7/#uldejs-softformat' title="Decode json (unit): Null"><code>++ul:dejs-soft:format</code></a>
132+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#uldejsformat' title="Decode json: Null"><code>++ul:dejs:format</code></a>
133+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#undejsformat' title="Decode json: Unit need"><code>++un:dejs:format</code></a>
134+
135+### w
136+
137+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_1-5/#wallenjsformat' title="Encode json: String from wall"><code>++wall:enjs:format</code></a>
138+
139+### z
140+
141+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_7/#zadejs-softformat' title="Decode json (unit): Full unit pole"><code>++za:dejs-soft:format</code></a>
142+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#zadejsformat' title="Decode json: Full unit pole"><code>++za:dejs:format</code></a>
143+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_7/#zldejs-softformat' title="Decode json (unit): Collapse unit list"><code>++zl:dejs-soft:format</code></a>
144+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#zldejsformat' title="Decode json: Collapse unit list"><code>++zl:dejs:format</code></a>
145+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_7/#zmdejs-softformat' title="Decode json (unit): Collapse unit map"><code>++zm:dejs-soft:format</code></a>
146+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#zmdejsformat' title="Decode json: Collapse unit map"><code>++zm:dejs:format</code></a>
147+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_7/#zpdejs-softformat' title="Decode json (unit): Unit tuple"><code>++zp:dejs-soft:format</code></a>
148+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#zpdejsformat' title="Decode json: Unit tuple"><code>++zp:dejs:format</code></a>
149+
150+## By Section
151+
152+### 2d (1-5): Formatting functions: Line lists and JSON encoding
153+
154+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_1-5/#to-wainformat' title="Cord to line list"><code>++to-wain:format</code></a>
155+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_1-5/#of-wainformat' title="Line list to cord"><code>++of-wain:format</code></a>
156+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_1-5/#of-wallformat' title="Line list to tape"><code>++of-wall:format</code></a>
157+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_1-5/#json-rnformat' title="Json to rn parser"><code>++json-rn:format</code></a>
158+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_1-5/#enjsformat' title="Container arm for JSON encoders"><code>++enjs:format</code></a>
159+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_1-5/#frondenjsformat' title="Encode json: Object from key-value pair"><code>++frond:enjs:format</code></a>
160+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_1-5/#pairsenjsformat' title="Encode json: Object from key-value pair list"><code>++pairs:enjs:format</code></a>
161+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_1-5/#tapeenjsformat' title="Encode json: String from tape"><code>++tape:enjs:format</code></a>
162+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_1-5/#wallenjsformat' title="Encode json: String from wall"><code>++wall:enjs:format</code></a>
163+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_1-5/#shipenjsformat' title="Encode json: String from ship"><code>++ship:enjs:format</code></a>
164+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_1-5/#numbenjsformat' title="Encode json: Number from unsigned"><code>++numb:enjs:format</code></a>
165+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_1-5/#sectenjsformat' title="Encode json: Seconds timestamp"><code>++sect:enjs:format</code></a>
166+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_1-5/#timeenjsformat' title="Encode json: Millisecond timestamp"><code>++time:enjs:format</code></a>
167+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_1-5/#pathenjsformat' title="Encode json: String from path"><code>++path:enjs:format</code></a>
168+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_1-5/#tankenjsformat' title="Encode json: Tank as string array"><code>++tank:enjs:format</code></a>
169+
170+### 2d (6): Formatting functions: JSON decoding
171+
172+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#dejsformat' title="Container arm for JSON decoding reparsers"><code>++dejs:format</code></a>
173+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#ardejsformat' title="Decode json: Array as list"><code>++ar:dejs:format</code></a>
174+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#asdejsformat' title="Decode json: Array as set"><code>++as:dejs:format</code></a>
175+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#atdejsformat' title="Decode json: Array as tuple"><code>++at:dejs:format</code></a>
176+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#at-rawdejsformat' title="Decode json: Array as tuple, raw"><code>++at-raw:dejs:format</code></a>
177+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#bodejsformat' title="Decode json: Boolean"><code>++bo:dejs:format</code></a>
178+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#budejsformat' title="Decode json: Boolean NOT"><code>++bu:dejs:format</code></a>
179+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#cidejsformat' title="Decode json: Maybe transform"><code>++ci:dejs:format</code></a>
180+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#cudejsformat' title="Decode json: Transform"><code>++cu:dejs:format</code></a>
181+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#didejsformat' title="Decode json: Millisecond date"><code>++di:dejs:format</code></a>
182+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#dudejsformat' title="Decode json: Second date"><code>++du:dejs:format</code></a>
183+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#mudejsformat' title="Decode json: True unit"><code>++mu:dejs:format</code></a>
184+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#nedejsformat' title="Decode json: Number as real"><code>++ne:dejs:format</code></a>
185+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#nidejsformat' title="Decode json: Number as integer"><code>++ni:dejs:format</code></a>
186+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#nodejsformat' title="Decode json: Number as knot"><code>++no:dejs:format</code></a>
187+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#nudejsformat' title="Decode json: Parse string as hex"><code>++nu:dejs:format</code></a>
188+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#ofdejsformat' title="Decode json: Object as frond"><code>++of:dejs:format</code></a>
189+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#otdejsformat' title="Decode json: Object as tuple"><code>++ot:dejs:format</code></a>
190+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#ot-rawdejsformat' title="Decode json: Object as tuple, raw"><code>++ot-raw:dejs:format</code></a>
191+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#oudejsformat' title="Decode json: Object of units"><code>++ou:dejs:format</code></a>
192+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#ou-rawdejsformat' title="Decode json: Object of units, raw"><code>++ou-raw:dejs:format</code></a>
193+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#ojdejsformat' title="Decode json: Object as jug"><code>++oj:dejs:format</code></a>
194+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#omdejsformat' title="Decode json: Object as map"><code>++om:dejs:format</code></a>
195+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#opdejsformat' title="Decode json: Parse keys of map"><code>++op:dejs:format</code></a>
196+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#padejsformat' title="Decode json: String as path"><code>++pa:dejs:format</code></a>
197+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#pedejsformat' title="Decode json: Prefix"><code>++pe:dejs:format</code></a>
198+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#sedejsformat' title="Decode json: String as tape"><code>++sa:dejs:format</code></a>
199+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#sddejsformat' title="Decode json: String @ud as date"><code>++sd:dejs:format</code></a>
200+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#sedejsformat' title="Decode json: String as aura"><code>++se:dejs:format</code></a>
201+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#sodejsformat' title="Decode json: String as cord"><code>++so:dejs:format</code></a>
202+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#sudejsformat' title="Decode json: Parse string"><code>++su:dejs:format</code></a>
203+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#ufdejsformat' title="Decode json: Unit fall"><code>++uf:dejs:format</code></a>
204+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#undejsformat' title="Decode json: Unit need"><code>++un:dejs:format</code></a>
205+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#uldejsformat' title="Decode json: Null"><code>++ul:dejs:format</code></a>
206+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#zadejsformat' title="Decode json: Full unit pole"><code>++za:dejs:format</code></a>
207+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#zldejsformat' title="Decode json: Collapse unit list"><code>++zl:dejs:format</code></a>
208+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#zpdejsformat' title="Decode json: Unit tuple"><code>++zp:dejs:format</code></a>
209+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_6/#zmdejsformat' title="Decode json: Collapse unit map"><code>++zm:dejs:format</code></a>
210+
211+### 2d (7): Formatting functions: JSON decoding (unit)
212+
213+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_7/#dejs-softformat' title="Container arm for unitized JSON decoding reparsers"><code>++dejs-soft:format</code></a>
214+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_7/#ardejs-softformat' title="Decode json (unit): Array as list"><code>++ar:dejs-soft:format</code></a>
215+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_7/#atdejs-softformat' title="Decode json (unit): Array as tuple"><code>++at:dejs-soft:format</code></a>
216+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_7/#at-rawdejs-softformat' title="Decode json (unit): Array as tuple, raw"><code>++at-raw:dejs-soft:format</code></a>
217+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_7/#bodejs-softformat' title="Decode json (unit): Boolean"><code>++bo:dejs-soft:format</code></a>
218+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_7/#budejs-softformat' title="Decode json (unit): Boolean NOT"><code>++bu:dejs-soft:format</code></a>
219+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_7/#cidejs-softformat' title="Decode json (unit): Maybe transform"><code>++ci:dejs-soft:format</code></a>
220+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_7/#cudejs-softformat' title="Decode json (unit): Transform"><code>++cu:dejs-soft:format</code></a>
221+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_7/#dadejs-softformat' title="Decode json (unit): UTC date"><code>++da:dejs-soft:format</code></a>
222+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_7/#dankdejs-softformat' title="Decode json (unit): Tank"><code>++dank:dejs-soft:format</code></a>
223+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_7/#didejs-softformat' title="Decode json (unit): Millisecond date"><code>++di:dejs-soft:format</code></a>
224+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_7/#mudejs-softformat' title="Decode json (unit): True unit"><code>++mu:dejs-soft:format</code></a>
225+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_7/#nedejs-softformat' title="Decode json (unit): Number as real"><code>++ne:dejs-soft:format</code></a>
226+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_7/#nidejs-softformat' title="Decode json (unit): Number as integer"><code>++ni:dejs-soft:format</code></a>
227+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_7/#nodejs-softformat' title="Decode json (unit): Number as knot"><code>++no:dejs-soft:format</code></a>
228+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_7/#ofdejs-softformat' title="Decode json (unit): Object as frond"><code>++of:dejs-soft:format</code></a>
229+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_7/#otdejs-softformat' title="Decode json (unit): Object as tuple"><code>++ot:dejs-soft:format</code></a>
230+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_7/#ot-rawdejs-softformat' title="Decode json (unit): Object as list of units, raw"><code>++ot-raw:dejs-soft:format</code></a>
231+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_7/#omdejs-softformat' title="Decode json (unit): Object as map"><code>++om:dejs-soft:format</code></a>
232+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_7/#opdejs-softformat' title="Decode json (unit): Parse keys of map"><code>++op:dejs-soft:format</code></a>
233+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_7/#pedejs-softformat' title="Decode json (unit): Prefix"><code>++pe:dejs-soft:format</code></a>
234+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_7/#redejs-softformat' title="Decode json (unit): Recursive reparser"><code>++re:dejs-soft:format</code></a>
235+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_7/#sadejs-softformat' title="Decode json (unit): String as tape"><code>++sa:dejs-soft:format</code></a>
236+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_7/#sodejs-softformat' title="Decode json (unit): String as cord"><code>++so:dejs-soft:format</code></a>
237+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_7/#sudejs-softformat' title="Decode json (unit): Parse string"><code>++su:dejs-soft:format</code></a>
238+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_7/#uldejs-softformat' title="Decode json (unit): Null"><code>++ul:dejs-soft:format</code></a>
239+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_7/#zadejs-softformat' title="Decode json (unit): Full unit pole"><code>++za:dejs-soft:format</code></a>
240+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_7/#zldejs-softformat' title="Decode json (unit): Collapse unit list"><code>++zl:dejs-soft:format</code></a>
241+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_7/#zpdejs-softformat' title="Decode json (unit): Unit tuple"><code>++zp:dejs-soft:format</code></a>
242+<a class="tooltip" href='/docs/hoon/reference/zuse/2d_7/#zmdejs-softformat' title="Decode json (unit): Collapse unit map"><code>++zm:dejs-soft:format</code></a>
243+
244+### 2e (2-3): Web text: JSON printing and parsing
245+
246+<a class="tooltip" href='/docs/hoon/reference/zuse/2e_2-3/#en-jsonhtml' title="Parse JSON"><code>++en-json:html</code></a>
247+<a class="tooltip" href='/docs/hoon/reference/zuse/2e_2-3/#de-jsonhtml' title="Parse JSON"><code>++de-json:html</code></a>
lib/glossary.js+596
@@ -6526,4 +6526,600 @@ export const glossary = [
65266526 slug: "https://urbit.org/docs/reference/library/3f/#zyrtun",
65276527 desc: "Used in the Hoon standard library.",
65286528 },
6529+ // zuse
6530+ {
6531+ name: "Decode json (unit): Array as list",
6532+ symbol: "ar:dejs-soft:format",
6533+ usage: "zuse",
6534+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_7/#ardejs-softformat",
6535+ desc: "Used in the Zuse library.",
6536+ },
6537+ {
6538+ name: "Decode json: Array as list",
6539+ symbol: "ar:dejs:format",
6540+ usage: "zuse",
6541+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_6/#ardejsformat",
6542+ desc: "Used in the Zuse library.",
6543+ },
6544+ {
6545+ name: "Decode json: Array as set",
6546+ symbol: "as:dejs:format",
6547+ usage: "zuse",
6548+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_6/#asdejsformat",
6549+ desc: "Used in the Zuse library.",
6550+ },
6551+ {
6552+ name: "Decode json (unit): Array as tuple, raw",
6553+ symbol: "at-raw:dejs-soft:format",
6554+ usage: "zuse",
6555+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_7/#at-rawdejs-softformat",
6556+ desc: "Used in the Zuse library.",
6557+ },
6558+ {
6559+ name: "Decode json: Array as tuple, raw",
6560+ symbol: "at-raw:dejs:format",
6561+ usage: "zuse",
6562+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_6/#at-rawdejsformat",
6563+ desc: "Used in the Zuse library.",
6564+ },
6565+ {
6566+ name: "Decode json (unit): Array as tuple",
6567+ symbol: "at:dejs-soft:format",
6568+ usage: "zuse",
6569+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_7/#atdejs-softformat",
6570+ desc: "Used in the Zuse library.",
6571+ },
6572+ {
6573+ name: "Decode json: Array as tuple",
6574+ symbol: "at:dejs:format",
6575+ usage: "zuse",
6576+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_6/#atdejsformat",
6577+ desc: "Used in the Zuse library.",
6578+ },
6579+ {
6580+ name: "Decode json (unit): Boolean",
6581+ symbol: "bo:dejs-soft:format",
6582+ usage: "zuse",
6583+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_7/#bodejs-softformat",
6584+ desc: "Used in the Zuse library.",
6585+ },
6586+ {
6587+ name: "Decode json: Boolean",
6588+ symbol: "bo:dejs:format",
6589+ usage: "zuse",
6590+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_6/#bodejsformat",
6591+ desc: "Used in the Zuse library.",
6592+ },
6593+ {
6594+ name: "Decode json (unit): Boolean NOT",
6595+ symbol: "bu:dejs-soft:format",
6596+ usage: "zuse",
6597+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_7/#budejs-softformat",
6598+ desc: "Used in the Zuse library.",
6599+ },
6600+ {
6601+ name: "Decode json: Boolean NOT",
6602+ symbol: "bu:dejs:format",
6603+ usage: "zuse",
6604+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_6/#budejsformat",
6605+ desc: "Used in the Zuse library.",
6606+ },
6607+ {
6608+ name: "Decode json (unit): Maybe transform",
6609+ symbol: "ci:dejs-soft:format",
6610+ usage: "zuse",
6611+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_7/#cidejs-softformat",
6612+ desc: "Used in the Zuse library.",
6613+ },
6614+ {
6615+ name: "Decode json: Maybe transform",
6616+ symbol: "ci:dejs:format",
6617+ usage: "zuse",
6618+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_6/#cidejsformat",
6619+ desc: "Used in the Zuse library.",
6620+ },
6621+ {
6622+ name: "Decode json (unit): Transform",
6623+ symbol: "cu:dejs-soft:format",
6624+ usage: "zuse",
6625+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_7/#cudejs-softformat",
6626+ desc: "Used in the Zuse library.",
6627+ },
6628+ {
6629+ name: "Decode json: Transform",
6630+ symbol: "cu:dejs:format",
6631+ usage: "zuse",
6632+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_6/#cudejsformat",
6633+ desc: "Used in the Zuse library.",
6634+ },
6635+ {
6636+ name: "Decode json (unit): UTC date",
6637+ symbol: "da:dejs-soft:format",
6638+ usage: "zuse",
6639+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_7/#dadejs-softformat",
6640+ desc: "Used in the Zuse library.",
6641+ },
6642+ {
6643+ name: "Decode json (unit): Tank",
6644+ symbol: "dank:dejs-soft:format",
6645+ usage: "zuse",
6646+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_7/#dankdejs-softformat",
6647+ desc: "Used in the Zuse library.",
6648+ },
6649+ {
6650+ name: "Container arm for unitized JSON decoding reparsers",
6651+ symbol: "dejs-soft:format",
6652+ usage: "zuse",
6653+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_7/#dejs-softformat",
6654+ desc: "Used in the Zuse library.",
6655+ },
6656+ {
6657+ name: "Container arm for JSON decoding reparsers",
6658+ symbol: "dejs:format",
6659+ usage: "zuse",
6660+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_6/#dejsformat",
6661+ desc: "Used in the Zuse library.",
6662+ },
6663+ {
6664+ name: "Parse JSON",
6665+ symbol: "de-json:html",
6666+ usage: "zuse",
6667+ slug: "https://urbit.org/docs/hoon/reference/zuse/2e_2-3/#de-jsonhtml",
6668+ desc: "Used in the Zuse library.",
6669+ },
6670+ {
6671+ name: "Decode json (unit): Millisecond date",
6672+ symbol: "di:dejs-soft:format",
6673+ usage: "zuse",
6674+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_7/#didejs-softformat",
6675+ desc: "Used in the Zuse library.",
6676+ },
6677+ {
6678+ name: "Decode json: Millisecond date",
6679+ symbol: "di:dejs:format",
6680+ usage: "zuse",
6681+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_6/#didejsformat",
6682+ desc: "Used in the Zuse library.",
6683+ },
6684+ {
6685+ name: "Decode json: Second date",
6686+ symbol: "du:dejs:format",
6687+ usage: "zuse",
6688+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_6/#dudejsformat",
6689+ desc: "Used in the Zuse library.",
6690+ },
6691+ {
6692+ name: "Parse JSON",
6693+ symbol: "en-json:html",
6694+ usage: "zuse",
6695+ slug: "https://urbit.org/docs/hoon/reference/zuse/2e_2-3/#en-jsonhtml",
6696+ desc: "Used in the Zuse library.",
6697+ },
6698+ {
6699+ name: "Container arm for JSON encoders",
6700+ symbol: "enjs:format",
6701+ usage: "zuse",
6702+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_1-5/#enjsformat",
6703+ desc: "Used in the Zuse library.",
6704+ },
6705+ {
6706+ name: "Encode json: Object from key-value pair",
6707+ symbol: "frond:enjs:format",
6708+ usage: "zuse",
6709+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_1-5/#frondenjsformat",
6710+ desc: "Used in the Zuse library.",
6711+ },
6712+ {
6713+ name: "Json to rn parser",
6714+ symbol: "json-rn:format",
6715+ usage: "zuse",
6716+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_1-5/#json-rnformat",
6717+ desc: "Used in the Zuse library.",
6718+ },
6719+ {
6720+ name: "Decode json (unit): True unit",
6721+ symbol: "mu:dejs-soft:format",
6722+ usage: "zuse",
6723+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_7/#mudejs-softformat",
6724+ desc: "Used in the Zuse library.",
6725+ },
6726+ {
6727+ name: "Decode json: True unit",
6728+ symbol: "mu:dejs:format",
6729+ usage: "zuse",
6730+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_6/#mudejsformat",
6731+ desc: "Used in the Zuse library.",
6732+ },
6733+ {
6734+ name: "Decode json (unit): Number as real",
6735+ symbol: "ne:dejs-soft:format",
6736+ usage: "zuse",
6737+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_7/#nedejs-softformat",
6738+ desc: "Used in the Zuse library.",
6739+ },
6740+ {
6741+ name: "Decode json: Number as real",
6742+ symbol: "ne:dejs:format",
6743+ usage: "zuse",
6744+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_6/#nedejsformat",
6745+ desc: "Used in the Zuse library.",
6746+ },
6747+ {
6748+ name: "Decode json (unit): Number as integer",
6749+ symbol: "ni:dejs-soft:format",
6750+ usage: "zuse",
6751+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_7/#nidejs-softformat",
6752+ desc: "Used in the Zuse library.",
6753+ },
6754+ {
6755+ name: "Decode json: Number as integer",
6756+ symbol: "ni:dejs:format",
6757+ usage: "zuse",
6758+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_6/#nidejsformat",
6759+ desc: "Used in the Zuse library.",
6760+ },
6761+ {
6762+ name: "Decode json (unit): Number as knot",
6763+ symbol: "no:dejs-soft:format",
6764+ usage: "zuse",
6765+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_7/#nodejs-softformat",
6766+ desc: "Used in the Zuse library.",
6767+ },
6768+ {
6769+ name: "Decode json: Number as knot",
6770+ symbol: "no:dejs:format",
6771+ usage: "zuse",
6772+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_6/#nodejsformat",
6773+ desc: "Used in the Zuse library.",
6774+ },
6775+ {
6776+ name: "Decode json: Parse string as hex",
6777+ symbol: "nu:dejs:format",
6778+ usage: "zuse",
6779+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_6/#nudejsformat",
6780+ desc: "Used in the Zuse library.",
6781+ },
6782+ {
6783+ name: "Encode json: Number from unsigned",
6784+ symbol: "numb:enjs:format",
6785+ usage: "zuse",
6786+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_1-5/#numbenjsformat",
6787+ desc: "Used in the Zuse library.",
6788+ },
6789+ {
6790+ name: "Line list to cord",
6791+ symbol: "of-wain:format",
6792+ usage: "zuse",
6793+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_1-5/#of-wainformat",
6794+ desc: "Used in the Zuse library.",
6795+ },
6796+ {
6797+ name: "Line list to tape",
6798+ symbol: "of-wall:format",
6799+ usage: "zuse",
6800+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_1-5/#of-wallformat",
6801+ desc: "Used in the Zuse library.",
6802+ },
6803+ {
6804+ name: "Decode json (unit): Object as frond",
6805+ symbol: "of:dejs-soft:format",
6806+ usage: "zuse",
6807+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_7/#ofdejs-softformat",
6808+ desc: "Used in the Zuse library.",
6809+ },
6810+ {
6811+ name: "Decode json: Object as frond",
6812+ symbol: "of:dejs:format",
6813+ usage: "zuse",
6814+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_6/#ofdejsformat",
6815+ desc: "Used in the Zuse library.",
6816+ },
6817+ {
6818+ name: "Decode json: Object as jug",
6819+ symbol: "oj:dejs:format",
6820+ usage: "zuse",
6821+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_6/#ojdejsformat",
6822+ desc: "Used in the Zuse library.",
6823+ },
6824+ {
6825+ name: "Decode json (unit): Object as map",
6826+ symbol: "om:dejs-soft:format",
6827+ usage: "zuse",
6828+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_7/#omdejs-softformat",
6829+ desc: "Used in the Zuse library.",
6830+ },
6831+ {
6832+ name: "Decode json: Object as map",
6833+ symbol: "om:dejs:format",
6834+ usage: "zuse",
6835+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_6/#omdejsformat",
6836+ desc: "Used in the Zuse library.",
6837+ },
6838+ {
6839+ name: "Decode json (unit): Parse keys of map",
6840+ symbol: "op:dejs-soft:format",
6841+ usage: "zuse",
6842+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_7/#opdejs-softformat",
6843+ desc: "Used in the Zuse library.",
6844+ },
6845+ {
6846+ name: "Decode json: Parse keys of map",
6847+ symbol: "op:dejs:format",
6848+ usage: "zuse",
6849+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_6/#opdejsformat",
6850+ desc: "Used in the Zuse library.",
6851+ },
6852+ {
6853+ name: "Decode json (unit): Object as list of units, raw",
6854+ symbol: "ot-raw:dejs-soft:format",
6855+ usage: "zuse",
6856+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_7/#ot-rawdejs-softformat",
6857+ desc: "Used in the Zuse library.",
6858+ },
6859+ {
6860+ name: "Decode json: Object as tuple, raw",
6861+ symbol: "ot-raw:dejs:format",
6862+ usage: "zuse",
6863+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_6/#ot-rawdejsformat",
6864+ desc: "Used in the Zuse library.",
6865+ },
6866+ {
6867+ name: "Decode json (unit): Object as tuple",
6868+ symbol: "ot:dejs-soft:format",
6869+ usage: "zuse",
6870+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_7/#otdejs-softformat",
6871+ desc: "Used in the Zuse library.",
6872+ },
6873+ {
6874+ name: "Decode json: Object as tuple",
6875+ symbol: "ot:dejs:format",
6876+ usage: "zuse",
6877+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_6/#otdejsformat",
6878+ desc: "Used in the Zuse library.",
6879+ },
6880+ {
6881+ name: "Decode json: Object of units, raw",
6882+ symbol: "ou-raw:dejs:format",
6883+ usage: "zuse",
6884+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_6/#ou-rawdejsformat",
6885+ desc: "Used in the Zuse library.",
6886+ },
6887+ {
6888+ name: "Decode json: Object of units",
6889+ symbol: "ou:dejs:format",
6890+ usage: "zuse",
6891+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_6/#oudejsformat",
6892+ desc: "Used in the Zuse library.",
6893+ },
6894+ {
6895+ name: "Decode json: String as path",
6896+ symbol: "pa:dejs:format",
6897+ usage: "zuse",
6898+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_6/#padejsformat",
6899+ desc: "Used in the Zuse library.",
6900+ },
6901+ {
6902+ name: "Encode json: Object from key-value pair list",
6903+ symbol: "pairs:enjs:format",
6904+ usage: "zuse",
6905+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_1-5/#pairsenjsformat",
6906+ desc: "Used in the Zuse library.",
6907+ },
6908+ {
6909+ name: "Encode json: String from path",
6910+ symbol: "path:enjs:format",
6911+ usage: "zuse",
6912+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_1-5/#pathenjsformat",
6913+ desc: "Used in the Zuse library.",
6914+ },
6915+ {
6916+ name: "Decode json (unit): Prefix",
6917+ symbol: "pe:dejs-soft:format",
6918+ usage: "zuse",
6919+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_7/#pedejs-softformat",
6920+ desc: "Used in the Zuse library.",
6921+ },
6922+ {
6923+ name: "Decode json: Prefix",
6924+ symbol: "pe:dejs:format",
6925+ usage: "zuse",
6926+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_6/#pedejsformat",
6927+ desc: "Used in the Zuse library.",
6928+ },
6929+ {
6930+ name: "Decode json (unit): Recursive reparser",
6931+ symbol: "re:dejs-soft:format",
6932+ usage: "zuse",
6933+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_7/#redejs-softformat",
6934+ desc: "Used in the Zuse library.",
6935+ },
6936+ {
6937+ name: "Decode json (unit): String as tape",
6938+ symbol: "sa:dejs-soft:format",
6939+ usage: "zuse",
6940+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_7/#sadejs-softformat",
6941+ desc: "Used in the Zuse library.",
6942+ },
6943+ {
6944+ name: "Decode json: String as tape",
6945+ symbol: "sa:dejs:format",
6946+ usage: "zuse",
6947+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_6/#sedejsformat",
6948+ desc: "Used in the Zuse library.",
6949+ },
6950+ {
6951+ name: "Decode json: String @ud as date",
6952+ symbol: "sd:dejs:format",
6953+ usage: "zuse",
6954+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_6/#sddejsformat",
6955+ desc: "Used in the Zuse library.",
6956+ },
6957+ {
6958+ name: "Decode json: String as aura",
6959+ symbol: "se:dejs:format",
6960+ usage: "zuse",
6961+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_6/#sedejsformat",
6962+ desc: "Used in the Zuse library.",
6963+ },
6964+ {
6965+ name: "Encode json: Seconds timestamp",
6966+ symbol: "sect:enjs:format",
6967+ usage: "zuse",
6968+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_1-5/#sectenjsformat",
6969+ desc: "Used in the Zuse library.",
6970+ },
6971+ {
6972+ name: "Encode json: String from ship",
6973+ symbol: "ship:enjs:format",
6974+ usage: "zuse",
6975+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_1-5/#shipenjsformat",
6976+ desc: "Used in the Zuse library.",
6977+ },
6978+ {
6979+ name: "Decode json (unit): String as cord",
6980+ symbol: "so:dejs-soft:format",
6981+ usage: "zuse",
6982+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_7/#sodejs-softformat",
6983+ desc: "Used in the Zuse library.",
6984+ },
6985+ {
6986+ name: "Decode json: String as cord",
6987+ symbol: "so:dejs:format",
6988+ usage: "zuse",
6989+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_6/#sodejsformat",
6990+ desc: "Used in the Zuse library.",
6991+ },
6992+ {
6993+ name: "Decode json (unit): Parse string",
6994+ symbol: "su:dejs-soft:format",
6995+ usage: "zuse",
6996+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_7/#sudejs-softformat",
6997+ desc: "Used in the Zuse library.",
6998+ },
6999+ {
7000+ name: "Decode json: Parse string",
7001+ symbol: "su:dejs:format",
7002+ usage: "zuse",
7003+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_6/#sudejsformat",
7004+ desc: "Used in the Zuse library.",
7005+ },
7006+ {
7007+ name: "Encode json: Tank as string array",
7008+ symbol: "tank:enjs:format",
7009+ usage: "zuse",
7010+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_1-5/#tankenjsformat",
7011+ desc: "Used in the Zuse library.",
7012+ },
7013+ {
7014+ name: "Encode json: String from tape",
7015+ symbol: "tape:enjs:format",
7016+ usage: "zuse",
7017+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_1-5/#tapeenjsformat",
7018+ desc: "Used in the Zuse library.",
7019+ },
7020+ {
7021+ name: "Encode json: Millisecond timestamp",
7022+ symbol: "time:enjs:format",
7023+ usage: "zuse",
7024+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_1-5/#timeenjsformat",
7025+ desc: "Used in the Zuse library.",
7026+ },
7027+ {
7028+ name: "Cord to line list",
7029+ symbol: "to-wain:format",
7030+ usage: "zuse",
7031+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_1-5/#to-wainformat",
7032+ desc: "Used in the Zuse library.",
7033+ },
7034+ {
7035+ name: "Decode json: Unit fall",
7036+ symbol: "uf:dejs:format",
7037+ usage: "zuse",
7038+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_6/#ufdejsformat",
7039+ desc: "Used in the Zuse library.",
7040+ },
7041+ {
7042+ name: "Decode json (unit): Null",
7043+ symbol: "ul:dejs-soft:format",
7044+ usage: "zuse",
7045+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_7/#uldejs-softformat",
7046+ desc: "Used in the Zuse library.",
7047+ },
7048+ {
7049+ name: "Decode json: Null",
7050+ symbol: "ul:dejs:format",
7051+ usage: "zuse",
7052+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_6/#uldejsformat",
7053+ desc: "Used in the Zuse library.",
7054+ },
7055+ {
7056+ name: "Decode json: Unit need",
7057+ symbol: "un:dejs:format",
7058+ usage: "zuse",
7059+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_6/#undejsformat",
7060+ desc: "Used in the Zuse library.",
7061+ },
7062+ {
7063+ name: "Encode json: String from wall",
7064+ symbol: "wall:enjs:format",
7065+ usage: "zuse",
7066+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_1-5/#wallenjsformat",
7067+ desc: "Used in the Zuse library.",
7068+ },
7069+ {
7070+ name: "Decode json (unit): Full unit pole",
7071+ symbol: "za:dejs-soft:format",
7072+ usage: "zuse",
7073+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_7/#zadejs-softformat",
7074+ desc: "Used in the Zuse library.",
7075+ },
7076+ {
7077+ name: "Decode json: Full unit pole",
7078+ symbol: "za:dejs:format",
7079+ usage: "zuse",
7080+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_6/#zadejsformat",
7081+ desc: "Used in the Zuse library.",
7082+ },
7083+ {
7084+ name: "Decode json (unit): Collapse unit list",
7085+ symbol: "zl:dejs-soft:format",
7086+ usage: "zuse",
7087+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_7/#zldejs-softformat",
7088+ desc: "Used in the Zuse library.",
7089+ },
7090+ {
7091+ name: "Decode json: Collapse unit list",
7092+ symbol: "zl:dejs:format",
7093+ usage: "zuse",
7094+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_6/#zldejsformat",
7095+ desc: "Used in the Zuse library.",
7096+ },
7097+ {
7098+ name: "Decode json (unit): Collapse unit map",
7099+ symbol: "zm:dejs-soft:format",
7100+ usage: "zuse",
7101+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_7/#zmdejs-softformat",
7102+ desc: "Used in the Zuse library.",
7103+ },
7104+ {
7105+ name: "Decode json: Collapse unit map",
7106+ symbol: "zm:dejs:format",
7107+ usage: "zuse",
7108+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_6/#zmdejsformat",
7109+ desc: "Used in the Zuse library.",
7110+ },
7111+ {
7112+ name: "Decode json (unit): Unit tuple",
7113+ symbol: "zp:dejs-soft:format",
7114+ usage: "zuse",
7115+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_7/#zpdejs-softformat",
7116+ desc: "Used in the Zuse library.",
7117+ },
7118+ {
7119+ name: "Decode json: Unit tuple",
7120+ symbol: "zp:dejs:format",
7121+ usage: "zuse",
7122+ slug: "https://urbit.org/docs/hoon/reference/zuse/2d_6/#zpdejsformat",
7123+ desc: "Used in the Zuse library.",
7124+ },
65297125];