646edee · urbit.org · git.iko.soy

git.iko.soy/urbit.org

Merge pull request #1302 from urbit/update-stdlib-4m-4n-4o

update stdlib 4m 4n 4o

commit646edeee5f80a11f35da3950fdfc08668cc65cb3 authortinnus-napbus <77721746+tinnus-napbus@users.noreply.github.com> dateTue 11 Jan 2022, 03:40 (5 years ago) parent56bec55 a5785d8

5 files changed+2367−852

compare with master

unifiedsplit

content/docs/hoon/reference/stdlib/4m.md+221−171 content/docs/hoon/reference/stdlib/4n.md+534−260 content/docs/hoon/reference/stdlib/4o.md+1101−314 content/docs/hoon/reference/stdlib/table-of-contents.md+141−52 lib/glossary.js+370−55

content/docs/hoon/reference/stdlib/4m.md+221−171

@@ -12,7 +12,7 @@ Renders a dime `mol` as a cord.

1212

1313#### Accepts

1414

15−`mol` is a `++dime`.

15+`mol` is a `dime`.

1616

1717#### Produces

1818

@@ -21,28 +21,28 @@ A `cord`.

2121#### Source

2222

2323```hoon

24− ++ scot |=(mol/dime ~(rent co %$ mol))

24+++ scot

25+ ~/ %scot

26+ |=(mol=dime ~(rent co %$ mol))

2527```

2628

2729#### Examples

2830

2931```

30− > (scot %p ~pillyt)

31− ~.~pillyt

32− > `@t`(scot %p ~pillyt)

33− '~pillyt'

34− > (scot %ux 0x12)

35− ~.0x12

36− > `@t`(scot %ux 0x12)

37− '0x12'

38− > (scot %if .127.0.0.1)

39− ~..127.0.0.1

40− > `@t`(scot %if .127.0.0.1)

41− '.127.0.0.1'

42− > (scot %ta ~.asd_a)

43− ~.~.asd_a

44− > `@t`(scot %ta ~.asd_a)

45− '~.asd_a'

32+> (scot %p ~pillyt)

33+~.~pillyt

34+

35+> `@t`(scot %p ~pillyt)

36+'~pillyt'

37+

38+> `@t`(scot %ux 0x12)

39+'0x12'

40+

41+> `@t`(scot %if .127.0.0.1)

42+'.127.0.0.1'

43+

44+> `@t`(scot %ta ~.asd_a)

45+'~.asd_a'

4646```

4747

4848---

@@ -55,7 +55,7 @@ Renders a dime `mol` as a tape.

5555

5656#### Accepts

5757

58−`mol` is a `++dime`.

58+`mol` is a `dime`.

5959

6060#### Produces

6161

@@ -64,20 +64,25 @@ A `tape`.

6464#### Source

6565

6666```hoon

67− ++ scow |=(mol/dime ~(rend co %$ mol))

67+++ scow

68+ ~/ %scow

69+ |=(mol=dime ~(rend co %$ mol))

6870```

6971

7072#### Examples

7173

7274```

73− > (scow %p ~pillyt)

74− "~pillyt"

75− > (scow %ux 0x12)

76− "0x12"

77− > (scow %if .127.0.0.1)

78− ".127.0.0.1"

79− > (scow %ta ~.asd_a)

80− "~.asd_a"

75+> (scow %p ~pillyt)

76+"~pillyt"

77+

78+> (scow %ux 0x12)

79+"0x12"

80+

81+> (scow %if .127.0.0.1)

82+".127.0.0.1"

83+

84+> (scow %ta ~.asd_a)

85+"~.asd_a"

8186```

8287

8388---

@@ -86,36 +91,39 @@ A `tape`.

8691

8792Curried slaw

8893

89−Produces a `gate` that parses a `term` `txt` to an atom of the

90−aura specified by `mod`.

94+Produces a `gate` that parses a `knot` `txt` to a `unit` containing the atom of

95+the aura specified by `mod`. The `unit` will be null if parsing failed.

9196

9297#### Accepts

9398

94−`mod` is a term, an atom of aura `@tas`.

99+`mod` is a `knot`.

95100

96−`txt` is a cord, an atom of aura `@ta`.

101+`txt` is a `cord`.

97102

98103#### Produces

99104

100−A `gate`.

105+A `(unit @)`.

101106

102107#### Source

103108

104109```hoon

105− ++ slat |=(mod/@tas |=(txt/@ta (slaw mod txt)))

110+++ slat |=(mod=@tas |=(txt=@ta (slaw mod txt)))

106111```

107112

108113#### Examples

109114

110115```

111− > `(unit @p)`((slat %p) '~pillyt')

112− [~ ~pillyt]

113− > `(unit @ux)`((slat %ux) '0x12')

114− [~ 0x12]

115− > `(unit @if)`((slat %if) '.127.0.0.1')

116− [~ .127.0.0.1]

117− > `(unit @ta)`((slat %ta) '~.asd_a')

118− [~ ~.asd_a

116+> `(unit @p)`((slat %p) '~pillyt')

117+[~ ~pillyt]

118+

119+> `(unit @ux)`((slat %ux) '0x12')

120+[~ 0x12]

121+

122+> `(unit @if)`((slat %if) '.127.0.0.1')

123+[~ .127.0.0.1]

124+

125+> `(unit @ta)`((slat %ta) '~.asd_a')

126+[~ ~.asd_a]

119127```

120128

121129---

@@ -129,39 +137,46 @@ Crashes if it fails to parse.

129137

130138#### Accepts

131139

132−`mod` is a term, an atom of aura `@tas`.

140+`mod` is a `term`

133141

134−`txt` is a cord, an atom of aura `@ta`.

142+`txt` is a `knot`.

135143

136144#### Produces

137145

138−The atom of a `(unit @)` from `++slaw`, or crash.

146+an atom.

139147

140148#### Source

141149

142150```hoon

143− ++ slav |=([mod/@tas txt/@ta] (need (slaw mod txt)))

151+++ slav |=([mod=@tas txt=@ta] (need (slaw mod txt)))

144152```

145153

146154#### Examples

147155

148156```

149− > `@p`(slav %p '~pillyt')

150− ~pillyt

151− > `@p`(slav %p '~pillam')

152− ! exit

153− > `@ux`(slav %ux '0x12')

154− 0x12

155− > `@ux`(slav %ux '0b10')

156− ! exit

157− > `@if`(slav %if '.127.0.0.1')

158− .127.0.0.1

159− > `@if`(slav %if '.fe80.0.0.202')

160− ! exit

161− > `@ta`(slav %ta '~.asd_a')

162− ~.asd_a

163− > `@ta`(slav %ta '~~asd-a')

164− ! exit

157+> `@p`(slav %p '~pillyt')

158+~pillyt

159+

160+> `@p`(slav %p '~pillam')

161+! exit

162+

163+> `@ux`(slav %ux '0x12')

164+0x12

165+

166+> `@ux`(slav %ux '0b10')

167+! exit

168+

169+> `@if`(slav %if '.127.0.0.1')

170+.127.0.0.1

171+

172+> `@if`(slav %if '.fe80.0.0.202')

173+! exit

174+

175+> `@ta`(slav %ta '~.asd_a')

176+~.asd_a

177+

178+> `@ta`(slav %ta '~~asd-a')

179+! exit

165180```

166181

167182---

@@ -170,13 +185,14 @@ The atom of a `(unit @)` from `++slaw`, or crash.

170185

171186Parse cord to input aura

172187

173−Parses a cord `txt` to an atom of the aura specified by `mod`.

188+Parses a cord `txt` to a `unit` containing the atom of the aura specified by

189+`mod`. The `unit` is null if parsing failed.

174190

175191#### Accepts

176192

177−`mod` is a term, an atom of aura `@tas`.

193+`mod` is a `term`.

178194

179−`txt` is a cord, an atom of aura `@ta`.

195+`txt` is a `knot`.

180196

181197#### Produces

182198

@@ -185,33 +201,65 @@ A `(unit @)`.

185201#### Source

186202

187203```hoon

188− ++ slaw

189− ~/ %slaw

190− |= {mod/@tas txt/@ta}

191− ^- (unit @)

204+++ slaw

205+ ~/ %slaw

206+ |= [mod=@tas txt=@ta]

207+ ^- (unit @)

208+ ?+ mod

209+ :: slow fallback case to the full slay

210+ ::

192211 =+ con=(slay txt)

193− ?.(&(?=({$~ $$ @ @} con) =(p.p.u.con mod)) ~ [~ q.p.u.con])

212+ ?.(&(?=([~ %$ @ @] con) =(p.p.u.con mod)) ~ [~ q.p.u.con])

213+ ::

214+ %da

215+ (rush txt ;~(pfix sig (cook year when:so)))

216+ ::

217+ %p

218+ (rush txt ;~(pfix sig fed:ag))

219+ ::

220+ %ud

221+ (rush txt dem:ag)

222+ ::

223+ %ux

224+ (rush txt ;~(pfix (jest '0x') hex:ag))

225+ ::

226+ %uv

227+ (rush txt ;~(pfix (jest '0v') viz:ag))

228+ ::

229+ %ta

230+ (rush txt ;~(pfix ;~(plug sig dot) urs:ab))

231+ ::

232+ %tas

233+ (rush txt sym)

234+ ==

194235```

195236

196237#### Examples

197238

198239```

199− > `(unit @p)`(slaw %p '~pillyt')

200− [~ ~pillyt]

201− > `(unit @p)`(slaw %p '~pillam')

202− ~

203− > `(unit @ux)`(slaw %ux '0x12')

204− [~ 0x12]

205− > `(unit @ux)`(slaw %ux '0b10')

206− ~

207− > `(unit @if)`(slaw %if '.127.0.0.1')

208− [~ .127.0.0.1]

209− > `(unit @if)`(slaw %if '.fe80.0.0.202')

210− ~

211− > `(unit @ta)`(slaw %ta '~.asd_a')

212− [~ ~.asd_a]

213− > `(unit @ta)`(slaw %ta '~~asd-a')

214− ~

240+> `(unit @p)`(slaw %p '~pillyt')

241+[~ ~pillyt]

242+

243+> `(unit @p)`(slaw %p '~pillam')

244+~

245+

246+> `(unit @ux)`(slaw %ux '0x12')

247+[~ 0x12]

248+

249+> `(unit @ux)`(slaw %ux '0b10')

250+~

251+

252+> `(unit @if)`(slaw %if '.127.0.0.1')

253+[~ .127.0.0.1]

254+

255+> `(unit @if)`(slaw %if '.fe80.0.0.202')

256+~

257+

258+> `(unit @ta)`(slaw %ta '~.asd_a')

259+[~ ~.asd_a]

260+

261+> `(unit @ta)`(slaw %ta '~~asd-a')

262+~

215263```

216264

217265---

@@ -220,7 +268,7 @@ A `(unit @)`.

220268

221269Parse cord to coin

222270

223−Parses a cord `txt` to the unit of a `++coin`.

271+Parses a cord `txt` to the unit of a `coin`.

224272

225273#### Accepts

226274

@@ -233,45 +281,31 @@ A `(unit coin)`.

233281#### Source

234282

235283```hoon

236− ++ slay

237− |= txt/@ta ^- (unit coin)

238− =+ ^= vex

239− ?: (gth 0x7fff.ffff txt) :: XX petty cache

240− ~+ ((full nuck:so) [[1 1] (trip txt)])

241− ((full nuck:so) [[1 1] (trip txt)])

242− ?~ q.vex

243− ~

244− [~ p.u.q.vex]

245− ::

284+++ slay

285+ |= txt=@ta ^- (unit coin)

286+ =+ ^= vex

287+ ?: (gth 0x7fff.ffff txt) :: XX petty cache

288+ ~+ ((full nuck:so) [[1 1] (trip txt)])

289+ ((full nuck:so) [[1 1] (trip txt)])

290+ ?~ q.vex

291+ ~

292+ [~ p.u.q.vex]

246293```

247294

248295#### Examples

249296

250297```

251− > (slay '~pillyt')

252− [~ [% p=[p=~.p q=32.819]]]

253− > (slay '0x12')

254− [~ [% p=[p=~.ux q=18]]]

255− > (slay '.127.0.0.1')

256− [~ [% p=[p=~.if q=2.130.706.433]]]

257− > `@ud`.127.0.0.1

258− 2.130.706.433

259− > (slay '._20_0w25_sam__')

260− [ ~

261− [ %many

262− p=~[[% p=[p=~.ud q=20]] [% p=[p=~.uw q=133]] [% p=[p=~.tas q=7.168.371]]]

263− ]

264− ]

265− > `@`%sam

266− 7.168.371

267− > (slay '~0ph')

268− [~ [%blob p=[1 1]]]

269− > 0ph

270− ~ <syntax error at [1 2]>

271− > ~0ph

272− [1 1]

273− > `@uv`(jam [1 1])

274− 0vph

298+> (slay '~pillyt')

299+[~ [%$ p=[p=~.p q=13.184]]]

300+

301+> (slay '0x12')

302+[~ [%$ p=[p=~.ux q=18]]]

303+

304+> (slay '.127.0.0.1')

305+[~ [%$ p=[p=~.if q=2.130.706.433]]]

306+

307+> (slay '!')

308+~

275309```

276310

277311---

@@ -285,7 +319,7 @@ pretty-printing.

285319

286320#### Accepts

287321

288−`bon` is a `++path`.

322+`bon` is a `path`.

289323

290324#### Produces

291325

@@ -294,30 +328,31 @@ A `tank`.

294328#### Source

295329

296330```hoon

297− ++ smyt :: pretty print path

298− |= bon/path ^- tank

299− :+ %rose [['/' ~] ['/' ~] ~]

300− (turn bon |=(a/@ [%leaf (trip a)]))

301− ::

331+++ smyt

332+ |= bon=path ^- tank

333+ :+ %rose [['/' ~] ['/' ~] ~]

334+ (turn bon |=(a=@ [%leaf (trip a)]))

302335```

303336

304337#### Examples

305338

306339```

307− > (smyt %)

308− [ %rose

309− p=[p="/" q="/" r="/"]

310− q

311− ~[ [%leaf p="~zod"]

312− [%leaf p="try"]

313− [%leaf p="~2014.10.28..18.36.58..a280"]

314− ]

315− ]

316− > (smyt /as/les/top)

317− [ %rose

318− p=[p="/" q="/" r="/"]

319− q=~[[%leaf p="as"] [%leaf p="les"] [%leaf p="top"]]

320− ]

340+> (smyt %)

341+[ %rose

342+ p=[p="/" q="/" r=""]

343+ q

344+ ~[

345+ [%leaf p="~zod"]

346+ [%leaf p="base"]

347+ [%leaf p="~2022.1.6..14.22.14..40bf"]

348+ ]

349+]

350+

351+> (smyt /as/les/top)

352+[ %rose

353+ p=[p="/" q="/" r=""]

354+ q=~[[%leaf p="as"] [%leaf p="les"] [%leaf p="top"]]

355+]

321356```

322357

323358---

@@ -339,18 +374,20 @@ A `cord`.

339374#### Source

340375

341376```hoon

342− ++ spat |=(pax/path (crip (spud pax))) :: path to cord

377+++ spat |=(pax=path (crip (spud pax)))

343378```

344379

345380#### Examples

346381

347382```

348− > (spat %)

349− '~zod/try/~2014.10.28..18.40.20..4287'

350− > (spat %/bin)

351− '~zod/try/~2014.10.28..18.41.12..3bcd/bin'

352− > (spat /as/les/top)

353− '/as/les/top'

383+> (spat %)

384+'/~zod/base/~2022.1.6..14.23.31..e367'

385+

386+> (spat %/lib)

387+'/~zod/base/~2022.1.6..14.23.43..829e/lib'

388+

389+> (spat /as/les/top)

390+'/as/les/top'

354391```

355392

356393---

@@ -372,18 +409,20 @@ A `tape`.

372409#### Source

373410

374411```hoon

375− ++ spud |=(pax/path ~(ram re (smyt pax))) :: path to tape

412+++ spud |=(pax=path ~(ram re (smyt pax)))

376413```

377414

378415#### Examples

379416

380417```

381− > (spud %)

382− "~zod/try/~2014.10.28..18.40.46..e951"

383− > (spud %/bin)

384− "~zod/try/~2014.10.28..18.41.05..16f2/bin"

385− > (spud /as/les/top)

386− "/as/les/top"

418+> (spud %)

419+"/~zod/base/~2022.1.6..14.24.35..cddf"

420+

421+> (spud %/lib)

422+"/~zod/base/~2022.1.6..14.24.43..3efb/lib"

423+

424+> (spud /as/les/top)

425+"/as/les/top"

387426```

388427

389428---

@@ -392,7 +431,7 @@ A `tape`.

392431

393432Parse cord to path

394433

395−Parsing rule. Parses a cord `zep` to a static `++path`.

434+Parses a cord `zep` to a static `path`.

396435Crashes if it fails to parse.

397436

398437#### Accepts

@@ -406,31 +445,42 @@ A `path`, or crash.

406445#### Source

407446

408447```hoon

409− ++ stab :: parse cord to path

410− =+ fel=;~(pfix fas (more fas urs:ab))

411− |=(zep/@t `path`(rash zep fel))

448+++ stab |=(zep=@t `path`(rash zep stap))

412449```

413450

414451#### Examples

415452

416453```

417− > (stab '/as/lek/tor')

418− /as/lek/tor

454+> (stab '/as/lek/tor')

455+/as/lek/tor

456+```

457+

458+---

459+

460+## `++stap`

461+

462+Path parser

419463

420− > `(pole ,@ta)`(stab '/as/lek/tor')

421− [~.as [~.lek [~.tor ~]]]

464+Parsing `rule`. Parses a `path`, used internally by `++stab`.

422465

423− > (stab '~zod/arvo/~2014.10.28..18.48.41..335f/zuse')

424− ~zod/arvo/~2014.10.28..18.48.41..335f/zuse

466+#### Source

425467

426− > `(pole ,@ta)`(stab '~zod/arvo/~2014.10.28..18.48.41..335f/zuse')

427− [~.~zod [~.arvo [~.~2014.10.28..18.48.41..335f [~.zuse ~]]]]

468+```hoon

469+++ stap

470+ %+ sear

471+ |= p=path

472+ ^- (unit path)

473+ ?: ?=([~ ~] p) `~

474+ ?. =(~ (rear p)) `p

475+ ~

476+ ;~(pfix fas (most fas urs:ab))

477+```

428478

429− > (stab '/a/~pillyt/pals/1')

430− /a/~pillyt/pals/1

479+#### Examples

431480

432− > `(pole ,@ta)`(stab '/a/~pillyt/pals/1')

433− [~.a [~.~pillyt [~.pals [~.1 ~]]]]

481+```

482+> (scan "/foo/bar/baz" stap)

483+/foo/bar/baz

434484```

435485

436486---

content/docs/hoon/reference/stdlib/4n.md+534−260

@@ -8,7 +8,7 @@ template = "doc.html"

99Nock subject to unit

1010

11−Accepts a nock subject-formula cell and wraps it into a `++unit`.

11+Accepts a nock subject-formula cell and wraps it into a `unit`.

1212`fol` is pure nock, meaning that nock `11` operations result in a block,

1313producing a `~`.

1414

@@ -16,36 +16,39 @@ producing a `~`.

1616

1717`sub` is a subject noun.

1818

19−`fol` is a formula noun, which is generally a `++nock`.

19+`fol` is a formula noun, which is generally a `nock`.

2020

2121#### Produces

2222

23−The `++unit` of a noun.

23+The `unit` of a noun.

2424

2525#### Source

2626

2727```hoon

28− ++ mack

29− |= {sub/* fol/*}

30− ^- (unit)

31− =+ ton=(mink [sub fol] |=({* *} ~))

32− ?.(?=({$0 *} ton) ~ [~ p.ton])

33− ::

28+++ mack

29+ |= [sub=* fol=*]

30+ ^- (unit)

31+ =/ ton (mink [sub fol] |~(^ ~))

32+ ?.(?=(%0 -.ton) ~ `product.ton)

3433```

3534

3635#### Examples

3736

3837```

39− > (mack [[1 2 3] [0 1]])

40− [~ [1 2 3]]

41− > (mack [41 4 0 1])

42− [~ 42]

43− > (mack [4 0 4])

44− ~

45− > (mack [[[0 2] [1 3]] 4 4 4 4 0 5])

46− [~ 6]

47− > ;;((unit @tas) (mack [[1 %yes %no] 6 [0 2] [0 6] 0 7]))

48− [~ %no]

38+> (mack [[1 2 3] [0 1]])

39+[~ [1 2 3]]

40+

41+> (mack [41 4 0 1])

42+[~ 42]

43+

44+> (mack [4 0 4])

45+~

46+

47+> (mack [[[0 2] [1 3]] 4 4 4 4 0 5])

48+[~ 6]

49+

50+> ;;((unit @tas) (mack [[1 %yes %no] 6 [0 2] [0 6] 0 7]))

51+[~ %no]

4952```

5053

5154---

@@ -55,122 +58,204 @@ The `++unit` of a noun.

5558Mock interpreter

5659

5760Bottom-level mock (virtual nock) interpreter. Produces a

58−`++tone`, a nock computation result. If nock 11 is invoked, `sky`

59−computes on the subject and produces a `++unit` result. An empty

60−result becomes a `%1` `++tone`, indicating a block.

61+`tone`, a nock computation result. If nock 12 is invoked, `scry`

62+computes on the subject and produces a `(unit (unit))` result. An empty

63+result becomes a `%1` `tone`, indicating a block.

6164

6265#### Accepts

6366

64−`sub` is the subject as a noun.

67+`subject` is the subject as a noun.

6568

66−`fol` is the formula as a noun.

69+`formula` is the formula as a noun.

6770

68−`sky` is an `%iron` gate invoked with nock operator 11.

71+`scry` is an `%iron` gate invoked with nock operator 12.

6972

7073#### Produces

7174

72−A `++tone`.

75+A `tone`.

7376

7477#### Source

7578

7679```hoon

77− ++ mink

78− ~/ %mink

79− |= {{sub/* fol/*} gul/$-({* *} (unit (unit)))}

80− =+ tax=*(list {@ta *})

81− |- ^- tone

82− ?@ fol

83− [%2 tax]

84− ?: ?=(^ -.fol)

85− =+ hed=$(fol -.fol)

86− ?: ?=($2 -.hed)

87− hed

88− =+ tal=$(fol +.fol)

89− ?- -.tal

90− $0 ?-(-.hed $0 [%0 p.hed p.tal], $1 hed)

91− $1 ?-(-.hed $0 tal, $1 [%1 (weld p.hed p.tal)])

92− $2 tal

80+++ mink !.

81+ ~/ %mink

82+ |= $: [subject=* formula=*]

83+ scry=$-(^ (unit (unit)))

84+ ==

85+ =| trace=(list [@ta *])

86+ |^ ^- tone

87+ ?+ formula [%2 trace]

88+ [^ *]

89+ =/ head $(formula -.formula)

90+ ?. ?=(%0 -.head) head

91+ =/ tail $(formula +.formula)

92+ ?. ?=(%0 -.tail) tail

93+ [%0 product.head product.tail]

94+ ::

95+ [%0 axis=@]

96+ =/ part (frag axis.formula subject)

97+ ?~ part [%2 trace]

98+ [%0 u.part]

99+ ::

100+ [%1 constant=*]

101+ [%0 constant.formula]

102+ ::

103+ [%2 subject=* formula=*]

104+ =/ subject $(formula subject.formula)

105+ ?. ?=(%0 -.subject) subject

106+ =/ formula $(formula formula.formula)

107+ ?. ?=(%0 -.formula) formula

108+ %= $

109+ subject product.subject

110+ formula product.formula

93111 ==

94− ?+ fol

95− [%2 tax]

96112 ::

97− {$0 b/@}

98− ?: =(0 b.fol) [%2 tax]

99− ?: =(1 b.fol) [%0 sub]

100− ?: ?=(@ sub) [%2 tax]

101− =+ [now=(cap b.fol) lat=(mas b.fol)]

102− $(b.fol lat, sub ?:(=(2 now) -.sub +.sub))

113+ [%3 argument=*]

114+ =/ argument $(formula argument.formula)

115+ ?. ?=(%0 -.argument) argument

116+ [%0 .?(product.argument)]

103117 ::

104− {$1 b/*}

105− [%0 b.fol]

118+ [%4 argument=*]

119+ =/ argument $(formula argument.formula)

120+ ?. ?=(%0 -.argument) argument

121+ ?^ product.argument [%2 trace]

122+ [%0 .+(product.argument)]

106123 ::

107− {$2 b/{^ *}}

108− =+ ben=$(fol b.fol)

109− ?. ?=($0 -.ben) ben

110− ?>(?=(^ p.ben) $(sub -.p.ben, fol +.p.ben))

111− ::?>(?=(^ p.ben) $([sub fol] p.ben)

124+ [%5 a=* b=*]

125+ =/ a $(formula a.formula)

126+ ?. ?=(%0 -.a) a

127+ =/ b $(formula b.formula)

128+ ?. ?=(%0 -.b) b

129+ [%0 =(product.a product.b)]

112130 ::

113− {$3 b/*}

114− =+ ben=$(fol b.fol)

115− ?. ?=($0 -.ben) ben

116− [%0 .?(p.ben)]

131+ [%6 test=* yes=* no=*]

132+ =/ result $(formula test.formula)

133+ ?. ?=(%0 -.result) result

134+ ?+ product.result

135+ [%2 trace]

136+ %& $(formula yes.formula)

137+ %| $(formula no.formula)

138+ ==

117139 ::

118− {$4 b/*}

119− =+ ben=$(fol b.fol)

120− ?. ?=($0 -.ben) ben

121− ?. ?=(@ p.ben) [%2 tax]

122− [%0 .+(p.ben)]

140+ [%7 subject=* next=*]

141+ =/ subject $(formula subject.formula)

142+ ?. ?=(%0 -.subject) subject

143+ %= $

144+ subject product.subject

145+ formula next.formula

146+ ==

123147 ::

124− {$5 b/*}

125− =+ ben=$(fol b.fol)

126− ?. ?=($0 -.ben) ben

127− ?. ?=(^ p.ben) [%2 tax]

128− [%0 =(-.p.ben +.p.ben)]

148+ [%8 head=* next=*]

149+ =/ head $(formula head.formula)

150+ ?. ?=(%0 -.head) head

151+ %= $

152+ subject [product.head subject]

153+ formula next.formula

154+ ==

129155 ::

130− {$6 b/* c/* d/*}

131− $(fol =>(fol [2 [0 1] 2 [1 c d] [1 0] 2 [1 2 3] [1 0] 4 4 b]))

156+ [%9 axis=@ core=*]

157+ =/ core $(formula core.formula)

158+ ?. ?=(%0 -.core) core

159+ =/ arm (frag axis.formula product.core)

160+ ?~ arm [%2 trace]

161+ %= $

162+ subject product.core

163+ formula u.arm

164+ ==

132165 ::

133− {$7 b/* c/*} $(fol =>(fol [2 b 1 c]))

134− {$8 b/* c/*} $(fol =>(fol [7 [[0 1] b] c]))

135− {$9 b/* c/*} $(fol =>(fol [7 c 0 b]))

136− {$10 @ c/*} $(fol c.fol)

137− {$10 {b/* c/*} d/*}

138− =+ ben=$(fol c.fol)

139− ?. ?=($0 -.ben) ben

140− ?: ?=(?($hunk $hand $lose $mean $spot) b.fol)

141− $(fol d.fol, tax [[b.fol p.ben] tax])

142− $(fol d.fol)

166+ [%10 [axis=@ value=*] target=*]

167+ ?: =(0 axis.formula) [%2 trace]

168+ =/ target $(formula target.formula)

169+ ?. ?=(%0 -.target) target

170+ =/ value $(formula value.formula)

171+ ?. ?=(%0 -.value) value

172+ =/ mutant=(unit *)

173+ (edit axis.formula product.target product.value)

174+ ?~ mutant [%2 trace]

175+ [%0 u.mutant]

143176 ::

144− {$11 b/* c/*}

145− =+ ref=$(fol b.fol)

146− =+ ben=$(fol c.fol)

147− ?. ?=($0 -.ref) ref

148− ?. ?=($0 -.ben) ben

149− =+ val=(gul p.ref p.ben)

150− ?~(val [%1 p.ben ~] ?~(u.val [%2 [[%hunk (mush p.ben)] tax]] [%0 u.u.val]))

177+ [%11 tag=@ next=*]

178+ =/ next $(formula next.formula)

179+ ?. ?=(%0 -.next) next

180+ :- %0

181+ .* subject

182+ [11 tag.formula 1 product.next]

183+ ::

184+ [%11 [tag=@ clue=*] next=*]

185+ =/ clue $(formula clue.formula)

186+ ?. ?=(%0 -.clue) clue

187+ =/ next

188+ =? trace

189+ ?=(?(%hunk %hand %lose %mean %spot) tag.formula)

190+ [[tag.formula product.clue] trace]

191+ $(formula next.formula)

192+ ?. ?=(%0 -.next) next

193+ :- %0

194+ .* subject

195+ [11 [tag.formula 1 product.clue] 1 product.next]

196+ ::

197+ [%12 ref=* path=*]

198+ =/ ref $(formula ref.formula)

199+ ?. ?=(%0 -.ref) ref

200+ =/ path $(formula path.formula)

201+ ?. ?=(%0 -.path) path

202+ =/ result (scry product.ref product.path)

203+ ?~ result

204+ [%1 product.path]

205+ ?~ u.result

206+ [%2 [%hunk product.ref product.path] trace]

207+ [%0 u.u.result]

151208 ==

152− ::

209+ ::

210+ ++ frag

211+ |= [axis=@ noun=*]

212+ ^- (unit)

213+ ?: =(0 axis) ~

214+ |- ^- (unit)

215+ ?: =(1 axis) `noun

216+ ?@ noun ~

217+ =/ pick (cap axis)

218+ %= $

219+ axis (mas axis)

220+ noun ?-(pick %2 -.noun, %3 +.noun)

221+ ==

222+ ::

223+ ++ edit

224+ |= [axis=@ target=* value=*]

225+ ^- (unit)

226+ ?: =(1 axis) `value

227+ ?@ target ~

228+ =/ pick (cap axis)

229+ =/ mutant

230+ %= $

231+ axis (mas axis)

232+ target ?-(pick %2 -.target, %3 +.target)

233+ ==

234+ ?~ mutant ~

235+ ?- pick

236+ %2 `[u.mutant +.target]

237+ %3 `[-.target u.mutant]

238+ ==

239+ --

153240```

154241

155242#### Examples

156243

157244```

158− > (mink [20 [4 0 1]] $~)

159− [%0 p=21]

160− > (mink [[90 5 3] [0 3]] $~)

161− [%0 p=[5 3]]

162− > (mink 20^[4 0 1] $~)

163− [%0 p=21]

164− > (mink [90 5 3]^[0 3] $~)

165− [%0 p=[5 3]]

166− > (mink [0]^[11 1 20] $~)

167− [%1 p=~[20]]

168− > (mink [0]^[11 1 20] |=(a=* `[40 a]))

169− [%0 p=[40 20]]

170− > (mink [5]^[0 2] $~)

171− [%2 p=~]

172− > (mink [5]^[10 yelp/[0 1] 0 0] $~)

173− [%2 p=~[[~.yelp 5]]]

245+> (mink [20 [4 0 1]] ,~)

246+[%0 product=21]

247+

248+> (mink [[[4 5] [6 14 15]] [0 7]] ,~)

249+[%0 product=[14 15]]

250+

251+> (mink [42 12 [0 1] [1 73]] |=(a=^ ``(add (,[@ @] a))))

252+[%0 product=115]

253+

254+> (mink [0 12 [1 0] [1 0]] |=(* ~))

255+[%1 block=0]

256+

257+> (mink [42 0 2] ,~)

258+[%2 trace=~]

174259```

175260

176261---

@@ -179,9 +264,9 @@ A `++tone`.

179264

180265Compute formula on subject with hint

181266

182−Produces a `++toon`, which is either a sucessful, blocked, or

183−crashed result. If nock 11 is invoked, `sky` computes on the subject and

184−produces a `++unit` result. An empty result becomes a `%1` `++tune`,

267+Produces a `toon`, which is either a sucessful, blocked, or

268+crashed result. If nock 11 is invoked, `gul` computes on the subject and

269+produces a `(unit (unit))` result. An empty result becomes a `%1` `tune`,

185270indicating a block.

186271

187272#### Accepts

@@ -190,38 +275,193 @@ indicating a block.

190275

191276`fol` is the formula as a noun.

192277

193−`sky` is an %iron gate invoked with nock operator 11.

278+`gul` is an %iron gate invoked with nock operator 11.

279+

280+#### Produces

281+

282+The `unit` of a noun.

283+

284+#### Source

285+

286+```hoon

287+++ mock

288+ |= [[sub=* fol=*] gul=$-(^ (unit (unit)))]

289+ (mook (mink [sub fol] gul))

290+```

291+

292+#### Examples

293+

294+```

295+> (mock [5 4 0 1] ,~)

296+[%0 p=6]

297+

298+> (mock [0 12 [0 1] [0 1]] |=(* ``999))

299+[%0 p=999]

300+

301+> (mock [42 12 [0 1] [0 1]] |=(* ~))

302+[%1 p=42]

303+

304+> (mock [42 0 2] ,~)

305+[%2 p=~]

306+```

307+

308+---

309+

310+## `++mook`

311+

312+Intelligently render crash annotation

313+

314+Converts a `%2` `tone` nock stack trace to a list of `tank`. Each may be a

315+`tank`, `cord`, `spot`, or trapped `tank`.

316+

317+#### Accepts

318+

319+`ton` is a `tone`.

194320

195321#### Produces

196322

197−The `++unit` of a noun.

323+A `toon`.

198324

199325#### Source

200326

201327```hoon

202− ++ mock

203− |= {{sub/* fol/*} gul/$-({* *} (unit (unit)))}

204− (mook (mink [sub fol] gul))

328+++ mook

329+ |= ton=tone

330+ ^- toon

331+ ?. ?=([%2 *] ton)

332+ ton

333+ |^ [%2 (turn skip rend)]

334+ ::

335+ ++ skip

336+ ^+ trace.ton

337+ =/ yel (lent trace.ton)

338+ ?. (gth yel 1.024) trace.ton

339+ %+ weld

340+ (scag 512 trace.ton)

341+ ^+ trace.ton

342+ :_ (slag (sub yel 512) trace.ton)

343+ :- %lose

344+ (crip "[skipped {(scow %ud (sub yel 1.024))} frames]")

345+ ::

346+ :: +rend: raw stack frame to tank

347+ ::

348+ :: $% [%hunk ref=* path] :: failed scry ([~ ~])

349+ :: [%lose cord] :: skipped frames

350+ :: [%hand *] :: mug any

351+ :: [%mean $@(cord (trap tank))] :: ~_ et al

352+ :: [%spot spot] :: source location

353+ :: ==

354+ ::

355+ ++ rend

356+ |= [tag=@ta dat=*]

357+ ^- tank

358+ ?+ tag

359+ ::

360+ leaf+"mook.{(rip 3 tag)}"

361+ ::

362+ %hunk

363+ ?@ dat leaf+"mook.hunk"

364+ =/ sof=(unit path) ((soft path) +.dat)

365+ ?~ sof leaf+"mook.hunk"

366+ (smyt u.sof)

367+ ::

368+ %lose

369+ ?^ dat leaf+"mook.lose"

370+ leaf+(rip 3 dat)

205371 ::

372+ %hand

373+ leaf+(scow %p (mug dat))

374+ ::

375+ %mean

376+ ?@ dat leaf+(rip 3 dat)

377+ =/ mac (mack dat -.dat)

378+ ?~ mac leaf+"####"

379+ =/ sof ((soft tank) u.mac)

380+ ?~ sof leaf+"mook.mean"

381+ u.sof

382+ ::

383+ %spot

384+ =/ sof=(unit spot) ((soft spot) dat)

385+ ?~ sof leaf+"mook.spot"

386+ :+ %rose [":" ~ ~]

387+ :~ (smyt p.u.sof)

388+ =* l p.q.u.sof

389+ =* r q.q.u.sof

390+ =/ ud |=(a=@u (scow %ud a))

391+ leaf+"<[{(ud p.l)} {(ud q.l)}].[{(ud p.r)} {(ud q.r)}]>"

392+ ==

393+ ==

394+ --

395+```

396+

397+#### Examples

398+

399+```

400+> (mook [%0 5 4 5 1])

401+[%0 p=[5 4 5 1]]

402+

403+> (mook [%2 ~[[%hunk %rose ["<" "," ">"] ~[[%leaf "err"]]]]])

404+[%2 p=~[[%leaf p="mook.hunk"]]]

405+

406+> (mook [%2 ~[[%mean |.(>(add 5 6)<)]]])

407+[%2 p=~[[%leaf p="11"]]]

408+

409+> (mook [%2 ~[[%spot /b/repl [1 1]^[1 2]] [%mean |.(!!)]]])

410+[ %2

411+ p

412+ ~[

413+ [ %rose

414+ p=[p=":" q="" r=""]

415+ q

416+ [ i

417+ [ %rose

418+ p=[p="/" q="/" r=""]

419+ q=[i=[%leaf p="b"] t=[i=[%leaf p="repl"] t=~]]

420+ ]

421+ t=[i=[%leaf p="<[1 1].[1 2]>"] t=~]

422+ ]

423+ ]

424+ [%leaf p="####"]

425+ ]

426+]

427+```

428+

429+---

430+

431+## `++mole`

432+

433+Typed unitary virtual

434+

435+Kicks a `trap`, producing its result in a `unit` if successful, or a null `unit`

436+if it crashed. Unitized version of [`++mule`](#mule).

437+

438+#### Accepts

439+

440+`tap` is a `trap`.

441+

442+#### Produces

443+

444+A `(unit *)`, where the `*` will be the type produced by the expression.

445+

446+#### Source

447+

448+```hoon

449+++ mole

450+ ~/ %mole

451+ |* tap=(trap)

452+ ^- (unit _$:tap)

453+ =/ mur (mure tap)

454+ ?~(mur ~ `$:tap)

206455```

207456

208457#### Examples

209458

210459```

211− > (mock [5 4 0 1] ,~)

212− [%0 p=6]

213− > (mock [~ 11 1 0] |=(* `999))

214− [%0 p=999]

215− > (mock [~ 0 1.337] ,~)

216− [%2 p=~]

217− > (mock [~ 11 1 1.337] ,~)

218− [%1 p=~[1.337]]

219− > (mock [[[4 4 4 4 0 3] 10] 11 9 2 0 1] |=(* `[+<]))

220− [%0 p=14]

221− > (mock [[[4 4 4 4 0 3] 10] 11 9 2 0 1] |=(* `[<+<>]))

222− [%0 p=[49 52 0]]

223− > ;;(tape +:(mock [[[4 4 4 4 0 3] 10] 11 9 2 0 1] |=(* `[<+<>])))

224− "14"

460+> (mole |.(`@t`(add 50 47)))

461+[~ 'a']

462+

463+> (mole |.(~|('Error!' !!)))

464+~

225465```

226466

227467---

@@ -230,179 +470,137 @@ The `++unit` of a noun.

230470

231471Slam gate with sample

232472

233−Produces a `++toon` computation result from slamming `gat` with

234−`sam`, using `sky` to compute or block on nock 11 when applicable.

473+Produces a `toon` computation result from slamming `gat` with

474+`sam`, using `gul` to compute or block on nock 11 when applicable.

235475

236476#### Accepts

237477

238478`gat` is a noun that is generally a `gate`.

239479

240−`sam` is a `sample` noun.

480+`sam` is a sample noun.

241481

242−`sky` is an %iron gate invoked with nock operator 11.

482+`gul` is an `%iron` gate invoked with nock operator 11.

243483

244484#### Produces

245485

246−A `++toon`.

486+A `toon`.

247487

248488#### Source

249489

250490```hoon

251− ++ mong

252− |= {{gat/* sam/*} gul/$-({* *} (unit (unit)))}

253− ^- toon

254− ?. &(?=(^ gat) ?=(^ +.gat))

255− [%2 ~]

256− (mock [[-.gat [sam +>.gat]] -.gat] gul)

257− ::

491+++ mong

492+ |= [[gat=* sam=*] gul=$-(^ (unit (unit)))]

493+ ^- toon

494+ ?. ?=([* ^] gat) [%2 ~]

495+ (mock [gat(+< sam) %9 2 %0 1] gul)

258496```

259497

260498#### Examples

261499

262500```

263− > (mong [|=(@ 20) ~] ,~)

264− [%0 p=20]

265− > (mong [|=(@ !!) ~] ,~)

266− [%2 p=~]

267− > (mong [|=(a/@ (add 20 a)) ~] ,~)

268− [%0 p=20]

269− > (mong [|=(a/[@ @] (add 20 -.a)) ~] ,~)

270− [%2 p=~]

271− > (mong [|=(a/[@ @] (add 20 -.a)) [4 6]] ,~)

272− [%0 p=24]

273− > (mong [|=(a/@ .^(a)) ~] ,~)

274− [%1 p=~[0]]

275− > (mong [|=(a/@ .^(a)) ~] ,[~ %42])

276− [%0 p=42]

277− > (mong [|=(a/@ .^(a)) ~] |=(a/* [~ a 6]))

278− [%0 p=[0 6]]

279− > (mong [|=(a/@ .^(a)) 8] |=(a/* [~ a 6]))

280− [%0 p=[8 6]]

501+> (mong [|=(@ 20) ~] ,~)

502+[%0 p=20]

503+

504+> (mong [|=(@ !!) ~] ,~)

505+[%2 p=~]

506+

507+> (mong [|=(a=@ (add 20 a)) ~] ,~)

508+[%0 p=20]

509+

510+> (mong [|=(a=[@ @] (add 20 -.a)) ~] ,~)

511+[%2 p=~]

512+

513+> (mong [|=(a=[@ @] (add 20 -.a)) [4 6]] ,~)

514+[%0 p=24]

515+

516+> (mong [|=(a=@ .^(* a)) 99] |=(^ ``+<))

517+[%0 p=[[140 1.853.189.998] 99]]

518+

519+> (mong [|=(a=@ .^(@ a)) 99] |=([* a=*] ``+((,@ a))))

520+[%0 p=100]

281521```

282522

283523---

284524

285−## `++mook`

525+## `++mule`

286526

287−Intelligently render crash annotation

527+Typed virtual

288528

289−Converts a `%2` `++tone` nock stack trace to a list of `++tank`.

290−Each may be a tank, cord, `++spot`, or trapped tank.

529+Kicks a `trap`, producing its results or any errors that occur along

530+the way. Used to lazily compute stack traces.

291531

292532#### Accepts

293533

294−`ton` is a `++tone`.

534+`tap` is a `trap`, generally producing a list of `tank`s.

295535

296536#### Produces

297537

298−A `++toon`.

538+An `(each * (list tank))` - `%.y` indicates success and `%.n` indicates a crash.

299539

300540#### Source

301541

302542```hoon

303− ++ mook

304− |= ton/tone

305− ^- toon

306− ?. ?=({$2 *} ton) ton

307− :- %2

308− :: =. p.ton (moop p.ton)

309− =+ yel=(lent p.ton)

310− =. p.ton

311− ?. (gth yel 256) p.ton

312− %+ weld

313− (scag 128 p.ton)

314− ^- (list {@ta *})

315− :_ (slag (sub yel 128) p.ton)

316− :- %lose

317− %+ rap 3

318− "[skipped {(scow %ud (sub yel 256))} frames]"

319− |- ^- (list tank)

320− ?~ p.ton ~

321− =+ rep=$(p.ton t.p.ton)

322− ?+ -.i.p.ton rep

323− $hunk [(tank +.i.p.ton) rep]

324− $lose [[%leaf (rip 3 (@ +.i.p.ton))] rep]

325− $hand [[%leaf (scow %p (mug +.i.p.ton))] rep]

326− $mean :_ rep

327− ?@ +.i.p.ton [%leaf (rip 3 (@ +.i.p.ton))]

328− =+ mac=(mack +.i.p.ton +<.i.p.ton)

329− ?~(mac [%leaf "####"] (tank u.mac))

330− $spot :_ rep

331− =+ sot=(spot +.i.p.ton)

332− :+ %rose [":" ~ ~]

333− :~ (smyt p.sot)

334− => [ud=|=(a/@u (scow %ud a)) q.sot]

335− leaf+"<[{(ud p.p)} {(ud q.p)}].[{(ud p.q)} {(ud q.q)}]>"

336− == ==

337− ::

543+++ mule

544+ ~/ %mule

545+ |* tap=(trap)

546+ =/ mud (mute tap)

547+ ?- -.mud

548+ %& [%& p=$:tap]

549+ %| [%| p=p.mud]

550+ ==

338551```

339552

340553#### Examples

341554

342555```

343− > (mook [%0 5 4 5 1])

344− [%0 p=[5 4 5 1]]

345− > (mook [%2 ~[[%hunk %rose ["<" "," ">"] ~[[%leaf "err"]]]]])

346− [%2 p=~[[%rose p=[p="<" q="," r=">"] q=[i=[%leaf p="err"] t=~]]]]

347− > (mook [%2 ~[[%malformed %elem] [%lose 'do print']]])

348− [%2 p=~[[%leaf p="do print"]]]

349− > (mook [%2 ~[[%mean |.(>(add 5 6)<)]]])

350− [%2 p=~[[%leaf p="11"]]]

351− > (mook [%2 ~[[%spot /b/repl [1 1]^[1 2]] [%mean |.(!!)]]])

352− [%2 p=~[[%leaf p="/b/repl/:<[1 1].[1 2]>"] [%leaf p="####"]]]

556+> (mule |.((add 1 1)))

557+[%.y p=2]

558+

559+> (mule |.(~|(%error !!)))

560+[%.n p=~[[%leaf p="%error"]]]

353561```

354562

355563---

356564

357−## `++mule`

565+## `++mure`

358566

359−Typed virtual

567+Untyped unitary virtual

360568

361−Kicks a `++trap`, producing its results or any errors that occur along

362−the way. Used to lazily compute stack traces.

569+Kicks a `trap`, producing its results in a `unit` which is null if it crashed.

570+The result is just a noun, no type information is preserved.

363571

364572#### Accepts

365573

366−`taq` is a `++trap`, generally producing a list of `++tank`s.

574+A `trap`.

367575

368576#### Produces

369577

370−XX

578+A `(unit *)`.

371579

372580#### Source

373581

374582```hoon

375− ++ mule :: typed virtual

376− ~/ %mule

377− |* taq/_|.(**)

378− =+ mud=(mute taq)

379− ?- -.mud

380− $& [%& p=$:taq] :: XX transition

381− $| [%| p=p.mud]

382− ==

383− ::

583+++ mure

584+ |= tap=(trap)

585+ ^- (unit)

586+ =/ ton (mink [tap %9 2 %0 1] |=((pair) ``.*(~ [%12 1+p 1+q])))

587+ ?.(?=(%0 -.ton) ~ `product.ton)

384588```

385589

386590#### Examples

387591

388592```

389− > (mule |.(leaf/"hello"))

390− [%.y p=[%leaf "hello"]]

391− > (mule |.(!!))

392− [%.n p=~]

393− > (mule |.(.^(a//=pals/1)))

394− [ %.n

395− p

396− ~[

397− [ %rose

398− p=[p="/" q="/" r="/"]

399− q

400− [ i=[%leaf p="a"]

401− t=[i=[%leaf p="~zod"] t=[i=[%leaf p="pals"] t=[i=[%leaf p="1"] t=~]]]

402− ]

403− ]

404− ]

405− ]

593+> (mure |.(~|(%error !!)))

594+~

595+

596+> (mure |.((add 1 1)))

597+[~ 2]

598+

599+> (mure |.('foo'))

600+[~ 7.303.014]

601+

602+> ((unit @t) (mure |.('foo')))

603+[~ 'foo']

406604```

407605

408606---

@@ -411,39 +609,115 @@ XX

411609

412610Untyped virtual

413611

414−Kicks a `++trap`, producing its result as a noun or the tanks of any

415−error that occurs. Similar to `++mule`, but preserves no type

416−information.

612+Kicks a `trap`, producing its result as a noun or the tanks of any error that

613+occurs. Similar to [`++mule`](#mule), but preserves no type information.

417614

418615#### Accepts

419616

420−`taq` is a `++trap`.

617+`tap` is a `trap`.

421618

422619#### Produces

423620

424−Either a noun or a `++list` of `++tank`.

621+A `(each * (list tank))`, where `%.y` indicates success and `%.n` indicates

622+failure.

425623

426624#### Source

427625

428626```hoon

429− ++ mute :: untyped virtual

430− |= taq/_^?(|.(**))

431− ^- (each * (list tank))

432− =+ ton=(mock [taq 9 2 0 1] |=({* *} ~))

433− ?- -.ton

434− $0 [%& p.ton]

435− $1 [%| (turn p.ton |=(a/* (smyt (path a))))]

436− $2 [%| p.ton]

437− ==

627+++ mute

628+ |= tap=(trap)

629+ ^- (each * (list tank))

630+ =/ ton (mock [tap %9 2 %0 1] |=((pair) ``.*(~ [%12 1+p 1+q])))

631+ ?- -.ton

632+ %0 [%& p.ton]

633+ ::

634+ %1 =/ sof=(unit path) ((soft path) p.ton)

635+ [%| ?~(sof leaf+"mute.hunk" (smyt u.sof)) ~]

636+ ::

637+ %2 [%| p.ton]

638+ ==

639+```

640+

641+#### Examples

642+

643+```

644+> (mute |.(leaf+"hello"))

645+[%.y p=[1.717.658.988 104 101 108 108 111 0]]

646+

647+> (mute |.(!!))

648+[%.n p=~]

649+

650+> (mute |.(~|(%error !!)))

651+[%.n p=~[[%leaf p="%error"]]]

652+

653+> (mute |.((cat 3 'foo' 'bar')))

654+[%.y p=125.762.588.864.358]

438655```

439656

657+---

658+

659+## `++slum`

660+

661+Slam a gate on a sample using raw nock, untyped

662+

663+Slam `gat` with `sam`. Uses a raw `.*` nock expression internally and does not

664+preserve type information for the result. This will crash if evaluation crashes.

665+

440666#### Examples

441667

442668```

443− > (mute |.(leaf/"hello"))

444− [%.y p=[1.717.658.988 104 101 108 108 111 0]]

445− > (mute |.(!!))

446− [%.n p=~]

669+> (slum |=([a=@ b=@] (add a b)) [7 9])

670+16

671+

672+> (slum (cury cat 3) ['foo' 'bar'])

673+125.762.588.864.358

674+

675+> (@t (slum (cury cat 3) ['foo' 'bar']))

676+'foobar'

677+

678+> (slum |=(* !!) 42)

679+dojo: hoon expression failed

680+```

681+

682+---

683+

684+## `++soft`

685+

686+Virtual clam

687+

688+Clam (mold) noun `fud` with `mold` `han`, producing a `unit` of the result. The

689+`unit` is null if clamming failed. This is curried, so the soft-clamming gate can

690+be stored and called repeatedly.

691+

692+#### Accepts

693+

694+`han` is a `mold`.

695+

696+`fud` is a noun.

697+

698+#### Produces

699+

700+A `(unit *)`, where the `*` will be the type produced by the mold.

701+

702+#### Source

703+

704+```hoon

705+++ soft

706+ |* han=$-(* *)

707+ |=(fud=* (mole |.((han fud))))

708+```

709+

710+#### Examples

711+

712+```

713+> ((soft @t) 97)

714+[~ 'a']

715+

716+> ((soft @t) [1 2])

717+~

718+

719+> ((soft ,[@ux @ux]) ['a' 'b'])

720+[~ [0x61 0x62]]

447721```

448722

449723---

content/docs/hoon/reference/stdlib/4o.md+1101−314

@@ -4,683 +4,1470 @@ weight = 42

44template = "doc.html"

55+++

7−## `++abel`

7+## `+$abel`

9−Biblical names in hoon are primarily aliases for the compiler.

9+Original sin: type

10+

11+Old type, same as the new `type`.

1012

1113#### Source

1214

1315```hoon

14− ++ abel typo :: original sin: type

16++$ abel typo

1517```

1618

1719#### Examples

1820

1921```

20− > *abel

21− %void

22+> *abel

23+#t/*

24+```

25+

26+---

27+

28+## `+$alas`

29+

30+Alias list

31+

32+This is the type used in `%brcb` (`|_` door) `hoon` type for `+*` alias arms.

33+

34+#### Source

35+

36+```hoon

37++$ alas (list (pair term hoon))

38+```

39+

40+---

41+

42+## `+$atom`

43+

44+Just an atom

45+

46+This is the same as `@`.

47+

48+#### Source

49+

50+```hoon

51++$ atom @

52+```

53+

54+#### Examples

55+

56+```

57+> *atom

58+0

59+

60+> `atom`'foo'

61+7.303.014

2262```

2363

2464---

2565

26−## `++aura`

66+## `+$aura`

2767

2868'type' of atom

2969

30−By convention, a short name for a category of atom. `++aura` is

31−circularly defined, with `@ta` being the `++aura` of the ASCII subset

32−commonly used in urbit.

70+By convention, a short name for a category of atom. `aura` is circularly

71+defined, with `@ta` being the `aura` of the ASCII subset commonly used in urbit.

3372

3473#### Source

3574

3675```hoon

37− ++ aura ,@ta :: atom format

76++$ aura @ta

3877```

3978

4079#### Examples

4180

42−See also: `++base`, aura reference

81+See also: [`+$base`](#base), aura reference

4382

4483```

45− > `aura`%ux

46− ~.ux

84+> `aura`'ux'

85+~.ux

4786```

4887

4988---

5089

51−## `++base`

90+## `+$base`

5291

5392Base type

5493

55−A base type that nouns are built from. A `++base` is either a noun, cell,

56−boolean or null labelled with an aura.

94+A base type that nouns are built from. A `base` is either a noun, atom with

95+aura, cell, boolean, null, or an empty set.

5796

5897#### Source

5998

6099```hoon

61− ++ base ?([%atom p=aura] %noun %cell %bean %null) :: axils, @ * ^ ? ~

100++$ base :: base mold

101+ $@ $? %noun :: any noun

102+ %cell :: any cell

103+ %flag :: loobean

104+ %null :: ~ == 0

105+ %void :: empty set

106+ == ::

107+ [%atom p=aura] :: atom

62108```

63109

64110#### Examples

65111

66112```

67− > *base

68− %null

113+> *base

114+%void

69115

70− > (ream '=|(^ !!)')

71− [%tsbr p=[%axil p=%cell] q=[%zpzp ~]]

72− > :: p.p is a ++base

73− > (ream '=|(@t !!)')

74− [%tsbr p=[%axil p=[%atom p=~.t]] q=[%zpzp ~]]

75− > (ream '=|(? !!)')

76− [%tsbr p=[%axil p=%bean] q=[%zpzp ~]]

116+> (ream '=|(^ !!)')

117+[%tsbr p=[%base p=%cell] q=[%zpzp ~]]

77118```

78119

79120---

80121

81−## `++beer`

122+## `+$woof`

82123

83−Tape builder

124+Simple embed

84125

85−Used to build tapes internally.

126+An atom or some `hoon`.

86127

87128#### Source

88129

89130```hoon

90− ++ beer $|(@ [~ p=hoon]) :: simple embed

131++$ woof $@(@ [~ p=hoon])

91132```

92133

93134#### Examples

94135

95136```

96− > `beer`'as'

97− 29.537

98− > `beer`[~ (ream 'lan')]

99− [~ p=[%cnzz p=~[%lan]]]

137+> *woof

138+0

139+

140+> `woof`[~ %base p=%cell]

141+[~ p=[%base p=%cell]]

142+

143+> `woof`'foo'

144+7.303.014

100145```

101146

102147---

103148

104−## `++beet`

149+## `+$chum`

105150

106−XML interpolation cases

151+Jet hint information

107152

108−Used internally.

153+Jet hint information that must be present in the body of a `~/` or `~%` rune. A

154+`chum` can optionally contain a kelvin version, jet vendor, and version number.

109155

110156#### Source

111157

112158```hoon

113− ++ beet $| @ :: advanced embed

114− $% [%a p=hoon] :: take tape

115− [%b p=hoon] :: take manx

116− [%c p=hoon] :: take marl

117− [%d p=hoon] :: take $+(marl marl)

118− [%e p=hoon q=(list tuna)] :: element literal

119− == ::

159++$ chum $? lef=term :: jet name

160+ [std=term kel=@] :: kelvin version

161+ [ven=term pro=term kel=@] :: vendor and product

162+ [ven=term pro=term ver=@ kel=@] :: all of the above

163+ == ::

164+```

165+

166+#### Examples

167+

168+```

169+> `chum`'hi'

170+lef=%hi

171+

172+> (ream '~/(%lob.314 !!)')

173+[%sgfs p=[std=%lob kel=314] q=[%zpzp ~]]

120174```

121175

122176---

123177

124−## `++chum`

178+## `+$coil`

125179

126−Jet hint information

180+Tuple of core information

127181

128−Jet hint information that must be present in the body of a `~/` or `~%`

129−rune. A `++chum` can optionally contain a kelvin version, jet vendor,

130−and `"{major}.{minor}"` version number.

182+Variance `p`, subject type `q`, and `r`: optional compiled nock, and arms. Used

183+as an intermediate step during compilation and converted to a core.

131184

132185#### Source

133186

134187```hoon

135− ++ chum $? lef=term :: jet name

136− [std=term kel=@] :: kelvin version

137− [ven=term pro=term kel=@] :: vendor and product

138− [ven=term pro=term ver=@ kel=@] :: all of the above

139− == ::

188++$ coil $: p=garb :: name, wet=dry, vary

189+ q=type :: context

190+ r=(pair seminoun (map term tome)) :: chapters

191+ == ::

140192```

141193

142−#### Examples

194+---

143195

144−XX there's a ++chum in zuse that's politely causing this not to work

196+## `+$garb`

145197

146−```

147− > `chum`'hi'

148− lef=%hi

198+Core metadata

149199

150− > (ream '~/(%lob.314 !!)')

151− [%sgfs p=[std=%lob kel=314] q=[%zpzp ~]]

200+A triple of an optional name, polarity (wet/dry), and variance (`%iron`, etc).

201+

202+#### Source

203+

204+```hoon

205++$ garb (trel (unit term) poly vair)

152206```

153207

154208---

155209

156−## `++coil`

210+## `+$poly`

157211

158−Tuple of core information

212+Polarity

159213

160−Variance `p`, subject type `q`, and `q`: optional compiled nock, and arms. Used as an

161−intermediate step within Section 2fB. Converted by `++core` to %core type.

214+Whether a core is wet or dry.

162215

163216#### Source

164217

165218```hoon

166− ++ coil $: p=?(%gold %iron %lead %zinc) :: core type

167− q=type ::

168− r=[p=?(~ ^) q=(map term foot)] ::

169− == ::

219++$ poly ?(%wet %dry)

170220```

171221

172222---

173223

174−## `++foot`

224+## `+$foot`

175225

176226Cases of arms by variance model.

177227

178−`%ash` arms are `dry` and geometric.

228+#### Source

229+

230+```hoon

231++$ foot $% [%dry p=hoon] :: dry arm, geometric

232+ [%wet p=hoon] :: wet arm, generic

233+ ==

234+```

235+

236+---

237+

238+## `+$link`

239+

240+Lexical segment

241+

242+Used for documentation.

243+

244+#### Source

245+

246+```hoon

247++$ link :: lexical segment

248+ $% [%chat p=term] :: |chapter

249+ [%cone p=aura q=atom] :: %constant

250+ [%frag p=term] :: .leg

251+ [%funk p=term] :: +arm

252+ ==

253+```

254+

255+---

256+

257+## `+$crib`

258+

259+Summary and details

260+

261+Summary and details for documentation.

179262

180263#### Source

181264

182265```hoon

183− ++ foot $% [%ash p=hoon] :: dry arm, geometric

184− [%elm p=hoon] :: wet arm, generic

185− [%oak ~] :: XX not used

186− [%yew p=(map term foot)] :: XX not used

187− == ::

266++$ crib [summary=cord details=(list sect)]

267+```

268+

269+---

270+

271+## `+$help`

272+

273+Documentation

274+

275+#### Source

276+

277+```hoon

278++$ help [links=(list link) =crib]

279+```

280+

281+---

282+

283+## `+$limb`

284+

285+Wing element

286+

287+Reference into subject by tree address or name.

288+

289+#### Source

290+

291+```hoon

292++$ limb $@ term :: wing element

293+ $% [%& p=axis] :: by geometry

294+ [%| p=@ud q=(unit term)] :: by name

295+ == ::

188296```

189297

190298#### Examples

191299

192−See also: `++ap`, `++ut`

300+```

301+> (ream '^^$')

302+[%wing p=~[[%.n p=2 q=[~ %$]]]]

303+```

304+

305+---

193306

307+## `+$null`

308+

309+Null, nil, etc

310+

311+Just `~`.

312+

313+#### Source

314+

315+```hoon

316++$ null ~

194317```

195− > *foot

196− [%yew p={}]

197318

198− > (ream '|% ++ $ foo --')

199− [%brcn p={[p=%$ q=[%ash p=[%cnzz p=~[%foo]]]]}]

200− > +<+:(ream '|% ++ $ foo --')

201− t=~[%ash %cnzz %foo]

202− > (foot +<+:(ream '|% ++ $ foo --'))

203− [%ash p=[%cnzz p=~[%foo]]]

204− > (foot +<+:(ream '|% +- $ foo --'))

205− [%elm p=[%cnzz p=~[%foo]]]

319+#### Examples

320+

321+```

322+> *null

323+~

206324```

207325

208326---

209327

210−## `++limb`

328+## `+$onyx`

329+

330+Arm activation

331+

332+#### Source

211333

212334```hoon

213− ++ limb $|(term $%([%& p=axis] [%| p=@ud q=term])) ::

335++$ onyx (list (pair type foot))

214336```

215337

216−XX move to `++ut`

338+---

217339

218−Reference into subject by name/axis

340+## `+$opal`

219341

220−See also: section 2fC-2fD

342+Wing match

343+

344+Arm or leg of a wing.

345+

346+#### Source

221347

222348```hoon

223− > (ream '^^$')

224− [%cnzz p=~[[%.n p=2 q=%$]]]

225− > (limb &2:(ream '^^$'))

226− [%.n p=2 q=%$]

227− > (limb &2:(ream '^^^$'))

228− [%.n p=3 q=%$]

349++$ opal :: limb match

350+ $% [%& p=type] :: leg

351+ [%| p=axis q=(set [p=type q=foot])] :: arm

352+ == ::

229353```

230354

231355---

232356

233−## `++line`

357+## `+$pica`

234358

235−XX move to `++ut`

359+Prose or code

360+

361+A `(pair ? cord)`. If `%.y` it's prose and if `%.n` it's code. Used in

362+documentation.

236363

237364#### Source

238365

239366```hoon

240− ++ line ,[p=[%leaf p=aura q=@] q=tile] :: %kelp case

367++$ pica (pair ? cord)

241368```

242369

243−#### Examples

370+---

244371

372+## `+$palo`

373+

374+Wing trace, match

375+

376+A [`$vein`](#vein) and a [`$opal`](#opal).

377+

378+#### Source

379+

380+```hoon

381++$ palo (pair vein opal)

245382```

246− > (ream '$%([1 a] [%2 b])')

247− [ %bccm

248− p

249− [ %kelp

250− p

251− [ i=[p=[%leaf p=~.ud q=1] q=[%herb p=[%cnzz p=~[%a]]]]

252− t=~[[p=[%leaf p=~.ud q=2] q=[%herb p=[%cnzz p=~[%b]]]]]

253− ]

254− ]

255− ]

256− > &3:(ream '$%([1 a] [%2 b])')

257− p=[p=[%leaf p=%ud q=1] q=[%herb p=[%cnzz p=~[%a]]]]

258− > (line &3:(ream '$%([1 a] [%2 b])'))

259− [p=[%leaf p=~.ud q=1] q=[%herb p=[%cnzz p=~[%a]]]]

383+

384+---

385+

386+## `+$plat`

387+

388+%hoon, %type, %nock or %tank

389+

390+#### Source

391+

392+```hoon

393++$ plat

394+ $? %hoon

395+ %type

396+ %nock

397+ %tank

398+ ==

260399```

261400

262401---

263402

264−## `++metl`

403+## `+$pock`

404+

405+Changes

406+

407+#### Source

265408

266409```hoon

267− ++ metl ?(%gold %iron %zinc %lead) :: core variance

410++$ pock (pair axis nock)

268411```

269412

270−XX move to `++ut`

413+---

271414

272−See also: `++coil`

415+## `+$port`

416+

417+Successful wing match

418+

419+#### Source

420+

421+```hoon

422++$ port (each palo (pair type nock))

423+```

273424

274425---

275426

276−## `++nock`

427+## `+$spec`

277428

278−Virtual machine. See Nock.

429+Structure definition AST.

279430

280431#### Source

281432

282433```hoon

283− ++ nock $& [p=nock q=nock] :: autocons

284− [%3 p=nock] :: cell test

285− [%4 p=nock] :: increment

286− [%5 p=nock q=nock] :: equality test

287− [%6 p=nock q=nock r=nock] :: if, then, else

288− [%7 p=nock q=nock] :: serial compose

289− [%8 p=nock q=nock] :: push onto subject

290− [%9 p=@ q=nock] :: select arm and fire

291− [%10 p=?(@ [p=@ q=nock]) q=nock] :: hint

292− [%11 p=nock] :: grab data from sky

293− == ::

434++$ spec :: structure definition

435+ $~ [%base %null] ::

436+ $% [%base p=base] :: base type

437+ [%dbug p=spot q=spec] :: set debug

438+ [%leaf p=term q=@] :: constant atom

439+ [%like p=wing q=(list wing)] :: reference

440+ [%loop p=term] :: hygienic reference

441+ [%made p=(pair term (list term)) q=spec] :: annotate synthetic

442+ [%make p=hoon q=(list spec)] :: composed spec

443+ [%name p=term q=spec] :: annotate simple

444+ [%over p=wing q=spec] :: relative to subject

445+ :: ::

446+ [%bcgr p=spec q=spec] :: $>, filter: require

447+ [%bcbc p=spec q=(map term spec)] :: $$, recursion

448+ [%bcbr p=spec q=hoon] :: $|, verify

449+ [%bccb p=hoon] :: $_, example

450+ [%bccl p=[i=spec t=(list spec)]] :: $:, tuple

451+ [%bccn p=[i=spec t=(list spec)]] :: $%, head pick

452+ [%bcdt p=spec q=(map term spec)] :: $., read-write core

453+ [%bcgl p=spec q=spec] :: $<, filter: exclude

454+ [%bchp p=spec q=spec] :: $-, function core

455+ [%bckt p=spec q=spec] :: $^, cons pick

456+ [%bcls p=stud q=spec] :: $+, standard

457+ [%bcfs p=spec q=(map term spec)] :: $/, write-only core

458+ [%bcmc p=hoon] :: $;, manual

459+ [%bcpm p=spec q=hoon] :: $&, repair

460+ [%bcsg p=hoon q=spec] :: $~, default

461+ [%bctc p=spec q=(map term spec)] :: $`, read-only core

462+ [%bcts p=skin q=spec] :: $=, name

463+ [%bcpt p=spec q=spec] :: $@, atom pick

464+ [%bcwt p=[i=spec t=(list spec)]] :: $?, full pick

465+ [%bczp p=spec q=(map term spec)] :: $!, opaque core

466+ == ::

294467```

295468

296469#### Examples

297470

298471```

299− > !=([+(.) 20 -<])

300− [[4 0 1] [1 20] 0 4]

301− > (nock !=([+(.) 20]))

302− [p=[%4 p=[%0 p=1]] q=[%1 p=20]]

472+> *spec

473+[%base p=%null]

474+

475+> `spec`[%bccl ~[leaf+ud+1 leaf+ud+2]]

476+[%bccl p=[i=[%leaf p=%ud q=1] t=~[[%leaf p=%ud q=2]]]]

303477```

304478

305479---

306480

307−## `++null`

481+## `+$tent`

482+

483+Model builder

484+

485+#### Source

486+

487+```hoon

488++$ tent

489+ $% [%| p=wing q=tent r=(list spec)] :: ~(p q r...)

490+ [%& p=(list wing)] :: a.b:c.d

491+ == ::

492+```

493+

494+---

495+

496+## `+$tiki`

497+

498+Test case

499+

500+This is used when compiling `?-` expressions and similar.

501+

502+#### Source

308503

309504```hoon

310− ++ null ,~ :: null, nil, etc

505++$ tiki :: test case

506+ $% [%& p=(unit term) q=wing] :: simple wing

507+ [%| p=(unit term) q=hoon] :: named wing

508+ == ::

311509```

312510

313−Used nowhere XX

511+---

512+

513+## `+$skin`

514+

515+Texture

516+

517+This type is used for faces and similar by the compiler.

518+

519+#### Source

314520

521+```hoon

522++$ skin :: texture

523+ $@ =term :: name/~[term %none]

524+ $% [%base =base] :: base match

525+ [%cell =skin =skin] :: pair

526+ [%dbug =spot =skin] :: trace

527+ [%leaf =aura =atom] :: atomic constant

528+ [%help =help =skin] :: describe

529+ [%name =term =skin] :: apply label

530+ [%over =wing =skin] :: relative to

531+ [%spec =spec =skin] :: cast to

532+ [%wash depth=@ud] :: strip faces

533+ == ::

315534```

316− > :type; *null

317− ~

318− %~

535+

536+---

537+

538+## `+$tome`

539+

540+Core chapter

541+

542+This type is used by the compiler for the contents of arms in cores.

543+

544+#### Source

545+

546+```hoon

547++$ tome (pair what (map term hoon))

319548```

320549

321550---

322551

323−## `++port`

552+## `+$tope`

324553

325−XX move to `++ut`

554+Topographic type

326555

327−Type and location of core-shaped thing? XX Compiler Internals

556+Describes the structure of a noun.

328557

329558#### Source

330559

331560```hoon

332− ++ port $: p=axis ::

333− $= q ::

334− $% [%& p=type] ::

335− [%| p=axis q=(list ,[p=type q=foot])] ::

336− == ::

337− == ::

561++$ tope :: topographic type

562+ $@ $? %& :: cell or atom

563+ %| :: atom

564+ == ::

565+ (pair tope tope) :: cell

338566```

339567

340568#### Examples

341569

342570```

343− > *port

344− [p=0 q=[%.y p=%void]]

571+> *tope

572+%.n

573+

574+> `tope`[%| %&]

575+[p=%.n q=%.y]

345576```

346577

347578---

348579

349−## `++span`

580+## `++hoot`

350581

351−ASCII atom

582+Hoon tools

352583

353−A restricted text atom for canonical atom syntaxes. The prefix is `~.`.

354−There are no escape sequences except `~~`, which means `~`, and `~-`,

355−which means `_`. `-` and `.` encode themselves. No other characters

356−besides numbers and lowercase letters are permitted.

584+Container core for internally-used XML structure types. XML structure types

585+you'd typically use directly are defined in [Standard Library section

586+5e](/docs/hoon/reference/stdlib/5e).

357587

358588#### Source

359589

360590```hoon

361− ++ span ,@ta :: text-atom (ASCII)

591+++ hoot

592+ |%

593+```

594+

595+---

596+

597+### `+$beer:hoot`

598+

599+Simple embed

600+

601+Either a tape element or interpolated hoon expression in an XML attribute.

602+

603+#### Source

604+

605+```hoon

606++$ beer $@(char [~ p=hoon])

607+```

608+

609+---

610+

611+### `+$mane:hoot`

612+

613+XML name+space

614+

615+XML tag name and optional namespace.

616+

617+#### Source

618+

619+```hoon

620++$ mane $@(@tas [@tas @tas])

362621```

363622

364623#### Examples

365624

366625```

367− > *span

368− ~.

626+> (en-xml:html ;foo;)

627+"<foo></foo>"

628+

629+> (en-xml:html ;foo_bar;)

630+"<foo:bar></foo:bar>"

631+

632+> `manx:hoot`;foo_bar;

633+[g=[n=[%foo %bar] a=~] c=~]

369634

370− > `@t`~.foo

371− 'foo'

372− > `@t`~.foo.bar

373− 'foo.bar'

374− > `@t`~.foo~~bar

375− 'foo~bar'

376− > `@t`~.foo~-bar

377− 'foo_bar'

378− > `@t`~.foo-bar

379− 'foo-bar'

635+> `mane:hoot`n.g:`manx`;foo_bar;

636+[%foo %bar]

637+

638+> `mane:hoot`n.g:`manx:hoot`;foo;

639+%foo

380640```

381641

382642---

383643

384−## `++tiki`

644+### `+$manx:hoot`

645+

646+Dynamic XML node

385647

386−XX move to `++ut`

648+An XML element which may contain text, attributes, and other elements.

649+

650+`g` is a [`$marx:hoot`](#marxhoot) (a tag) and `c` is a

651+[`$marl:hoot`](#marlhoot) (its contents).

387652

388653#### Source

389654

390655```hoon

391− ++ tiki :: test case

656++$ manx $~([[%$ ~] ~] [g=marx c=marl])

392657```

393658

394659#### Examples

395660

396661```

397−A `++wing` or `++hoon`.

398−

399− > (ream '=+ a=4 ?-(a @ ~)')

400− [ %tsls

401− p=[%ktts p=p=%a q=[%dtzy p=%ud q=4]]

402− q

403− [ %wthz

404− p=[%.y p=~ q=~[%a]]

405− q=~[[p=[%axil p=[%atom p=~.]] q=[%bczp p=%null]]]

406− ]

662+> *manx:hoot

663+[g=[n=%$ a=~] c=~

664+

665+> `manx:hoot`;foo;

666+[g=[n=%foo a=~] c=~]

667+

668+> (en-xml:html `manx:hoot`;foo;)

669+"<foo></foo>"

670+

671+> =a ^- manx:hoot

672+ ;foo

673+ ;bar: abc

674+ ;baz

675+ ;xxx: hello

676+ ==

677+ ==

678+

679+> a

680+[ g=[n=%foo a=~]

681+ c

682+ ~[

683+ [ g=[n=%bar a=~]

684+ c=~[[g=[n=%$ a=~[[n=%$ v="abc"]]] c=~]]

407685 ]

408− > (ream '=+ a=4 ?-(4 @ ~)')

409− [ %tsls

410− p=[%ktts p=p=%a q=[%dtzy p=%ud q=4]]

411− q

412− [ %wthz

413− p=[%.n p=~ q=[%dtzy p=%ud q=4]]

414− q=~[[p=[%axil p=[%atom p=~.]] q=[%bczp p=%null]]]

686+ [ g=[n=%baz a=~]

687+ c

688+ ~[

689+ [ g=[n=%xxx a=~]

690+ c=~[[g=[n=%$ a=~[[n=%$ v="hello"]]] c=~]]

691+ ]

415692 ]

416693 ]

694+ ]

695+]

696+

697+> (en-xml:html a)

698+"<foo><bar>abc</bar><baz><xxx>hello</xxx></baz></foo>"

417699```

418700

419701---

420702

421−## `++toga`

703+### `+$marl:hoot`

704+

705+Dynamic XML nodes

706+

707+A list of XML nodes - maybe with interpolation and recursion. See

708+[`$tuna:hoot`](#tunahoot).

709+

710+#### Source

711+

712+```hoon

713++$ marl (list tuna)

714+```

422715

423−Tree of faces

716+#### Examples

424717

425−A face, or tree of faces. A `++toga` is applied to anything assigned

426−using `^=`.

718+```

719+> *marl

720+~

721+

722+> ^- marl:hoot

723+ ;=

724+ ;foo: abc

725+ ;bar: def

726+ ==

727+~[

728+ [g=[n=%foo a=~] c=~[[g=[n=%$ a=~[[n=%$ v=~['a' 'b' 'c']]]] c=~]]]

729+ [g=[n=%bar a=~] c=~[[g=[n=%$ a=~[[n=%$ v=~['d' 'e' 'f']]]] c=~]]]

730+]

731+

732+> %- en-xml:html

733+ ;baz

734+ ;=

735+ ;foo: abc

736+ ;bar: def

737+ ==

738+ ==

739+"<baz><foo>abc</foo><bar>def</bar></baz>"

740+```

741+

742+---

427743

428−XX move to `++ut` and rune doc (for \^= examples)

744+### `+$mart:hoot`

745+

746+Dynamic XML attributes

747+

748+A list of atributes for an XML tag. For each list item, `n` is a

749+[`$mane:hoot`](#manehoot) (an attribute name with optional namespace) and `v` is

750+a `(list beer:hoot)` (the attribute itself, maybe with interpolated hoon).

429751

430752#### Source

431753

432754```hoon

433− ++ toga :: face control

434− [2 p=toga q=toga] :: cell toga

435− == ::

755++$ mart (list [n=mane v=(list beer)])

436756```

437757

438758#### Examples

439759

440760```

441− > a=1

442− a=1

443− > (ream 'a=1')

444− [%ktts p=p=%a q=[%dtzy p=%ud q=1]]

445− > [a b]=[1 2 3]

446− [a=1 b=[2 3]]

447− > (ream '[a b]=[1 2 3]')

448− [ %ktts

449− p=[%2 p=p=%a q=p=%b]

450− q=[%cltr p=~[[%dtzy p=%ud q=1] [%dtzy p=%ud q=2] [%dtzy p=%ud q=3]]]

451− ]

761+> *mart:hoot

762+~

452763

453− > [a ~]=[1 2 3]

454− [a=1 2 3]

455− > (ream '[a ~]=[1 2 3]')

456− [ %ktts

457− p=[%2 p=p=%a q=[%0 ~]]

458− q=[%cltr p=~[[%dtzy p=%ud q=1] [%dtzy p=%ud q=2] [%dtzy p=%ud q=3]]]

459− ]

764+> `manx:hoot`;foo.bar;

765+[g=[n=%foo a=~[[n=%class v=~['b' 'a' 'r']]]] c=~]

766+

767+> `mart:hoot`a.g:`manx:hoot`;foo.bar;

768+~[[n=%class v=~['b' 'a' 'r']]]

769+

770+> (en-xml:html ;foo.bar;)

771+"<foo class=\"bar\"></foo>"

460772```

461773

462774---

463775

464−## `++tone`

776+### `+$marx:hoot`

465777

466−Intermediate Nock computation result

778+Dynamic XML tag

467779

468−Similar to `++toon`, but stack trace is not yet rendered.

780+An XML tag with optional attributes. `n` is a [`$mane:hoot`](#manehoot) (the tag

781+name with optional namespace) and `a` is a [`$mart:hoot`](marthoot) (any XML

782+attributes).

469783

470784#### Source

471785

472786```hoon

473− ++ tone $% [%0 p=*] :: success

787++$ marx $~([%$ ~] [n=mane a=mart])

474788```

475789

476790#### Examples

477791

478792```

479− > (mink [[20 21] 0 3] ,~)

480− [%0 p=21]

793+> `manx:hoot`;foo.bar;

794+[g=[n=%foo a=~[[n=%class v=~['b' 'a' 'r']]]] c=~]

481795

482− > (mink [[0] !=(.^(cy//=main/1))] ,~)

483− [%1 p=~[[31.075 1.685.027.454 1.852.399.981 49 0]]]

484− > (path [31.075 1.685.027.454 1.852.399.981 49 0])

485− /cy/~zod/main/1

796+> `marx:hoot`g:`manx:hoot`;foo.bar;

797+[n=%foo a=~[[n=%class v=~['b' 'a' 'r']]]]

486798

487− > (mink [[1 2] !=(~|(%hi +(.)))] ,~)

488− [%2 p=~[[~.yelp 26.984]]]

489− > (mink [[1 2] !=(!:(+(.)))] ,~)

490− [ %2

491− p

492− ~[

493− [ ~.spot

494− [ [ 1.685.027.454

495− 7.959.156

496− \/159.445.990.350.374.058.574.398.238.344.143.957.205.628.479.572.65\/

497− 8.112.403.878.526

498− \/ \/

499− 0

500− ]

501− [1 20]

502− 1

503− 24

504− ]

505− ]

506− ]

507− ]

799+> (en-xml:html ;foo.bar;)

800+"<foo class=\"bar\"></foo>"

508801```

509802

510803---

511804

512−## `++tuna`

805+### `+$mare:hoot`

513806

514−XML template tree

807+Node or nodes

515808

516−An XML template tree.

809+If `%.y`, a [`$manx:hoot`](#manxhoot) (single XML node). If `%.n`, a

810+[`$marl:hoot`](#marlhoot) (list of XML nodes).

517811

518812#### Source

519813

520814```hoon

521− ++ tuna :: tagflow

522− [%d p=hoon] :: dynamic list

523− [%e p=hoon q=(list tuna)] :: element

524− [%f p=(list tuna)] :: subflow

525− == ::

815++$ mare (each manx marl)

526816```

527817

528818#### Examples

529819

530−Leaf %a contains plain-text, %b an empty tag, %c a static list, %d a

531−dynamic list, %e a full node element containing a hoon and a list of

532−tuna, and %f is a empty node.

820+```

821+> *mare:hoot

822+[%.y p=[g=[n=%$ a=~] c=~]]

823+

824+> `mare:hoot`[%.y ;foo.bar;]

825+[%.y p=[g=[n=%foo a=~[[n=%class v=~['b' 'a' 'r']]]] c=~]]

826+

827+> `mare:hoot`[%.n ~[;foo.bar; ;baz;]]

828+[%.n p=~[[g=[n=%foo a=~[[n=%class v=~['b' 'a' 'r']]]] c=~] [g=[n=%baz a=~] c=~]]]

829+```

830+

831+---

832+

833+### `+$maru:hoot`

533834

534−See also: `++sail`

835+Interpolation or nodes

836+

837+If `%.y`, a [`$tuna:hoot`](#tunahoot). If `%.n`, a [`$marl:hoot`](#marlhoot).

838+

839+#### Source

840+

841+```hoon

842++$ maru (each tuna marl)

843+```

844+

845+---

846+

847+### `+$tuna:hoot`

848+

849+Maybe interpolation

850+

851+Kinds of nodes. Either an ordinary [`$manx:hoot`](#manxhoot), or else a plain tape, a

852+[`$marl:hoot`](#marlhoot), or a function call.

853+

854+#### Source

855+

856+```hoon

857++$ tuna

858+ $~ [[%$ ~] ~]

859+ $^ manx

860+ $: ?(%tape %manx %marl %call)

861+ p=hoon

862+ ==

863+```

535864

536865---

537866

538−## `++tusk`

867+## `+$hoon`

539868

540−List of expressions

869+Hoon AST

541870

542−List of `++hoon`s. In `:*`, for example, your contents is

543−a `++tusk`.

871+See the [Rune section](/docs/hoon/reference/rune) of the Hoon reference for

872+details of what many of these relate to.

544873

545874#### Source

546875

547876```hoon

548− ++ tusk (list hoon) ::

877++$ hoon ::

878+ $~ [%zpzp ~]

879+ $^ [p=hoon q=hoon] ::

880+ $% ::

881+ [%$ p=axis] :: simple leg

882+ :: ::

883+ [%base p=base] :: base spec

884+ [%bust p=base] :: bunt base

885+ [%dbug p=spot q=hoon] :: debug info in trace

886+ [%eror p=tape] :: assembly error

887+ [%hand p=type q=nock] :: premade result

888+ [%note p=note q=hoon] :: annotate

889+ [%fits p=hoon q=wing] :: underlying ?=

890+ [%knit p=(list woof)] :: assemble string

891+ [%leaf p=(pair term @)] :: symbol spec

892+ [%limb p=term] :: take limb

893+ [%lost p=hoon] :: not to be taken

894+ [%rock p=term q=*] :: fixed constant

895+ [%sand p=term q=*] :: unfixed constant

896+ [%tell p=(list hoon)] :: render as tape

897+ [%tune p=$@(term tune)] :: minimal face

898+ [%wing p=wing] :: take wing

899+ [%yell p=(list hoon)] :: render as tank

900+ [%xray p=manx:hoot] :: ;foo; templating

901+ :: :::::: cores

902+ [%brbc sample=(lest term) body=spec] :: |$

903+ [%brcb p=spec q=alas r=(map term tome)] :: |_

904+ [%brcl p=hoon q=hoon] :: |:

905+ [%brcn p=(unit term) q=(map term tome)] :: |%

906+ [%brdt p=hoon] :: |.

907+ [%brkt p=hoon q=(map term tome)] :: |^

908+ [%brhp p=hoon] :: |-

909+ [%brsg p=spec q=hoon] :: |~

910+ [%brtr p=spec q=hoon] :: |*

911+ [%brts p=spec q=hoon] :: |=

912+ [%brpt p=(unit term) q=(map term tome)] :: |@

913+ [%brwt p=hoon] :: |?

914+ :: :::::: tuples

915+ [%clcb p=hoon q=hoon] :: :_ [q p]

916+ [%clkt p=hoon q=hoon r=hoon s=hoon] :: :^ [p q r s]

917+ [%clhp p=hoon q=hoon] :: :- [p q]

918+ [%clls p=hoon q=hoon r=hoon] :: :+ [p q r]

919+ [%clsg p=(list hoon)] :: :~ [p ~]

920+ [%cltr p=(list hoon)] :: :* p as a tuple

921+ :: :::::: invocations

922+ [%cncb p=wing q=(list (pair wing hoon))] :: %_

923+ [%cndt p=hoon q=hoon] :: %.

924+ [%cnhp p=hoon q=hoon] :: %-

925+ [%cncl p=hoon q=(list hoon)] :: %:

926+ [%cntr p=wing q=hoon r=(list (pair wing hoon))] :: %*

927+ [%cnkt p=hoon q=hoon r=hoon s=hoon] :: %^

928+ [%cnls p=hoon q=hoon r=hoon] :: %+

929+ [%cnsg p=wing q=hoon r=(list hoon)] :: %~

930+ [%cnts p=wing q=(list (pair wing hoon))] :: %=

931+ :: :::::: nock

932+ [%dtkt p=spec q=hoon] :: .^ nock 11

933+ [%dtls p=hoon] :: .+ nock 4

934+ [%dttr p=hoon q=hoon] :: .* nock 2

935+ [%dtts p=hoon q=hoon] :: .= nock 5

936+ [%dtwt p=hoon] :: .? nock 3

937+ :: :::::: type conversion

938+ [%ktbr p=hoon] :: ^| contravariant

939+ [%ktdt p=hoon q=hoon] :: ^. self-cast

940+ [%ktls p=hoon q=hoon] :: ^+ expression cast

941+ [%kthp p=spec q=hoon] :: ^- structure cast

942+ [%ktpm p=hoon] :: ^& covariant

943+ [%ktsg p=hoon] :: ^~ constant

944+ [%ktts p=skin q=hoon] :: ^= label

945+ [%ktwt p=hoon] :: ^? bivariant

946+ [%kttr p=spec] :: ^* example

947+ [%ktcl p=spec] :: ^: filter

948+ :: :::::: hints

949+ [%sgbr p=hoon q=hoon] :: ~| sell on trace

950+ [%sgcb p=hoon q=hoon] :: ~_ tank on trace

951+ [%sgcn p=chum q=hoon r=tyre s=hoon] :: ~% general jet hint

952+ [%sgfs p=chum q=hoon] :: ~/ function j-hint

953+ [%sggl p=$@(term [p=term q=hoon]) q=hoon] :: ~< backward hint

954+ [%sggr p=$@(term [p=term q=hoon]) q=hoon] :: ~> forward hint

955+ [%sgbc p=term q=hoon] :: ~$ profiler hit

956+ [%sgls p=@ q=hoon] :: ~+ cache=memoize

957+ [%sgpm p=@ud q=hoon r=hoon] :: ~& printf=priority

958+ [%sgts p=hoon q=hoon] :: ~= don't duplicate

959+ [%sgwt p=@ud q=hoon r=hoon s=hoon] :: ~? tested printf

960+ [%sgzp p=hoon q=hoon] :: ~! type on trace

961+ :: :::::: miscellaneous

962+ [%mcts p=marl:hoot] :: ;= list templating

963+ [%mccl p=hoon q=(list hoon)] :: ;: binary to nary

964+ [%mcfs p=hoon] :: ;/ [%$ [%$ p ~] ~]

965+ [%mcgl p=spec q=hoon r=hoon s=hoon] :: ;< bind

966+ [%mcsg p=hoon q=(list hoon)] :: ;~ kleisli arrow

967+ [%mcmc p=spec q=hoon] :: ;; normalize

968+ :: :::::: compositions

969+ [%tsbr p=spec q=hoon] :: =| push bunt

970+ [%tscl p=(list (pair wing hoon)) q=hoon] :: =: q w= p changes

971+ [%tsfs p=skin q=hoon r=hoon] :: =/ typed variable

972+ [%tsmc p=skin q=hoon r=hoon] :: =; =/(q p r)

973+ [%tsdt p=wing q=hoon r=hoon] :: =. r with p as q

974+ [%tswt p=wing q=hoon r=hoon s=hoon] :: =? conditional =.

975+ [%tsgl p=hoon q=hoon] :: =< =>(q p)

976+ [%tshp p=hoon q=hoon] :: =- =+(q p)

977+ [%tsgr p=hoon q=hoon] :: => q w=subject p

978+ [%tskt p=skin q=wing r=hoon s=hoon] :: =^ state machine

979+ [%tsls p=hoon q=hoon] :: =+ q w=[p subject]

980+ [%tssg p=(list hoon)] :: =~ hoon stack

981+ [%tstr p=(pair term (unit spec)) q=hoon r=hoon] :: =* new style

982+ [%tscm p=hoon q=hoon] :: =, overload p in q

983+ :: :::::: conditionals

984+ [%wtbr p=(list hoon)] :: ?| loobean or

985+ [%wthp p=wing q=(list (pair spec hoon))] :: ?- pick case in q

986+ [%wtcl p=hoon q=hoon r=hoon] :: ?: if=then=else

987+ [%wtdt p=hoon q=hoon r=hoon] :: ?. ?:(p r q)

988+ [%wtkt p=wing q=hoon r=hoon] :: ?^ if p is a cell

989+ [%wtgl p=hoon q=hoon] :: ?< ?:(p !! q)

990+ [%wtgr p=hoon q=hoon] :: ?> ?:(p q !!)

991+ [%wtls p=wing q=hoon r=(list (pair spec hoon))] :: ?+ ?- w=default

992+ [%wtpm p=(list hoon)] :: ?& loobean and

993+ [%wtpt p=wing q=hoon r=hoon] :: ?@ if p is atom

994+ [%wtsg p=wing q=hoon r=hoon] :: ?~ if p is null

995+ [%wthx p=skin q=wing] :: ?# if q matches p

996+ [%wtts p=spec q=wing] :: ?= if q matches p

997+ [%wtzp p=hoon] :: ?! loobean not

998+ :: :::::: special

999+ [%zpcm p=hoon q=hoon] :: !,

1000+ [%zpgr p=hoon] :: !>

1001+ [%zpgl p=spec q=hoon] :: !<

1002+ [%zpmc p=hoon q=hoon] :: !;

1003+ [%zpts p=hoon] :: !=

1004+ [%zppt p=(list wing) q=hoon r=hoon] :: !@

1005+ [%zpwt p=$@(p=@ [p=@ q=@]) q=hoon] :: !?

1006+ [%zpzp ~] :: !!

1007+ == ::

5491008```

5501009

5511010#### Examples

5521011

5531012```

554− > (ream '[1 2 3]')

555− [%cltr p=~[[%dtzy p=%ud q=1] [%dtzy p=%ud q=2] [%dtzy p=%ud q=3]]]

556− > (tusk +:(ream '[1 2 3]'))

557− ~[[%dtzy p=%ud q=1] [%dtzy p=%ud q=2] [%dtzy p=%ud q=3]]

1013+> *hoon

1014+[%zpzp ~]

1015+

1016+> `hoon`(ream '|=([a=@ b=@] [b a])')

1017+[ %brts

1018+ p

1019+ [ %bccl

1020+ p

1021+ [ i=[%bcts p=term=%a q=[%base p=[%atom p=~.]]]

1022+ t=~[[%bcts p=term=%b q=[%base p=[%atom p=~.]]]]

1023+ ]

1024+ ]

1025+ q=[%cltr p=~[[%wing p=~[%b]] [%wing p=~[%a]]]]

1026+]

5581027```

5591028

5601029---

5611030

562−## `++hoon`

1031+## `+$tyre`

5631032

564−Expression

1033+List, term hoon

5651034

566−An expression, or AST.

1035+Associative list of `term` `hoon`, used in jet hint processing.

5671036

568−See Rune section of Hoon reference

1037+#### Source

1038+

1039+```hoon

1040++$ tyre (list [p=term q=hoon]) ::

1041+```

5691042

5701043---

5711044

572−## `++tyke`

1045+## `+$tyke`

5731046

5741047List of 'maybe' hoons

5751048

576−List of `++unit` `++hoon`, or gaps left to be inferred, in `++path`

577−parsing. When you use a path such as `/=main=/pub/src/doc` the path is in fact

578−a `++tyke`, where the `=` are inferred from your current path.

1049+List of `unit` `hoon`, or gaps left to be inferred, in `path` parsing. When you

1050+use a path such as `/=base=/gen/code` the path is in fact a `tyke`, where the

1051+`=` are inferred from your current path.

1052+

1053+#### Source

1054+

1055+```hoon

1056++$ tyke (list (unit hoon))

1057+```

1058+

1059+---

1060+

1061+## `+$nock`

1062+

1063+Virtual nock.

1064+

1065+See the [Nock documentation](/docs/nock/definition) for details.

5791066

5801067#### Source

5811068

5821069```hoon

583− ++ tyke (list (unit hoon)) ::

1070++$ nock $^ [p=nock q=nock] :: autocons

1071+ $% [%1 p=*] :: constant

1072+ [%2 p=nock q=nock] :: compose

1073+ [%3 p=nock] :: cell test

1074+ [%4 p=nock] :: increment

1075+ [%5 p=nock q=nock] :: equality test

1076+ [%6 p=nock q=nock r=nock] :: if, then, else

1077+ [%7 p=nock q=nock] :: serial compose

1078+ [%8 p=nock q=nock] :: push onto subject

1079+ [%9 p=@ q=nock] :: select arm and fire

1080+ [%10 p=[p=@ q=nock] q=nock] :: edit

1081+ [%11 p=$@(@ [p=@ q=nock]) q=nock] :: hint

1082+ [%12 p=nock q=nock] :: grab data from sky

1083+ [%0 p=@] :: axis select

1084+ == ::

5841085```

5851086

5861087#### Examples

5871088

5881089```

589− > (scan "/==as=" porc:vast)

590− [0 ~[~ ~ [~ [%dtzy p=%tas q=29.537]] ~]]

591− > `tyke`+:(scan "/==as=" porc:vast)

592− ~[~ ~ [~ [%dtzy p=%tas q=29.537]] ~]

1090+> !=([+(.) 20 -<])

1091+[[4 0 1] [1 20] 0 4]

1092+

1093+> (nock !=([+(.) 20]))

1094+[p=[%4 p=[%0 p=1]] q=[%1 p=20]]

5931095```

5941096

5951097---

5961098

597−## `++typo`

1099+## `+$note`

1100+

1101+Type annotation

1102+

1103+Used for documentation.

1104+

1105+#### Source

1106+

1107+```hoon

1108++$ note :: type annotation

1109+ $% [%help p=help] :: documentation

1110+ [%know p=stud] :: global standard

1111+ [%made p=term q=(unit (list wing))] :: structure

1112+ == ::

1113+```

1114+

1115+---

5981116

599−Pointer for `++type`

1117+## `+$type`

6001118

601−Pointer for `++type`. `++typo` preserves the previous `++type` in your

602−context when upating.

1119+Hoon type type

6031120

6041121#### Source

6051122

6061123```hoon

607− ++ typo type :: old type

1124++$ type $~ %noun ::

1125+ $@ $? %noun :: any nouns

1126+ %void :: no noun

1127+ == ::

1128+ $% [%atom p=term q=(unit @)] :: atom / constant

1129+ [%cell p=type q=type] :: ordered pair

1130+ [%core p=type q=coil] :: object

1131+ [%face p=$@(term tune) q=type] :: namespace

1132+ [%fork p=(set type)] :: union

1133+ [%hint p=(pair type note) q=type] :: annotation

1134+ [%hold p=type q=hoon] :: lazy evaluation

1135+ == ::

6081136```

6091137

6101138#### Examples

6111139

612−See also: `++seem`, `++vise`, `++type`

1140+```

1141+> `type`[%cell [%atom %ud ~] [%atom %ud ~]]

1142+#t/[@ud @ud]

1143+```

6131144

6141145---

6151146

616−## `++tyre`

1147+## `+$tony`

6171148

618−List, term hoon

1149+`$tone` done right

1150+

1151+An intermediate Nock computation result. Similar to a

1152+[`$toon`](/docs/hoon/reference/stdlib/3g#toon) but without a rendered stack

1153+trace.

1154+

1155+#### Source

1156+

1157+```hoon

1158++$ tony :: ++tone done right

1159+ $% [%0 p=tine q=*] :: success

1160+ [%1 p=(set)] :: blocks

1161+ [%2 p=(list [@ta *])] :: error ~_s

1162+ == ::

1163+```

1164+

1165+---

6191166

620−Associative list of `++term` `++hoon`, used in jet hint processing.

1167+## `+$tine`

1168+

1169+Partial noun

6211170

6221171#### Source

6231172

6241173```hoon

625− ++ tyre (list ,[p=term q=hoon]) ::

1174++$ tine :: partial noun

1175+ $@ ~ :: open

1176+ $% [%& p=tine q=tine] :: half-blocked

1177+ [%| p=(set)] :: fully blocked

1178+ == ::

6261179```

6271180

6281181---

6291182

630−## `++vase`

1183+## `+$tool`

6311184

632−Typed data. A `++vase` is used wherever typed data is explicitly worked

633−with.

1185+Type decoration

6341186

6351187#### Source

6361188

6371189```hoon

638− ++ vase ,[p=type q=*] :: type-value pair

1190++$ tool $@(term tune)

1191+```

1192+

1193+---

1194+

1195+## `+$tune`

1196+

1197+Complex

1198+

1199+#### Source

1200+

1201+```hoon

1202++$ tune :: complex

1203+ $~ [~ ~] ::

1204+ $: p=(map term (unit hoon)) :: aliases

1205+ q=(list hoon) :: bridges

1206+ == ::

1207+```

1208+

1209+---

1210+

1211+## `+$typo`

1212+

1213+Old type

1214+

1215+Same as `$type`

1216+

1217+#### Source

1218+

1219+```hoon

1220++$ typo type

1221+```

1222+

1223+---

1224+

1225+## `+$vase`

1226+

1227+Type-value pair

1228+

1229+Typed data. A `$vase` is used wherever typed data is explicitly worked with.

1230+

1231+#### Source

1232+

1233+```hoon

1234++$ vase [p=type q=*]

6391235```

6401236

6411237#### Examples

6421238

6431239```

644− > `vase`!>(~)

645− [p=[%cube p=0 q=[%atom p=%n]] q=0]

1240+> *vase

1241+[#t/* q=0]

1242+

1243+> !>([2 2])

1244+[#t/[@ud @ud] q=[2 2]]

1245+

1246+> !>('foo')

1247+[#t/@t q=7.303.014]

1248+```

1249+

1250+---

1251+

1252+## `+$vise`

1253+

1254+Old vase

1255+

1256+Same as a [`$vase`](#vase).

1257+

1258+#### Source

1259+

1260+```hoon

1261++$ vise [p=typo q=*]

1262+```

1263+

1264+---

1265+

1266+## `+$vial`

1267+

1268+co/contra/in/bi

1269+

1270+Covariant, contravariant, invariant, bivariant.

1271+

1272+#### Source

1273+

1274+```hoon

1275++$ vial ?(%read %rite %both %free)

1276+```

1277+

1278+---

1279+

1280+## `+$vair`

1281+

1282+in/contra/bi/co

1283+

1284+Core variance.

1285+

1286+- `%gold` - invariant payload.

1287+- `%iron` - contravariant sample.

1288+- `%lead` - bivariant sample.

1289+- `%zinc` - covariant sample.

1290+

1291+See the Hoon School lesson on [type

1292+polymorphism](/docs/hoon/hoon-school/type-polymorphism) for more details.

1293+

1294+#### Source

1295+

1296+```hoon

1297++$ vair ?(%gold %iron %lead %zinc)

1298+```

1299+

1300+---

1301+

1302+## `+$vein`

1303+

1304+Search trace

1305+

1306+Noun search trace.

1307+

1308+#### Source

1309+

1310+```hoon

1311++$ vein (list (unit axis))

1312+```

1313+

1314+---

1315+

1316+## `+$sect`

1317+

1318+Paragraph

1319+

1320+Used in documentation.

1321+

1322+#### Source

1323+

1324+```hoon

1325++$ sect (list pica)

1326+```

1327+

1328+---

1329+

1330+## `+$whit`

1331+

1332+Documentation

1333+

1334+#### Source

1335+

1336+```hoon

1337++$ whit ::

1338+ $: lab=(unit term) :: label

1339+ boy=(unit (pair cord (list sect))) :: body

1340+ def=(map term (pair cord (list sect))) :: definitions

1341+ use=(set term) :: defs used

1342+ == ::

1343+```

1344+

1345+---

1346+

1347+## `+$what`

1348+

1349+Help slogan/section

1350+

1351+#### Source

1352+

1353+```hoon

1354++$ what (unit (pair cord (list sect)))

6461355```

6471356

6481357---

6491358

650−## `++vise`

1359+## `+$wing`

6511360

652−Convert during reboot

1361+Search path

6531362

654−Used to convert from previously-typed data during reboot.

1363+Address in subject. A `$wing` is a path to a value in the subject. A

1364+term alone is the trivial case of a `$wing`.

6551365

6561366#### Source

6571367

6581368```hoon

659− ++ vise ,[p=typo q=*] :: old vase

1369++$ wing (list limb)

6601370```

6611371

6621372#### Examples

6631373

664−See also: `++typo`, `++seer`

1374+```

1375+> (ream 'a.+.c')

1376+[%wing p=~[%a [%.y p=3] %c]]

1377+

1378+> (wing +:(ream 'a.+.c'))

1379+~[%a [%.y p=3] %c]

1380+```

6651381

6661382---

6671383

668−## `++wing`

1384+## `+$block`

1385+

1386+Abstract identity of resource awaited

1387+

1388+#### Source

6691389

6701390```hoon

671− ++ wing (list limb) ::

1391++$ block

1392+ path

6721393```

6731394

674−Address in subject. A `++wing` is a path to a value in the subject. A

675−term alone is the trivial case of a `++wing`.

1395+---

6761396

677−See also: `++hoon`

1397+## `+$result`

6781398

1399+Internal interpreter result

1400+

1401+#### Source

1402+

1403+```hoon

1404++$ result

1405+ $@(~ seminoun)

1406+```

1407+

1408+---

1409+

1410+## `+$thunk`

1411+

1412+Fragment constructor

1413+

1414+#### Source

1415+

1416+```hoon

1417++$ thunk

1418+ $-(@ud (unit noun))

6791419```

680− > (ream 'a.+.c')

681− [%cnzz p=~[%a [%.y p=3] %c]]

682− > (wing +:(ream 'a.+.c'))

683− ~[%a [%.y p=3] %c]

1420+

1421+---

1422+

1423+## `+$doss`

1424+

1425+Profiling

1426+

1427+#### Source

1428+

1429+```hoon

1430++$ doss

1431+ $: mon=moan :: sample count

1432+ hit=(map term @ud) :: hit points

1433+ cut=(map path hump) :: cut points

1434+ ==

1435+```

1436+

1437+---

1438+

1439+## `+$moan`

1440+

1441+Profiling: sample metric

1442+

1443+#### Source

1444+

1445+```hoon

1446++$ moan :: sample metric

1447+ $: fun=@ud :: samples in C

1448+ noc=@ud :: samples in nock

1449+ glu=@ud :: samples in glue

1450+ mal=@ud :: samples in alloc

1451+ far=@ud :: samples in frag

1452+ coy=@ud :: samples in copy

1453+ euq=@ud :: samples in equal

1454+ == ::

1455+```

1456+

1457+---

1458+

1459+## `+$hump`

1460+

1461+Profiling

1462+

1463+#### Source

1464+

1465+```hoon

1466++$ hump

1467+ $: mon=moan :: sample count

1468+ out=(map path @ud) :: calls out of

1469+ inn=(map path @ud) :: calls into

1470+ ==

6841471```

6851472

6861473---

content/docs/hoon/reference/stdlib/table-of-contents.md+141−52

@@ -16,7 +16,7 @@ Can be navigated [alphabetically](#alphabetical) or [by section](#by-section).

1616<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#ab' title="Primitive parser engine"><code>++ab</code></a>

1717<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#absfl' title="Absolute value"><code>++abs:fl</code></a>

1818<a class="tooltip" href='/docs/hoon/reference/stdlib/3a/#abssi' title="Absolute value (signed integer)"><code>++abs:si</code></a>

19−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#abel' title="Compiler alias"><code>++abel</code></a>

19+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#abel' title="Original sin: type"><code>+$abel</code></a>

2020<a class="tooltip" href='/docs/hoon/reference/stdlib/4h/#ace' title="Parse space"><code>++ace</code></a>

2121<a class="tooltip" href='/docs/hoon/reference/stdlib/4k/#a-coco' title="Render decimal"><code>++a-co:co</code></a>

2222<a class="tooltip" href='/docs/hoon/reference/stdlib/1a/#add' title="Add"><code>++add</code></a>

@@ -29,6 +29,7 @@ Can be navigated [alphabetically](#alphabetical) or [by section](#by-section).

2929<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#addrq' title="Add (quadprecision float)"><code>++add:rq</code></a>

3030<a class="tooltip" href='/docs/hoon/reference/stdlib/2n/#aftr' title="Pair after"><code>++aftr</code></a>

3131<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#ag' title="Toplevel atom parser engine"><code>++ag</code></a>

32+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#alas' title="Alias list"><code>+$alas</code></a>

3233<a class="tooltip" href='/docs/hoon/reference/stdlib/4i/#alf' title="Parse alphabetic characters"><code>++alf</code></a>

3334<a class="tooltip" href='/docs/hoon/reference/stdlib/2i/#allby' title="Logical AND (map and wet gate)"><code>++all:by</code></a>

3435<a class="tooltip" href='/docs/hoon/reference/stdlib/2h/#allin' title="Logical AND (set and wet gate)"><code>++all:in</code></a>

@@ -42,7 +43,8 @@ Can be navigated [alphabetically](#alphabetical) or [by section](#by-section).

4243<a class="tooltip" href='/docs/hoon/reference/stdlib/2h/#aptin' title="Check correctness (set)"><code>++apt:in</code></a>

4344<a class="tooltip" href='/docs/hoon/reference/stdlib/2k/#aptto' title="Check correctness of queue"><code>++apt:to</code></a>

4445<a class="tooltip" href='/docs/hoon/reference/stdlib/4b/#at' title="Basic printing"><code>++at</code></a>

45−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#aura' title="'Type' of atom"><code>++aura</code></a>

46+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#atom' title="Just an atom"><code>+$atom</code></a>

47+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#aura' title="'Type' of atom"><code>+$aura</code></a>

4648<a class="tooltip" href='/docs/hoon/reference/stdlib/2q/#axis' title="Tree address"><code>+$axis</code></a>

4749

4850### b

@@ -51,12 +53,11 @@ Can be navigated [alphabetically](#alphabetical) or [by section](#by-section).

5153<a class="tooltip" href='/docs/hoon/reference/stdlib/2k/#balto' title="Balance queue"><code>++bal:to</code></a>

5254<a class="tooltip" href='/docs/hoon/reference/stdlib/4h/#bar' title="Parse | (bar)"><code>++bar</code></a>

5355<a class="tooltip" href='/docs/hoon/reference/stdlib/4h/#bas' title="Parse \ (bas)"><code>++bas</code></a>

54−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#base' title="Base type"><code>++base</code></a>

56+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#base' title="Base type"><code>+$base</code></a>

5557<a class="tooltip" href='/docs/hoon/reference/stdlib/4f/#bass' title="Parser modifier (LSBordered ++list as atom of ++base)"><code>++bass</code></a>

5658<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#bayag' title="Parses binary number"><code>++bay:ag</code></a>

5759<a class="tooltip" href='/docs/hoon/reference/stdlib/2q/#bean' title="Boolean"><code>+$bean</code></a>

58−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#beer' title="Tape builder"><code>++beer</code></a>

59−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#beet' title="XML interpolation cases"><code>++beet</code></a>

60+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#beerhoot' title="Simple embed"><code>+$beer:hoot</code></a>

6061<a class="tooltip" href='/docs/hoon/reference/stdlib/4e/#bend' title="Conditional composer"><code>++bend</code></a>

6162<a class="tooltip" href='/docs/hoon/reference/stdlib/4i/#bet' title="Parse hep and lus axis syntax"><code>++bet</code></a>

6263<a class="tooltip" href='/docs/hoon/reference/stdlib/2c/#bex' title="Binary exponent"><code>++bex</code></a>

@@ -75,6 +76,7 @@ Can be navigated [alphabetically](#alphabetical) or [by section](#by-section).

7576<a class="tooltip" href='/docs/hoon/reference/stdlib/1c/#bite' title="Atom slice specificier"><code>$bite</code></a>

7677<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#bixab' title="Parse hex pair"><code>++bix:ab</code></a>

7778<a class="tooltip" href='/docs/hoon/reference/stdlib/4l/#biskso' title="Parse auraatom pair"><code>++bisk:so</code></a>

79+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#block' title="Abstract identity of resource awaited"><code>+$block</code></a>

7880<a class="tooltip" href='/docs/hoon/reference/stdlib/1c/#bloq' title="Blocksize"><code>$bloq</code></a>

7981<a class="tooltip" href='/docs/hoon/reference/stdlib/2a/#bond' title="Replace null"><code>++bond</code></a>

8082<a class="tooltip" href='/docs/hoon/reference/stdlib/4f/#boss' title="Parser modifier: LSB"><code>++boss</code></a>

@@ -96,13 +98,13 @@ Can be navigated [alphabetically](#alphabetical) or [by section](#by-section).

9698<a class="tooltip" href='/docs/hoon/reference/stdlib/3c/#cetyo' title="Days in a century"><code>++cet:yo</code></a>

9799<a class="tooltip" href='/docs/hoon/reference/stdlib/4a/#chafa' title="Decode base58check character"><code>++cha:fa</code></a>

98100<a class="tooltip" href='/docs/hoon/reference/stdlib/2q/#char' title="Character"><code>+$char</code></a>

99−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#chum' title="Jet hint information"><code>++chum</code></a>

101+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#chum' title="Jet hint information"><code>+$chum</code></a>

100102<a class="tooltip" href='/docs/hoon/reference/stdlib/4i/#cit' title="Octal digit"><code>++cit</code></a>

101103<a class="tooltip" href='/docs/hoon/reference/stdlib/2a/#clap' title="Combine two units with function"><code>++clap</code></a>

102104<a class="tooltip" href='/docs/hoon/reference/stdlib/2a/#clef' title="Compose two units with function"><code>++clef</code></a>

103105<a class="tooltip" href='/docs/hoon/reference/stdlib/3a/#cmpsi' title="Compare (signed integer)"><code>++cmp:si</code></a>

104106<a class="tooltip" href='/docs/hoon/reference/stdlib/4k/#co' title="Literal rendering engine"><code>++co</code></a>

105−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#coil' title="Tuple of core information"><code>++coil</code></a>

107+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#coil' title="Tuple of core information"><code>+$coil</code></a>

106108<a class="tooltip" href='/docs/hoon/reference/stdlib/3g/#coin' title="Nounliteral syntax cases"><code>+$coin</code></a>

107109<a class="tooltip" href='/docs/hoon/reference/stdlib/4h/#col' title="Parse : (col)"><code>++col</code></a>

108110<a class="tooltip" href='/docs/hoon/reference/stdlib/4f/#cold' title="Replace with constant"><code>++cold</code></a>

@@ -113,6 +115,7 @@ Can be navigated [alphabetically](#alphabetical) or [by section](#by-section).

113115<a class="tooltip" href='/docs/hoon/reference/stdlib/2q/#cord' title="UTF8 text"><code>+$cord</code></a>

114116<a class="tooltip" href='/docs/hoon/reference/stdlib/2n/#cork' title="Compose forward"><code>++cork</code></a>

115117<a class="tooltip" href='/docs/hoon/reference/stdlib/2n/#corl' title="Compose backward"><code>++corl</code></a>

118+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#crib' title="Summary and details"><code>+$crib</code></a>

116119<a class="tooltip" href='/docs/hoon/reference/stdlib/4b/#crip' title="Tape to cord"><code>++crip</code></a>

117120<a class="tooltip" href='/docs/hoon/reference/stdlib/4l/#crubso' title="Parse @da, @dr, @p, @t"><code>++crub:so</code></a>

118121<a class="tooltip" href='/docs/hoon/reference/stdlib/2p/#cue' title="Unpack atom to noun"><code>++cue</code></a>

@@ -159,6 +162,7 @@ Can be navigated [alphabetically](#alphabetical) or [by section](#by-section).

159162<a class="tooltip" href='/docs/hoon/reference/stdlib/4i/#doh' title="@p separator"><code>++doh</code></a>

160163<a class="tooltip" href='/docs/hoon/reference/stdlib/4h/#doq' title="Parse double quote"><code>++doq</code></a>

161164<a class="tooltip" href='/docs/hoon/reference/stdlib/2f/#dor' title="Depth order"><code>++dor</code></a>

165+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#doss' title="Profiling"><code>+$doss</code></a>

162166<a class="tooltip" href='/docs/hoon/reference/stdlib/4h/#dot' title="Parse period"><code>++dot</code></a>

163167<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#drgff' title="@r to decimal float"><code>++drg:ff</code></a>

164168<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#drgfl' title="Get printable decimal (signed and unsigned integer cell)"><code>++drg:fl</code></a>

@@ -233,7 +237,7 @@ Can be navigated [alphabetically](#alphabetical) or [by section](#by-section).

233237<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#fmars' title="Fused multiplyadd (singleprecision float)"><code>++fma:rs</code></a>

234238<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#fmarq' title="Fused multiplyadd (quadprecision float)"><code>++fma:rq</code></a>

235239<a class="tooltip" href='/docs/hoon/reference/stdlib/3a/#fo' title="Modulo prime"><code>++fo</code></a>

236−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#foot' title="Cases of arms by variance model"><code>++foot</code></a>

240+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#foot' title="Cases of arms by variance model"><code>+$foot</code></a>

237241<a class="tooltip" href='/docs/hoon/reference/stdlib/2n/#fore' title="Pair before"><code>++fore</code></a>

238242<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#fosrh' title="@rs to @rh"><code>++fos:rh</code></a>

239243<a class="tooltip" href='/docs/hoon/reference/stdlib/3a/#frafo' title="Divide (modular base)"><code>++fra:fo</code></a>

@@ -250,6 +254,7 @@ Can be navigated [alphabetically](#alphabetical) or [by section](#by-section).

250254<a class="tooltip" href='/docs/hoon/reference/stdlib/4i/#gap' title="Plural whitespace"><code>++gap</code></a>

251255<a class="tooltip" href='/docs/hoon/reference/stdlib/4i/#gaq' title="End of line"><code>++gaq</code></a>

252256<a class="tooltip" href='/docs/hoon/reference/stdlib/4h/#gar' title="Parse > (gar)"><code>++gar</code></a>

257+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#garb' title="Core metadata"><code>+$garb</code></a>

253258<a class="tooltip" href='/docs/hoon/reference/stdlib/2i/#gasby' title="Concatenate (map)"><code>++gas:by</code></a>

254259<a class="tooltip" href='/docs/hoon/reference/stdlib/2h/#gasin' title="Concatenate (set)"><code>++gas:in</code></a>

255260<a class="tooltip" href='/docs/hoon/reference/stdlib/2j/#gasju' title="Concatenate (jug)"><code>++gas:ju</code></a>

@@ -297,6 +302,7 @@ Can be navigated [alphabetically](#alphabetical) or [by section](#by-section).

297302<a class="tooltip" href='/docs/hoon/reference/stdlib/2j/#hasju' title="Check contents (jug)"><code>++has:ju</code></a>

298303<a class="tooltip" href='/docs/hoon/reference/stdlib/4h/#hax' title="Parse # (hax)"><code>++hax</code></a>

299304<a class="tooltip" href='/docs/hoon/reference/stdlib/2n/#head' title="Get head of cell"><code>++head</code></a>

305+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#help' title="Documentation"><code>+$help</code></a>

300306<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#hefab' title="Parse non-dozzod phonetic pair"><code>++hef:ab</code></a>

301307<a class="tooltip" href='/docs/hoon/reference/stdlib/4f/#here' title="Placebased apply"><code>++here</code></a>

302308<a class="tooltip" href='/docs/hoon/reference/stdlib/4h/#hep' title="Parse (hep)"><code>++hep</code></a>

@@ -307,8 +313,11 @@ Can be navigated [alphabetically](#alphabetical) or [by section](#by-section).

307313<a class="tooltip" href='/docs/hoon/reference/stdlib/4i/#hit' title="Parse single hexadecimal digit"><code>++hit</code></a>

308314<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#hofab' title="Parse 2-4 @q phonetic pair"><code>++hof:ab</code></a>

309315<a class="tooltip" href='/docs/hoon/reference/stdlib/2b/#homo' title="Homogenize list"><code>++homo</code></a>

316+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#hoon' title="Hoon AST"><code>+$hoon</code></a>

317+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#hoot' title="Hoon tools"><code>++hoot</code></a>

310318<a class="tooltip" href='/docs/hoon/reference/stdlib/3c/#horyo' title="Seconds in hour"><code>++hor:yo</code></a>

311319<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#hufab' title="Parse 1-4 @q phonetic pairs"><code>++huf:ab</code></a>

320+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#hump' title="Profiling"><code>+$hump</code></a>

312321<a class="tooltip" href='/docs/hoon/reference/stdlib/2a/#hunt' title="Select between two units by a rule"><code>++hunt</code></a>

313322<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#hyfab' title="Parse four @q phonetic pairs"><code>++hyf:ab</code></a>

314323

@@ -361,9 +370,9 @@ Can be navigated [alphabetically](#alphabetical) or [by section](#by-section).

361370<a class="tooltip" href='/docs/hoon/reference/stdlib/2b/#lien' title="Logical OR on list"><code>++lien</code></a>

362371<a class="tooltip" href='/docs/hoon/reference/stdlib/2a/#lift' title="Curried bind"><code>++lift</code></a>

363372<a class="tooltip" href='/docs/hoon/reference/stdlib/3g/#like' title="Generic edge"><code>++like</code></a>

364−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#limb' title="Reference into subject by name/axis"><code>++limb</code></a>

373+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#limb' title="Reference into subject by name/axis"><code>+$limb</code></a>

365374<a class="tooltip" href='/docs/hoon/reference/stdlib/2b/#limo' title="Construct list from nullterminated tuple"><code>++limo</code></a>

366−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#line' title="(Undocumented)"><code>++line</code></a>

375+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#link' title="Lexical segment"><code>+$link</code></a>

367376<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#lipag' title="Parse IPv4 address"><code>++lip:ag</code></a>

368377<a class="tooltip" href='/docs/hoon/reference/stdlib/1c/#list' title="Mold constructor (list)"><code>++list</code></a>

369378<a class="tooltip" href='/docs/hoon/reference/stdlib/1c/#lone' title="Mold generator (face on mold)"><code>++lone</code></a>

@@ -391,14 +400,21 @@ Can be navigated [alphabetically](#alphabetical) or [by section](#by-section).

391400

392401### m

393402

403+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#manxhoot' title="Dynamic XML node"><code>+$manx:hoot</code></a>

394404<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#mard' title="Initialize ff (rd core)"><code>++ma:rd</code></a>

395405<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#marh' title="Initialize ff (rh core)"><code>++ma:rh</code></a>

396406<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#mars' title="Initialize ff (rs core)"><code>++ma:rs</code></a>

397407<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#marq' title="Initialize ff (rq core)"><code>++ma:rq</code></a>

398408<a class="tooltip" href='/docs/hoon/reference/stdlib/4n/#mack' title="Nock subject to unit"><code>++mack</code></a>

399409<a class="tooltip" href='/docs/hoon/reference/stdlib/2l/#malt' title="Map from list"><code>++malt</code></a>

410+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#manehoot' title="XML name+space"><code>+$mane:hoot</code></a>

400411<a class="tooltip" href='/docs/hoon/reference/stdlib/2o/#map' title="Mold generator (map)"><code>++map</code></a>

401412<a class="tooltip" href='/docs/hoon/reference/stdlib/2i/#marby' title="Add with validation (map)"><code>++mar:by</code></a>

413+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#marehoot' title="Node or nodes"><code>+$mare:hoot</code></a>

414+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#marlhoot' title="Dynamic XML nodes"><code>+$marl:hoot</code></a>

415+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#marthoot' title="Dynamic XML attributes"><code>+$mart:hoot</code></a>

416+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#maruhoot' title="Interpolation or nodes"><code>+$maru:hoot</code></a>

417+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#marxhoot' title="Dynamic XML tag"><code>+$marx:hoot</code></a>

402418<a class="tooltip" href='/docs/hoon/reference/stdlib/1b/#mas' title="Address within head/tail"><code>++mas</code></a>

403419<a class="tooltip" href='/docs/hoon/reference/stdlib/4f/#mask' title="Match character"><code>++mask</code></a>

404420<a class="tooltip" href='/docs/hoon/reference/stdlib/2p/#mat' title="Lengthencode"><code>++mat</code></a>

@@ -409,15 +425,16 @@ Can be navigated [alphabetically](#alphabetical) or [by section](#by-section).

409425<a class="tooltip" href='/docs/hoon/reference/stdlib/4i/#mes' title="Parse hexabyte"><code>++mes</code></a>

410426<a class="tooltip" href='/docs/hoon/reference/stdlib/4b/#mesc' title="Escape special characters"><code>++mesc</code></a>

411427<a class="tooltip" href='/docs/hoon/reference/stdlib/2c/#met' title="Measure"><code>++met</code></a>

412−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#metl' title="(Undocumented)"><code>++metl</code></a>

413428<a class="tooltip" href='/docs/hoon/reference/stdlib/1a/#min' title="Minimum (atom)"><code>++min</code></a>

414429<a class="tooltip" href='/docs/hoon/reference/stdlib/4n/#mink' title="Mock (virtual Nock) interpreter"><code>++mink</code></a>

415430<a class="tooltip" href='/docs/hoon/reference/stdlib/3c/#mityo' title="Seconds in minute"><code>++mit:yo</code></a>

416431<a class="tooltip" href='/docs/hoon/reference/stdlib/2d/#mix' title="Binary XOR (atom)"><code>++mix</code></a>

417432<a class="tooltip" href='/docs/hoon/reference/stdlib/4i/#mixed-case-symbol' title="Mixed-case term"><code>++mixed-case-symbol</code></a>

433+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#moan' title="Profiling: sample metric"><code>+$moan</code></a>

418434<a class="tooltip" href='/docs/hoon/reference/stdlib/4n/#mock' title="Compute formula on subject with hint"><code>++mock</code></a>

419435<a class="tooltip" href='/docs/hoon/reference/stdlib/1a/#mod' title="Modulus (atom)"><code>++mod</code></a>

420436<a class="tooltip" href='/docs/hoon/reference/stdlib/3c/#mohyo' title="Days in month"><code>++moh:yo</code></a>

437+<a class="tooltip" href='/docs/hoon/reference/stdlib/4n/#mole' title="Typed unitary virtual"><code>++mole</code></a>

421438<a class="tooltip" href='/docs/hoon/reference/stdlib/2l/#molt' title="Map from pair list"><code>++molt</code></a>

422439<a class="tooltip" href='/docs/hoon/reference/stdlib/4n/#mong' title="Slam gate with sample"><code>++mong</code></a>

423440<a class="tooltip" href='/docs/hoon/reference/stdlib/4n/#mook' title="Intelligently render crash annotation"><code>++mook</code></a>

@@ -437,6 +454,7 @@ Can be navigated [alphabetically](#alphabetical) or [by section](#by-section).

437454<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#mulrs' title="Multiply (singleprecision float)"><code>++mul:rs</code></a>

438455<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#mulrq' title="Multiply (quadprecision float)"><code>++mul:rq</code></a>

439456<a class="tooltip" href='/docs/hoon/reference/stdlib/4n/#mule' title="Typed virtual"><code>++mule</code></a>

457+<a class="tooltip" href='/docs/hoon/reference/stdlib/4n/#mure' title="Untyped unitary virtual"><code>++mure</code></a>

440458<a class="tooltip" href='/docs/hoon/reference/stdlib/4n/#mute' title="Untyped virtual"><code>++mute</code></a>

441459<a class="tooltip" href='/docs/hoon/reference/stdlib/2b/#murn' title="Maybe transform"><code>++murn</code></a>

442460<a class="tooltip" href='/docs/hoon/reference/stdlib/2m/#my' title="Map from raw noun"><code>++my</code></a>

@@ -455,12 +473,13 @@ Can be navigated [alphabetically](#alphabetical) or [by section](#by-section).

455473<a class="tooltip" href='/docs/hoon/reference/stdlib/2k/#nipto' title="Remove root of queue"><code>++nip:to</code></a>

456474<a class="tooltip" href='/docs/hoon/reference/stdlib/4i/#nix' title="Parse letters and underscore"><code>++nix</code></a>

457475<a class="tooltip" href='/docs/hoon/reference/stdlib/2m/#nl' title="Noun to container operations"><code>++nl</code></a>

458−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#nock' title="Virtual machine (see Nock)"><code>++nock</code></a>

476+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#nock' title="Virtual nock"><code>+$nock</code></a>

459477<a class="tooltip" href='/docs/hoon/reference/stdlib/2d/#not' title="Binary NOT (atom)"><code>++not</code></a>

478+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#note' title="Type annotation"><code>+$note</code></a>

460479<a class="tooltip" href='/docs/hoon/reference/stdlib/2q/#noun' title="Any noun"><code>+$noun</code></a>

461480<a class="tooltip" href='/docs/hoon/reference/stdlib/4l/#nuckso' title="Toplevel coin parser"><code>++nuck:so</code></a>

462481<a class="tooltip" href='/docs/hoon/reference/stdlib/4i/#nud' title="Parse numeric character"><code>++nud</code></a>

463−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#null' title="(Undocumented)"><code>++null</code></a>

482+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#null' title="Null, nil, etc"><code>+$null</code></a>

464483<a class="tooltip" href='/docs/hoon/reference/stdlib/4l/#nuskso' title="Parse coin literal with escapes"><code>++nusk:so</code></a>

465484

466485### o

@@ -468,6 +487,8 @@ Can be navigated [alphabetically](#alphabetical) or [by section](#by-section).

468487<a class="tooltip" href='/docs/hoon/reference/stdlib/3f/#ob' title="Reversible scrambling v2"><code>++ob</code></a>

469488<a class="tooltip" href='/docs/hoon/reference/stdlib/3d/#og' title="Container arm for SHA256 powered RNG"><code>++og</code></a>

470489<a class="tooltip" href='/docs/hoon/reference/stdlib/3a/#oldsi' title="Sign and absolute value"><code>++old:si</code></a>

490+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#onyx' title="Arm activation"><code>+$onyx</code></a>

491+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#opal' title="Wing match"><code>+$opal</code></a>

471492<a class="tooltip" href='/docs/hoon/reference/stdlib/2b/#oust' title="Remove from list"><code>++oust</code></a>

472493<a class="tooltip" href='/docs/hoon/reference/stdlib/2c/#outfe' title="Maximum integer value"><code>++out:fe</code></a>

473494<a class="tooltip" href='/docs/hoon/reference/stdlib/4k/#ox-coco' title="Format dot-separated digits in numeric base"><code>++ox-co:co</code></a>

@@ -482,20 +503,25 @@ Can be navigated [alphabetically](#alphabetical) or [by section](#by-section).

482503<a class="tooltip" href='/docs/hoon/reference/stdlib/2q/#path' title="Like unix path"><code>+$path</code></a>

483504<a class="tooltip" href='/docs/hoon/reference/stdlib/1b/#peg' title="Address within address"><code>++peg</code></a>

484505<a class="tooltip" href='/docs/hoon/reference/stdlib/4h/#pal' title="Parse ( (pal)"><code>++pal</code></a>

506+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#palo' title="Wing trace, match"><code>+$palo</code></a>

485507<a class="tooltip" href='/docs/hoon/reference/stdlib/4h/#par' title="Parse ) (par)"><code>++par</code></a>

486508<a class="tooltip" href='/docs/hoon/reference/stdlib/4l/#perdso' title="Parsing coin literal without prefixes"><code>++perd:so</code></a>

487509<a class="tooltip" href='/docs/hoon/reference/stdlib/4f/#perk' title="Parse cube fork"><code>++perk</code></a>

488510<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#pevab' title="Parse 1-5 @uv base-32 chars"><code>++pev:ab</code></a>

489511<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#pewab' title="Parse <= 5 in base 64"><code>++pew:ab</code></a>

490512<a class="tooltip" href='/docs/hoon/reference/stdlib/4e/#pfix' title="Discard first rule"><code>++pfix</code></a>

513+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#pica' title="Prose or code"><code>+$pica</code></a>

491514<a class="tooltip" href='/docs/hoon/reference/stdlib/3g/#pint' title="Parsing range"><code>+$pint</code></a>

492515<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#pivab' title="Parse 5 @uv base-32 chars"><code>++piv:ab</code></a>

493516<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#piwab' title="Parse 5 @uw base-64 chars"><code>++piw:ab</code></a>

517+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#plat' title="%hoon, %type, %nock or %tank"><code>+$plat</code></a>

494518<a class="tooltip" href='/docs/hoon/reference/stdlib/4e/#plug' title="Parse to tuple"><code>++plug</code></a>

495519<a class="tooltip" href='/docs/hoon/reference/stdlib/4f/#plus' title="List of at least one match"><code>++plus</code></a>

496520<a class="tooltip" href='/docs/hoon/reference/stdlib/4a/#po' title="Phonetic base"><code>++po</code></a>

521+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#pock' title="Changes"><code>+$pock</code></a>

497522<a class="tooltip" href='/docs/hoon/reference/stdlib/1c/#pole' title="Mold generator of faceless list"><code>++pole</code></a>

498−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#port' title="(Undocumented)"><code>++port</code></a>

523+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#poly' title="Polarity"><code>+$poly</code></a>

524+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#port' title="Successful wing match"><code>+$port</code></a>

499525<a class="tooltip" href='/docs/hoon/reference/stdlib/4e/#pose' title="Parse options"><code>++pose</code></a>

500526<a class="tooltip" href='/docs/hoon/reference/stdlib/2g/#pow' title="Computes a to the power of b"><code>++pow</code></a>

501527<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#prcfl' title="Force precision of 2 or greater (floating point)"><code>++prc:fl</code></a>

@@ -545,6 +571,7 @@ Can be navigated [alphabetically](#alphabetical) or [by section](#by-section).

545571<a class="tooltip" href='/docs/hoon/reference/stdlib/2c/#rep' title="Assemble single"><code>++rep</code></a>

546572<a class="tooltip" href='/docs/hoon/reference/stdlib/2i/#repby' title="Reduce to product (map)"><code>++rep:by</code></a>

547573<a class="tooltip" href='/docs/hoon/reference/stdlib/2h/#repin' title="Accumulate elements (set)"><code>++rep:in</code></a>

574+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#result' title="Internal interpreter result"><code>+$result</code></a>

548575<a class="tooltip" href='/docs/hoon/reference/stdlib/2c/#rev' title="Reverse"><code>++rev</code></a>

549576<a class="tooltip" href='/docs/hoon/reference/stdlib/4b/#rfat' title="Print loobean"><code>++rf:at</code></a>

550577<a class="tooltip" href='/docs/hoon/reference/stdlib/2i/#ribby' title="Transform + product (map)"><code>++rib:by</code></a>

@@ -607,6 +634,7 @@ Can be navigated [alphabetically](#alphabetical) or [by section](#by-section).

607634<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#searq' title="Convert from quadprecision float to fn"><code>++sea:rq</code></a>

608635<a class="tooltip" href='/docs/hoon/reference/stdlib/4f/#sear' title="Conditional ++cook"><code>++sear</code></a>

609636<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#sebab' title="Parse 1"><code>++seb:ab</code></a>

637+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#sect' title="Paragraph"><code>+$sect</code></a>

610638<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#sedab' title="Parse nonzero decimal digit"><code>++sed:ab</code></a>

611639<a class="tooltip" href='/docs/hoon/reference/stdlib/4h/#sel' title="Parse [ (sel)"><code>++sel</code></a>

612640<a class="tooltip" href='/docs/hoon/reference/stdlib/4h/#mic' title="Parse ; (mic)"><code>++mic</code></a>

@@ -649,6 +677,7 @@ Can be navigated [alphabetically](#alphabetical) or [by section](#by-section).

649677<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#sixab' title="Parse a hexadecimal digit"><code>++six:ab</code></a>

650678<a class="tooltip" href='/docs/hoon/reference/stdlib/2b/#skid' title="Separate list into two lists from slammed elments"><code>++skid</code></a>

651679<a class="tooltip" href='/docs/hoon/reference/stdlib/2b/#skim' title="Produce list of elements from boolean gate"><code>++skim</code></a>

680+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#skin' title="Texture"><code>+$skin</code></a>

652681<a class="tooltip" href='/docs/hoon/reference/stdlib/2b/#skip' title="Produce list of elements failing boolean gate"><code>++skip</code></a>

653682<a class="tooltip" href='/docs/hoon/reference/stdlib/2b/#slag' title="Produce all elements from index in list"><code>++slag</code></a>

654683<a class="tooltip" href='/docs/hoon/reference/stdlib/4m/#slat' title="Curried slaw"><code>++slat</code></a>

@@ -657,12 +686,14 @@ Can be navigated [alphabetically](#alphabetical) or [by section](#by-section).

657686<a class="tooltip" href='/docs/hoon/reference/stdlib/4m/#slay' title="Parse cord to coin"><code>++slay</code></a>

658687<a class="tooltip" href='/docs/hoon/reference/stdlib/5c/#slog' title="Deify printf"><code>++slog</code></a>

659688<a class="tooltip" href='/docs/hoon/reference/stdlib/4f/#slug' title="Use gate to parse delimited list"><code>++slug</code></a>

689+<a class="tooltip" href='/docs/hoon/reference/stdlib/4n/#slum' title="Slam a gate on a sample using raw nock, untyped"><code>++slum</code></a>

660690<a class="tooltip" href='/docs/hoon/reference/stdlib/4m/#smyt' title="Render path as tank"><code>++smyt</code></a>

661691<a class="tooltip" href='/docs/hoon/reference/stdlib/2b/#snag' title="Produce element at specific index (list)"><code>++snag</code></a>

662692<a class="tooltip" href='/docs/hoon/reference/stdlib/2m/#snagnl' title="Produce element from list at specific nullterminated noun"><code>++snag:nl</code></a>

663693<a class="tooltip" href='/docs/hoon/reference/stdlib/2b/#snip' title="Drop tail off list"><code>++snip</code></a>

664694<a class="tooltip" href='/docs/hoon/reference/stdlib/2b/#snoc' title="Append noun to list"><code>++snoc</code></a>

665695<a class="tooltip" href='/docs/hoon/reference/stdlib/4l/#so' title="Coin parser engine"><code>++so</code></a>

696+<a class="tooltip" href='/docs/hoon/reference/stdlib/4n/#soft' title="Virtual clam"><code>++soft</code></a>

666697<a class="tooltip" href='/docs/hoon/reference/stdlib/2a/#some' title="Wrap value in unit"><code>++some</code></a>

667698<a class="tooltip" href='/docs/hoon/reference/stdlib/4h/#soq' title="Parse ' (soq)"><code>++soq</code></a>

668699<a class="tooltip" href='/docs/hoon/reference/stdlib/2b/#sort' title="Quicksort (list)"><code>++sort</code></a>

@@ -670,9 +701,9 @@ Can be navigated [alphabetically](#alphabetical) or [by section](#by-section).

670701<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#sowab' title="Parse @uw base-64 letter/symbol"><code>++sow:ab</code></a>

671702<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#soxab' title="Parse hexadecimal letter"><code>++sox:ab</code></a>

672703<a class="tooltip" href='/docs/hoon/reference/stdlib/4i/#soz' title="Parse triple singlequote"><code>++soz</code></a>

673−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#span' title="ASCII atom"><code>++span</code></a>

674704<a class="tooltip" href='/docs/hoon/reference/stdlib/4m/#spat' title="Render path as cord"><code>++spat</code></a>

675705<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#spdfl' title="Produce smallest denormalized float"><code>++spd:fl</code></a>

706+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#spec' title="Structure definition AST"><code>+$spec</code></a>

676707<a class="tooltip" href='/docs/hoon/reference/stdlib/2b/#spin' title="Gate to list (with state)"><code>++spin</code></a>

677708<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#spnfl' title="Produce smallest normal float"><code>++spn:fl</code></a>

678709<a class="tooltip" href='/docs/hoon/reference/stdlib/3g/#spot' title="Stack trace line"><code>+$spot</code></a>

@@ -687,6 +718,7 @@ Can be navigated [alphabetically](#alphabetical) or [by section](#by-section).

687718<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#sqtrq' title="Produce square root of quadprecision float"><code>++sqt:rq</code></a>

688719<a class="tooltip" href='/docs/hoon/reference/stdlib/4m/#stab' title="Parse cord to path"><code>++stab</code></a>

689720<a class="tooltip" href='/docs/hoon/reference/stdlib/4f/#stag' title="Add label"><code>++stag</code></a>

721+<a class="tooltip" href='/docs/hoon/reference/stdlib/4m/#stap' title="Path parser"><code>++stap</code></a>

690722<a class="tooltip" href='/docs/hoon/reference/stdlib/4f/#star' title="Produce list of matches"><code>++star</code></a>

691723<a class="tooltip" href='/docs/hoon/reference/stdlib/1c/#step' title="Atom size or offset, in bloqs"><code>++step</code></a>

692724<a class="tooltip" href='/docs/hoon/reference/stdlib/4f/#stet' title="Add faces to rangeparser pairs in list"><code>++stet</code></a>

@@ -737,18 +769,20 @@ Can be navigated [alphabetically](#alphabetical) or [by section](#by-section).

737769<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#tedab' title="Parse 1-999 decimal"><code>++ted:ab</code></a>

738770<a class="tooltip" href='/docs/hoon/reference/stdlib/4b/#teff' title="UTF8 length"><code>++teff</code></a>

739771<a class="tooltip" href='/docs/hoon/reference/stdlib/3f/#tailob' title="Reverse +feis"><code>++tail:ob</code></a>

772+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#tent' title="Model builder"><code>+$tent</code></a>

740773<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#tepab' title="Parse non-doz leading phonetic byte"><code>++tep:ab</code></a>

741774<a class="tooltip" href='/docs/hoon/reference/stdlib/2q/#term' title="Hoon constant"><code>+$term</code></a>

742775<a class="tooltip" href='/docs/hoon/reference/stdlib/2n/#test' title="Test for equality"><code>++test</code></a>

776+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#thunk' title="Fragment constructor"><code>+$thunk</code></a>

743777<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#tidab' title="Parse 3 decimal digits"><code>++tid:ab</code></a>

744−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#tiki' title="(Undocumented)"><code>++tiki</code></a>

778+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#tiki' title="Test case"><code>+$tiki</code></a>

745779<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#tilab' title="Parse 3 lowercase letters"><code>++til:ab</code></a>

780+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#tine' title="Partial noun"><code>+$tine</code></a>

746781<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#tipab' title="Leading phonetic byte"><code>++tip:ab</code></a>

747782<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#tiqab' title="Trailing phonetic syllable"><code>++tiq:ab</code></a>

748783<a class="tooltip" href='/docs/hoon/reference/stdlib/4h/#tis' title="Parse = (tis)"><code>++tis</code></a>

749784<a class="tooltip" href='/docs/hoon/reference/stdlib/2k/#to' title="Queue operations"><code>++to</code></a>

750785<a class="tooltip" href='/docs/hoon/reference/stdlib/4a/#todpo' title="Fetch suffix"><code>++tod:po</code></a>

751−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#toga' title="Tree of faces"><code>++toga</code></a>

752786<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#toiff' title="Round IEEE float to nearest signed integer"><code>++toi:ff</code></a>

753787<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#toifl' title="Round float to nearest signed integer"><code>++toi:fl</code></a>

754788<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#toird' title="Round doubleprecision float to nearest signed integer"><code>++toi:rd</code></a>

@@ -757,12 +791,17 @@ Can be navigated [alphabetically](#alphabetical) or [by section](#by-section).

757791<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#toirq' title="Round quadprecision float to nearest signed integer"><code>++toi:rq</code></a>

758792<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#tojfl' title="Round unsigned and signed integer to float"><code>++toj:fl</code></a>

759793<a class="tooltip" href='/docs/hoon/reference/stdlib/4a/#tokfa' title="Compute base58check checksum"><code>++tok:fa</code></a>

794+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#tome' title="Core chapter"><code>+$tome</code></a>

760795<a class="tooltip" href='/docs/hoon/reference/stdlib/3g/#tone' title="Nock result (error report)"><code>+$tone</code></a>

796+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#tony' title="$tone done right"><code>+$tony</code></a>

797+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#tool' title="Type decoration"><code>+$tool</code></a>

761798<a class="tooltip" href='/docs/hoon/reference/stdlib/3g/#toon' title="Nock result (stack trace)"><code>+$toon</code></a>

799+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#tope' title="Topographic type"><code>+$tope</code></a>

762800<a class="tooltip" href='/docs/hoon/reference/stdlib/2k/#topto' title="Produce head of queue"><code>++top:to</code></a>

763801<a class="tooltip" href='/docs/hoon/reference/stdlib/4a/#tospo' title="Fetch prefix"><code>++tos:po</code></a>

764802<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#tosrh' title="Convert halfprecision float to singleprecision float"><code>++tos:rh</code></a>

765803<a class="tooltip" href='/docs/hoon/reference/stdlib/2q/#tour' title="UTF-32 clusters"><code>+$tour</code></a>

804+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#type' title="Hoon type type"><code>+$type</code></a>

766805<a class="tooltip" href='/docs/hoon/reference/stdlib/1c/#trap' title="Core with one arm $"><code>++trap</code></a>

767806<a class="tooltip" href='/docs/hoon/reference/stdlib/1c/#tree' title="Mold generator (tree)"><code>++tree</code></a>

768807<a class="tooltip" href='/docs/hoon/reference/stdlib/1c/#trel' title="Mold generator (tuple of three types)"><code>++trel</code></a>

@@ -770,14 +809,14 @@ Can be navigated [alphabetically](#alphabetical) or [by section](#by-section).

770809<a class="tooltip" href='/docs/hoon/reference/stdlib/4b/#trip' title="Cord to tape"><code>++trip</code></a>

771810<a class="tooltip" href='/docs/hoon/reference/stdlib/4b/#tuba' title="UTF8 to UTF32 tape"><code>++tuba</code></a>

772811<a class="tooltip" href='/docs/hoon/reference/stdlib/4b/#tufa' title="UTF32 to UTF8 tape"><code>++tufa</code></a>

773−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#tuna' title="XML template tree"><code>++tuna</code></a>

774812<a class="tooltip" href='/docs/hoon/reference/stdlib/4b/#tuft' title="UTF32 to UTF8 text"><code>++tuft</code></a>

813+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#tunahoot' title="Maybe interpolation"><code>+$tuna:hoot</code></a>

814+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#tune' title="Complex"><code>+$tune</code></a>

775815<a class="tooltip" href='/docs/hoon/reference/stdlib/2b/#turn' title="Gate to list"><code>++turn</code></a>

776−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#tusk' title="List of expressions"><code>++tusk</code></a>

777816<a class="tooltip" href='/docs/hoon/reference/stdlib/4l/#twidso' title="Parse coins without ~ prefix"><code>++twid:so</code></a>

778−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#tyke' title="List of 'maybe' hoons"><code>++tyke</code></a>

779−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#typo' title="Pointer for ++type"><code>++typo</code></a>

780−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#tyre' title="List, term hoon"><code>++tyre</code></a>

817+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#tyke' title="List of 'maybe' hoons"><code>+$tyke</code></a>

818+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#typo' title="Old type"><code>+$typo</code></a>

819+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#tyre' title="List, term hoon"><code>+$tyre</code></a>

781820

782821### u

783822

@@ -795,11 +834,14 @@ Can be navigated [alphabetically](#alphabetical) or [by section](#by-section).

795834

796835<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#vne' title="Render base 32"><code>++v:ne</code></a>

797836<code>++vang</code>

798−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#vase' title="Typed data"><code>++vase</code></a>

837+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#vair' title="Core variance"><code>+$vair</code></a>

838+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#vase' title="Type-value pair"><code>+$vase</code></a>

799839<code>++vast</code>

800840<a class="tooltip" href='/docs/hoon/reference/stdlib/4k/#v-coco' title="Render base-32 with minimum length"><code>++v-co:co</code></a>

841+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#vein' title="Search trace"><code>+$vein</code></a>

801842<a class="tooltip" href='/docs/hoon/reference/stdlib/4i/#ven' title="Axis syntax parser"><code>++ven</code></a>

802−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#vise' title="Convert during reboot"><code>++vise</code></a>

843+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#vial' title="co/contra/in/bi"><code>+$vial</code></a>

844+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#vise' title="Old vase"><code>+$vise</code></a>

803845<a class="tooltip" href='/docs/hoon/reference/stdlib/4i/#vit' title="Parse base 64 digit"><code>++vit</code></a>

804846<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#vizag' title="Parse base 32 digit with dot separators"><code>++viz:ag</code></a>

805847<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#voyab' title="Parse bas, soq, or bix"><code>++voy:ab</code></a>

@@ -817,13 +859,16 @@ Can be navigated [alphabetically](#alphabetical) or [by section](#by-section).

817859<a class="tooltip" href='/docs/hoon/reference/stdlib/2b/#weld' title="Concatenate two lists"><code>++weld</code></a>

818860<a class="tooltip" href='/docs/hoon/reference/stdlib/2m/#weldnl' title="Concatenate nullterminated nouns"><code>++weld:nl</code></a>

819861<a class="tooltip" href='/docs/hoon/reference/stdlib/2b/#welp' title="Perfect concatenate (lists)"><code>++welp</code></a>

862+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#what' title="Help slogan/section"><code>+$what</code></a>

820863<a class="tooltip" href='/docs/hoon/reference/stdlib/4l/#whenso' title="Parse date"><code>++when:so</code></a>

864+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#whit' title="Documentation"><code>+$whit</code></a>

821865<a class="tooltip" href='/docs/hoon/reference/stdlib/4b/#wick' title="Knot unescape"><code>++wick</code></a>

822866<a class="tooltip" href='/docs/hoon/reference/stdlib/4c/#winre' title="Render at indent"><code>++win:re</code></a>

823−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#wing' title="Address in subject"><code>++wing</code></a>

867+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#wing' title="Search path"><code>+$wing</code></a>

824868<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#wizag' title="Parse base 64 number"><code>++wiz:ag</code></a>

825869<a class="tooltip" href='/docs/hoon/reference/stdlib/4b/#woad' title="Unescape cord"><code>++woad</code></a>

826870<a class="tooltip" href='/docs/hoon/reference/stdlib/4b/#wood' title="Escape cord"><code>++wood</code></a>

871+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#woof' title="Simple embed"><code>+$woof</code></a>

827872<a class="tooltip" href='/docs/hoon/reference/stdlib/3g/#wonk' title="Product from edge"><code>++wonk</code></a>

828873<a class="tooltip" href='/docs/hoon/reference/stdlib/3f/#wredun' title="Restore structure"><code>++wred:un</code></a>

829874<a class="tooltip" href='/docs/hoon/reference/stdlib/3f/#wrenun' title="Conceal structure"><code>++wren:un</code></a>

@@ -1766,45 +1811,89 @@ Can be navigated [alphabetically](#alphabetical) or [by section](#by-section).

17661811<a class="tooltip" href='/docs/hoon/reference/stdlib/4m/#spat' title="Render path as cord"><code>++spat</code></a>

17671812<a class="tooltip" href='/docs/hoon/reference/stdlib/4m/#spud' title="Render path as tape"><code>++spud</code></a>

17681813<a class="tooltip" href='/docs/hoon/reference/stdlib/4m/#stab' title="Parse cord to path"><code>++stab</code></a>

1814+<a class="tooltip" href='/docs/hoon/reference/stdlib/4m/#stap' title="Path parser"><code>++stap</code></a>

17691815

17701816### 4n: parsing (virtualization)

17711817

17721818<a class="tooltip" href='/docs/hoon/reference/stdlib/4n/#mack' title="Nock subject to unit"><code>++mack</code></a>

17731819<a class="tooltip" href='/docs/hoon/reference/stdlib/4n/#mink' title="Mock (virtual Nock) interpreter"><code>++mink</code></a>

17741820<a class="tooltip" href='/docs/hoon/reference/stdlib/4n/#mock' title="Compute formula on subject with hint"><code>++mock</code></a>

1775−<a class="tooltip" href='/docs/hoon/reference/stdlib/4n/#mong' title="Slam gate with sample"><code>++mong</code></a>

17761821<a class="tooltip" href='/docs/hoon/reference/stdlib/4n/#mook' title="Intelligently render crash annotation"><code>++mook</code></a>

1822+<a class="tooltip" href='/docs/hoon/reference/stdlib/4n/#mole' title="Typed unitary virtual"><code>++mole</code></a>

1823+<a class="tooltip" href='/docs/hoon/reference/stdlib/4n/#mong' title="Slam gate with sample"><code>++mong</code></a>

17771824<a class="tooltip" href='/docs/hoon/reference/stdlib/4n/#mule' title="Typed virtual"><code>++mule</code></a>

1825+<a class="tooltip" href='/docs/hoon/reference/stdlib/4n/#mure' title="Untyped unitary virtual"><code>++mure</code></a>

17781826<a class="tooltip" href='/docs/hoon/reference/stdlib/4n/#mute' title="Untyped virtual"><code>++mute</code></a>

1827+<a class="tooltip" href='/docs/hoon/reference/stdlib/4n/#slum' title="Slam a gate on a sample using raw nock, untyped"><code>++slum</code></a>

1828+<a class="tooltip" href='/docs/hoon/reference/stdlib/4n/#soft' title="Virtual clam"><code>++soft</code></a>

17791829

17801830### 4o: parsing (molds)

17811831

1782−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#abel' title="Compiler alias"><code>++abel</code></a>

1783−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#aura' title="'Type' of atom"><code>++aura</code></a>

1784−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#base' title="Base type"><code>++base</code></a>

1785−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#beer' title="Tape builder"><code>++beer</code></a>

1786−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#beet' title="XML interpolation cases"><code>++beet</code></a>

1787−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#chum' title="Jet hint information"><code>++chum</code></a>

1788−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#coil' title="Tuple of core information"><code>++coil</code></a>

1789−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#foot' title="Cases of arms by variance model"><code>++foot</code></a>

1790−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#limb' title="Reference into subject by name/axis"><code>++limb</code></a>

1791−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#line' title="(Undocumented)"><code>++line</code></a>

1792−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#metl' title="(Undocumented)"><code>++metl</code></a>

1793−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#nock' title="Virtual machine (see Nock)"><code>++nock</code></a>

1794−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#null' title="(Undocumented)"><code>++null</code></a>

1795−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#port' title="(Undocumented)"><code>++port</code></a>

1796−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#span' title="ASCII atom"><code>++span</code></a>

1797−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#tiki' title="(Undocumented)"><code>++tiki</code></a>

1798−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#toga' title="Tree of faces"><code>++toga</code></a>

1799−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#tone'><code>+$tone</code></a>

1800−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#tuna' title="XML template tree"><code>++tuna</code></a>

1801−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#tusk' title="List of expressions"><code>++tusk</code></a>

1802−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#tyke' title="List of 'maybe' hoons"><code>++tyke</code></a>

1803−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#typo' title="Pointer for ++type"><code>++typo</code></a>

1804−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#tyre' title="List, term hoon"><code>++tyre</code></a>

1805−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#vase' title="Typed data"><code>++vase</code></a>

1806−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#vise' title="Convert during reboot"><code>++vise</code></a>

1807−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#wing' title="Address in subject"><code>++wing</code></a>

1832+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#abel' title="Original sin: type"><code>+$abel</code></a>

1833+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#alas' title="Alias list"><code>+$alas</code></a>

1834+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#atom' title="Just an atom"><code>+$atom</code></a>

1835+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#aura' title="'Type' of atom"><code>+$aura</code></a>

1836+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#base' title="Base type"><code>+$base</code></a>

1837+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#woof' title="Simple embed"><code>+$woof</code></a>

1838+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#chum' title="Jet hint information"><code>+$chum</code></a>

1839+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#coil' title="Tuple of core information"><code>+$coil</code></a>

1840+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#garb' title="Core metadata"><code>+$garb</code></a>

1841+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#poly' title="Polarity"><code>+$poly</code></a>

1842+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#foot' title="Cases of arms by variance model"><code>+$foot</code></a>

1843+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#link' title="Lexical segment"><code>+$link</code></a>

1844+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#crib' title="Summary and details"><code>+$crib</code></a>

1845+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#help' title="Documentation"><code>+$help</code></a>

1846+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#limb' title="Reference into subject by name/axis"><code>+$limb</code></a>

1847+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#null' title="Null, nil, etc"><code>+$null</code></a>

1848+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#onyx' title="Arm activation"><code>+$onyx</code></a>

1849+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#opal' title="Wing match"><code>+$opal</code></a>

1850+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#pica' title="Prose or code"><code>+$pica</code></a>

1851+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#palo' title="Wing trace, match"><code>+$palo</code></a>

1852+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#plat' title="%hoon, %type, %nock or %tank"><code>+$plat</code></a>

1853+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#pock' title="Changes"><code>+$pock</code></a>

1854+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#port' title="Successful wing match"><code>+$port</code></a>

1855+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#spec' title="Structure definition AST"><code>+$spec</code></a>

1856+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#tent' title="Model builder"><code>+$tent</code></a>

1857+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#tiki' title="Test case"><code>+$tiki</code></a>

1858+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#skin' title="Texture"><code>+$skin</code></a>

1859+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#tome' title="Core chapter"><code>+$tome</code></a>

1860+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#tope' title="Topographic type"><code>+$tope</code></a>

1861+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#hoot' title="Hoon tools"><code>++hoot</code></a>

1862+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#beerhoot' title="Simple embed"><code>+$beer:hoot</code></a>

1863+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#manehoot' title="XML name+space"><code>+$mane:hoot</code></a>

1864+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#manxhoot' title="Dynamic XML node"><code>+$manx:hoot</code></a>

1865+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#marlhoot' title="Dynamic XML nodes"><code>+$marl:hoot</code></a>

1866+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#marthoot' title="Dynamic XML attributes"><code>+$mart:hoot</code></a>

1867+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#marxhoot' title="Dynamic XML tag"><code>+$marx:hoot</code></a>

1868+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#marehoot' title="Node or nodes"><code>+$mare:hoot</code></a>

1869+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#maruhoot' title="Interpolation or nodes"><code>+$maru:hoot</code></a>

1870+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#tunahoot' title="Maybe interpolation"><code>+$tuna:hoot</code></a>

1871+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#hoon' title="Hoon AST"><code>+$hoon</code></a>

1872+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#tyre' title="List, term hoon"><code>+$tyre</code></a>

1873+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#tyke' title="List of 'maybe' hoons"><code>+$tyke</code></a>

1874+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#nock' title="Virtual nock"><code>+$nock</code></a>

1875+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#note' title="Type annotation"><code>+$note</code></a>

1876+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#type' title="Hoon type type"><code>+$type</code></a>

1877+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#tony' title="$tone done right"><code>+$tony</code></a>

1878+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#tine' title="Partial noun"><code>+$tine</code></a>

1879+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#tool' title="Type decoration"><code>+$tool</code></a>

1880+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#tune' title="Complex"><code>+$tune</code></a>

1881+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#typo' title="Old type"><code>+$typo</code></a>

1882+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#vase' title="Type-value pair"><code>+$vase</code></a>

1883+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#vise' title="Old vase"><code>+$vise</code></a>

1884+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#vial' title="co/contra/in/bi"><code>+$vial</code></a>

1885+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#vair' title="Core variance"><code>+$vair</code></a>

1886+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#vein' title="Search trace"><code>+$vein</code></a>

1887+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#sect' title="Paragraph"><code>+$sect</code></a>

1888+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#whit' title="Documentation"><code>+$whit</code></a>

1889+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#what' title="Help slogan/section"><code>+$what</code></a>

1890+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#wing' title="Search path"><code>+$wing</code></a>

1891+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#block' title="Abstract identity of resource awaited"><code>+$block</code></a>

1892+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#result' title="Internal interpreter result"><code>+$result</code></a>

1893+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#thunk' title="Fragment constructor"><code>+$thunk</code></a>

1894+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#doss' title="Profiling"><code>+$doss</code></a>

1895+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#moan' title="Profiling: sample metric"><code>+$moan</code></a>

1896+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#hump' title="Profiling"><code>+$hump</code></a>

18081897

18091898### 5a: compiler utilities

18101899

lib/glossary.js+370−55

@@ -1403,7 +1403,7 @@ export const glossary = [

14031403 desc: "Used in the Hoon standard library.",

14041404 },

14051405 {

1406− name: "Compiler alias",

1406+ name: "Original sin: type",

14071407 symbol: "abel",

14081408 usage: "stdlib",

14091409 slug: "https://urbit.org/docs/reference/library/4o/#abel",

@@ -1493,6 +1493,13 @@ export const glossary = [

14931493 slug: "https://urbit.org/docs/reference/library/4j/#ag",

14941494 desc: "Used in the Hoon standard library.",

14951495 },

1496+ {

1497+ name: "Alias list",

1498+ symbol: "alas",

1499+ usage: "stdlib",

1500+ slug: "https://urbit.org/docs/reference/library/4o/#alas",

1501+ desc: "Used in the Hoon standard library.",

1502+ },

14961503 {

14971504 name: "Parse alphabetic characters",

14981505 symbol: "alf",

@@ -1584,6 +1591,13 @@ export const glossary = [

15841591 slug: "https://urbit.org/docs/reference/library/4b/#at",

15851592 desc: "Used in the Hoon standard library.",

15861593 },

1594+ {

1595+ name: "Just an atom",

1596+ symbol: "atom",

1597+ usage: "stdlib",

1598+ slug: "https://urbit.org/docs/reference/library/4o/#atom",

1599+ desc: "Used in the Hoon standard library.",

1600+ },

15871601 {

15881602 name: "'Type' of atom",

15891603 symbol: "aura",

@@ -1655,17 +1669,10 @@ export const glossary = [

16551669 desc: "Used in the Hoon standard library.",

16561670 },

16571671 {

1658− name: "Tape builder",

1659− symbol: "beer",

1672+ name: "Simple embed",

1673+ symbol: "beer:hoot",

16601674 usage: "stdlib",

1661− slug: "https://urbit.org/docs/reference/library/4o/#beer",

1662− desc: "Used in the Hoon standard library.",

1663− },

1664− {

1665− name: "XML interpolation cases",

1666− symbol: "beet",

1667− usage: "stdlib",

1668− slug: "https://urbit.org/docs/reference/library/4o/#beet",

1675+ slug: "https://urbit.org/docs/reference/library/4o/#beerhoot",

16691676 desc: "Used in the Hoon standard library.",

16701677 },

16711678 {

@@ -1787,6 +1794,13 @@ export const glossary = [

17871794 slug: "https://urbit.org/docs/reference/library/4l/#biskso",

17881795 desc: "Used in the Hoon standard library.",

17891796 },

1797+ {

1798+ name: "Abstract identity of resource awaited",

1799+ symbol: "block",

1800+ usage: "stdlib",

1801+ slug: "https://urbit.org/docs/reference/library/4o/#block",

1802+ desc: "Used in the Hoon standard library.",

1803+ },

17901804 {

17911805 name: "Blocksize",

17921806 symbol: "bloq",

@@ -2046,6 +2060,13 @@ export const glossary = [

20462060 slug: "https://urbit.org/docs/reference/library/4b/#crip",

20472061 desc: "Used in the Hoon standard library.",

20482062 },

2063+ {

2064+ name: "Summary and details",

2065+ symbol: "crib",

2066+ usage: "stdlib",

2067+ slug: "https://urbit.org/docs/reference/library/4o/#crib",

2068+ desc: "Used in the Hoon standard library.",

2069+ },

20492070 {

20502071 name: "Parse @da, @dr, @p, @t",

20512072 symbol: "crub:so",

@@ -2347,6 +2368,13 @@ export const glossary = [

23472368 slug: "https://urbit.org/docs/reference/library/2f/#dor",

23482369 desc: "Used in the Hoon standard library.",

23492370 },

2371+ {

2372+ name: "Profiling",

2373+ symbol: "doss",

2374+ usage: "stdlib",

2375+ slug: "https://urbit.org/docs/reference/library/4o/#doss",

2376+ desc: "Used in the Hoon standard library.",

2377+ },

23502378 {

23512379 name: "Parse period",

23522380 symbol: "dot",

@@ -2921,6 +2949,13 @@ export const glossary = [

29212949 slug: "https://urbit.org/docs/reference/library/4h/#gar",

29222950 desc: "Used in the Hoon standard library.",

29232951 },

2952+ {

2953+ name: "Core metadata",

2954+ symbol: "garb",

2955+ usage: "stdlib",

2956+ slug: "https://urbit.org/docs/reference/library/4o/#garb",

2957+ desc: "Used in the Hoon standard library.",

2958+ },

29242959 {

29252960 name: "Concatenate (map)",

29262961 symbol: "gas:by",

@@ -3236,6 +3271,13 @@ export const glossary = [

32363271 slug: "https://urbit.org/docs/reference/library/4j/#hefab",

32373272 desc: "Used in the Hoon standard library.",

32383273 },

3274+ {

3275+ name: "Documentation",

3276+ symbol: "help",

3277+ usage: "stdlib",

3278+ slug: "https://urbit.org/docs/reference/library/4o/#help",

3279+ desc: "Used in the Hoon standard library.",

3280+ },

32393281 {

32403282 name: "Place-based apply",

32413283 symbol: "here",

@@ -3299,6 +3341,13 @@ export const glossary = [

32993341 slug: "https://urbit.org/docs/reference/library/2b/#homo",

33003342 desc: "Used in the Hoon standard library.",

33013343 },

3344+ {

3345+ name: "Hoon AST",

3346+ symbol: "hoon",

3347+ usage: "stdlib",

3348+ slug: "https://urbit.org/docs/reference/library/4o/#hoon",

3349+ desc: "Used in the Hoon standard library.",

3350+ },

33023351 {

33033352 name: "Seconds in hour",

33043353 symbol: "hor:yo",

@@ -3306,6 +3355,13 @@ export const glossary = [

33063355 slug: "https://urbit.org/docs/reference/library/3c/#horyo",

33073356 desc: "Used in the Hoon standard library.",

33083357 },

3358+ {

3359+ name: "Hoon tools",

3360+ symbol: "hoot",

3361+ usage: "stdlib",

3362+ slug: "https://urbit.org/docs/reference/library/4o/#hoot",

3363+ desc: "Used in the Hoon standard library.",

3364+ },

33093365 {

33103366 name: "Parse 1-4 @q phonetic pairs",

33113367 symbol: "huf:ab",

@@ -3313,6 +3369,13 @@ export const glossary = [

33133369 slug: "https://urbit.org/docs/reference/library/4j/#hufab",

33143370 desc: "Used in the Hoon standard library.",

33153371 },

3372+ {

3373+ name: "Profiling",

3374+ symbol: "hump",

3375+ usage: "stdlib",

3376+ slug: "https://urbit.org/docs/reference/library/4o/#hump",

3377+ desc: "Used in the Hoon standard library.",

3378+ },

33163379 {

33173380 name: "Select between two units by a rule",

33183381 symbol: "hunt",

@@ -3615,10 +3678,10 @@ export const glossary = [

36153678 desc: "Used in the Hoon standard library.",

36163679 },

36173680 {

3618− name: "(Undocumented)",

3619− symbol: "line",

3681+ name: "Lexical segment",

3682+ symbol: "link",

36203683 usage: "stdlib",

3621− slug: "https://urbit.org/docs/reference/library/4o/#line",

3684+ slug: "https://urbit.org/docs/reference/library/4o/#link",

36223685 desc: "Used in the Hoon standard library.",

36233686 },

36243687 {

@@ -3831,6 +3894,20 @@ export const glossary = [

38313894 slug: "https://urbit.org/docs/reference/library/2l/#malt",

38323895 desc: "Used in the Hoon standard library.",

38333896 },

3897+ {

3898+ name: "XML name+space",

3899+ symbol: "mane:hoot",

3900+ usage: "stdlib",

3901+ slug: "https://urbit.org/docs/reference/library/4o/#manehoot",

3902+ desc: "Used in the Hoon standard library.",

3903+ },

3904+ {

3905+ name: "Dynamic XML node",

3906+ symbol: "manx:hoot",

3907+ usage: "stdlib",

3908+ slug: "https://urbit.org/docs/reference/library/4o/#manxhoot",

3909+ desc: "Used in the Hoon standard library.",

3910+ },

38343911 {

38353912 name: "Mold generator (map)",

38363913 symbol: "map",

@@ -3845,6 +3922,41 @@ export const glossary = [

38453922 slug: "https://urbit.org/docs/reference/library/2i/#marby",

38463923 desc: "Used in the Hoon standard library.",

38473924 },

3925+ {

3926+ name: "Node or nodes",

3927+ symbol: "mare:hoot",

3928+ usage: "stdlib",

3929+ slug: "https://urbit.org/docs/reference/library/4o/#marehoot",

3930+ desc: "Used in the Hoon standard library.",

3931+ },

3932+ {

3933+ name: "Dynamic XML nodes",

3934+ symbol: "marl:hoot",

3935+ usage: "stdlib",

3936+ slug: "https://urbit.org/docs/reference/library/4o/#marlhoot",

3937+ desc: "Used in the Hoon standard library.",

3938+ },

3939+ {

3940+ name: "Dynamic XML attributes",

3941+ symbol: "mart:hoot",

3942+ usage: "stdlib",

3943+ slug: "https://urbit.org/docs/reference/library/4o/#marthoot",

3944+ desc: "Used in the Hoon standard library.",

3945+ },

3946+ {

3947+ name: "Interpolation or nodes",

3948+ symbol: "maru:hoot",

3949+ usage: "stdlib",

3950+ slug: "https://urbit.org/docs/reference/library/4o/#maruhoot",

3951+ desc: "Used in the Hoon standard library.",

3952+ },

3953+ {

3954+ name: "Dynamic XML tag",

3955+ symbol: "marx:hoot",

3956+ usage: "stdlib",

3957+ slug: "https://urbit.org/docs/reference/library/4o/#marxhoot",

3958+ desc: "Used in the Hoon standard library.",

3959+ },

38483960 {

38493961 name: "Address within head/tail",

38503962 symbol: "mas",

@@ -3915,13 +4027,6 @@ export const glossary = [

39154027 slug: "https://urbit.org/docs/reference/library/2c/#met",

39164028 desc: "Used in the Hoon standard library.",

39174029 },

3918− {

3919− name: "(Undocumented)",

3920− symbol: "metl",

3921− usage: "stdlib",

3922− slug: "https://urbit.org/docs/reference/library/4o/#metl",

3923− desc: "Used in the Hoon standard library.",

3924− },

39254030 {

39264031 name: "Minimum (atom)",

39274032 symbol: "min",

@@ -3957,6 +4062,13 @@ export const glossary = [

39574062 slug: "https://urbit.org/docs/reference/library/4i/#mixed-case-symbol",

39584063 desc: "Used in the Hoon standard library.",

39594064 },

4065+ {

4066+ name: "Profiling: sample metric",

4067+ symbol: "moan",

4068+ usage: "stdlib",

4069+ slug: "https://urbit.org/docs/reference/library/4o/#moan",

4070+ desc: "Used in the Hoon standard library.",

4071+ },

39604072 {

39614073 name: "Compute formula on subject with hint",

39624074 symbol: "mock",

@@ -3978,6 +4090,13 @@ export const glossary = [

39784090 slug: "https://urbit.org/docs/reference/library/3c/#mohyo",

39794091 desc: "Used in the Hoon standard library.",

39804092 },

4093+ {

4094+ name: "Typed unitary virtual",

4095+ symbol: "mole",

4096+ usage: "stdlib",

4097+ slug: "https://urbit.org/docs/reference/library/4n/#mole",

4098+ desc: "Used in the Hoon standard library.",

4099+ },

39814100 {

39824101 name: "Map from pair list",

39834102 symbol: "molt",

@@ -4111,6 +4230,13 @@ export const glossary = [

41114230 slug: "https://urbit.org/docs/reference/library/4n/#mule",

41124231 desc: "Used in the Hoon standard library.",

41134232 },

4233+ {

4234+ name: "Untyped unitary virtual",

4235+ symbol: "mure",

4236+ usage: "stdlib",

4237+ slug: "https://urbit.org/docs/reference/library/4n/#mure",

4238+ desc: "Used in the Hoon standard library.",

4239+ },

41144240 {

41154241 name: "Untyped virtual",

41164242 symbol: "mute",

@@ -4217,7 +4343,7 @@ export const glossary = [

42174343 desc: "Used in the Hoon standard library.",

42184344 },

42194345 {

4220− name: "Virtual machine (see Nock)",

4346+ name: "Virtual Nock",

42214347 symbol: "nock",

42224348 usage: "stdlib",

42234349 slug: "https://urbit.org/docs/reference/library/4o/#nock",

@@ -4230,6 +4356,13 @@ export const glossary = [

42304356 slug: "https://urbit.org/docs/reference/library/2d/#not",

42314357 desc: "Used in the Hoon standard library.",

42324358 },

4359+ {

4360+ name: "Type annotation",

4361+ symbol: "note",

4362+ usage: "stdlib",

4363+ slug: "https://urbit.org/docs/reference/library/4o/#note",

4364+ desc: "Used in the Hoon standard library.",

4365+ },

42334366 {

42344367 name: "Any noun",

42354368 symbol: "noun",

@@ -4252,7 +4385,7 @@ export const glossary = [

42524385 desc: "Used in the Hoon standard library.",

42534386 },

42544387 {

4255− name: "(Undocumented)",

4388+ name: "Null, nil, etc",

42564389 symbol: "null",

42574390 usage: "stdlib",

42584391 slug: "https://urbit.org/docs/reference/library/4o/#null",

@@ -4286,6 +4419,20 @@ export const glossary = [

42864419 slug: "https://urbit.org/docs/reference/library/3a/#oldsi",

42874420 desc: "Used in the Hoon standard library.",

42884421 },

4422+ {

4423+ name: "Arm activation",

4424+ symbol: "onyx",

4425+ usage: "stdlib",

4426+ slug: "https://urbit.org/docs/reference/library/4o/#onyx",

4427+ desc: "Used in the Hoon standard library.",

4428+ },

4429+ {

4430+ name: "Wing match",

4431+ symbol: "opal",

4432+ usage: "stdlib",

4433+ slug: "https://urbit.org/docs/reference/library/4o/#opal",

4434+ desc: "Used in the Hoon standard library.",

4435+ },

42894436 {

42904437 name: "Remove from list",

42914438 symbol: "oust",

@@ -4321,6 +4468,13 @@ export const glossary = [

43214468 slug: "https://urbit.org/docs/reference/library/1c/#pair",

43224469 desc: "Used in the Hoon standard library.",

43234470 },

4471+ {

4472+ name: "Wing trace, match",

4473+ symbol: "palo",

4474+ usage: "stdlib",

4475+ slug: "https://urbit.org/docs/reference/library/4o/#palo",

4476+ desc: "Used in the Hoon standard library.",

4477+ },

43244478 {

43254479 name: "Parse & (pam)",

43264480 symbol: "pam",

@@ -4398,6 +4552,13 @@ export const glossary = [

43984552 slug: "https://urbit.org/docs/reference/library/4e/#pfix",

43994553 desc: "Used in the Hoon standard library.",

44004554 },

4555+ {

4556+ name: "Prose or code",

4557+ symbol: "pica",

4558+ usage: "stdlib",

4559+ slug: "https://urbit.org/docs/reference/library/4o/#pica",

4560+ desc: "Used in the Hoon standard library.",

4561+ },

44014562 {

44024563 name: "Parsing range",

44034564 symbol: "pint",

@@ -4419,6 +4580,13 @@ export const glossary = [

44194580 slug: "https://urbit.org/docs/reference/library/4j/#piwab",

44204581 desc: "Used in the Hoon standard library.",

44214582 },

4583+ {

4584+ name: "%hoon, %type, %nock or %tank",

4585+ symbol: "plat",

4586+ usage: "stdlib",

4587+ slug: "https://urbit.org/docs/reference/library/4o/#plat",

4588+ desc: "Used in the Hoon standard library.",

4589+ },

44224590 {

44234591 name: "Parse to tuple",

44244592 symbol: "plug",

@@ -4440,6 +4608,13 @@ export const glossary = [

44404608 slug: "https://urbit.org/docs/reference/library/4a/#po",

44414609 desc: "Used in the Hoon standard library.",

44424610 },

4611+ {

4612+ name: "Changes",

4613+ symbol: "pock",

4614+ usage: "stdlib",

4615+ slug: "https://urbit.org/docs/reference/library/4o/#pock",

4616+ desc: "Used in the Hoon standard library.",

4617+ },

44434618 {

44444619 name: "Mold generator of faceless list",

44454620 symbol: "pole",

@@ -4448,7 +4623,14 @@ export const glossary = [

44484623 desc: "Used in the Hoon standard library.",

44494624 },

44504625 {

4451− name: "(Undocumented)",

4626+ name: "Polarity (wet/dry)",

4627+ symbol: "poly",

4628+ usage: "stdlib",

4629+ slug: "https://urbit.org/docs/reference/library/4o/#poly",

4630+ desc: "Used in the Hoon standard library.",

4631+ },

4632+ {

4633+ name: "Successful wing match",

44524634 symbol: "port",

44534635 usage: "stdlib",

44544636 slug: "https://urbit.org/docs/reference/library/4o/#port",

@@ -4755,6 +4937,13 @@ export const glossary = [

47554937 slug: "https://urbit.org/docs/reference/library/2h/#repin",

47564938 desc: "Used in the Hoon standard library.",

47574939 },

4940+ {

4941+ name: "Internal interpreter result",

4942+ symbol: "result",

4943+ usage: "stdlib",

4944+ slug: "https://urbit.org/docs/reference/library/4o/#result",

4945+ desc: "Used in the Hoon standard library.",

4946+ },

47584947 {

47594948 name: "Print loobean",

47604949 symbol: "rf:at",

@@ -5154,6 +5343,13 @@ export const glossary = [

51545343 slug: "https://urbit.org/docs/reference/library/4j/#sebab",

51555344 desc: "Used in the Hoon standard library.",

51565345 },

5346+ {

5347+ name: "Paragraph",

5348+ symbol: "sect",

5349+ usage: "stdlib",

5350+ slug: "https://urbit.org/docs/reference/library/4o/#sect",

5351+ desc: "Used in the Hoon standard library.",

5352+ },

51575353 {

51585354 name: "Parse non-zero decimal digit",

51595355 symbol: "sed:ab",

@@ -5448,6 +5644,13 @@ export const glossary = [

54485644 slug: "https://urbit.org/docs/reference/library/2b/#skim",

54495645 desc: "Used in the Hoon standard library.",

54505646 },

5647+ {

5648+ name: "Texture",

5649+ symbol: "skin",

5650+ usage: "stdlib",

5651+ slug: "https://urbit.org/docs/reference/library/4o/#skin",

5652+ desc: "Used in the Hoon standard library.",

5653+ },

54515654 {

54525655 name: "Produce list of elements failing boolean gate",

54535656 symbol: "skip",

@@ -5504,6 +5707,13 @@ export const glossary = [

55045707 slug: "https://urbit.org/docs/reference/library/4f/#slug",

55055708 desc: "Used in the Hoon standard library.",

55065709 },

5710+ {

5711+ name: "Slam a gate on a sample using raw nock, untyped",

5712+ symbol: "slum",

5713+ usage: "stdlib",

5714+ slug: "https://urbit.org/docs/reference/library/4n/#slum",

5715+ desc: "Used in the Hoon standard library.",

5716+ },

55075717 {

55085718 name: "Render path as tank",

55095719 symbol: "smyt",

@@ -5546,6 +5756,13 @@ export const glossary = [

55465756 slug: "https://urbit.org/docs/reference/library/4l/#so",

55475757 desc: "Used in the Hoon standard library.",

55485758 },

5759+ {

5760+ name: "Virtual clam",

5761+ symbol: "soft",

5762+ usage: "stdlib",

5763+ slug: "https://urbit.org/docs/reference/library/4n/#soft",

5764+ desc: "Used in the Hoon standard library.",

5765+ },

55495766 {

55505767 name: "Wrap value in unit",

55515768 symbol: "some",

@@ -5595,13 +5812,6 @@ export const glossary = [

55955812 slug: "https://urbit.org/docs/reference/library/4i/#soz",

55965813 desc: "Used in the Hoon standard library.",

55975814 },

5598− {

5599− name: "ASCII atom",

5600− symbol: "span",

5601− usage: "stdlib",

5602− slug: "https://urbit.org/docs/reference/library/4o/#span",

5603− desc: "Used in the Hoon standard library.",

5604− },

56055815 {

56065816 name: "Render path as cord",

56075817 symbol: "spat",

@@ -5616,6 +5826,13 @@ export const glossary = [

56165826 slug: "https://urbit.org/docs/reference/library/3b/#spdfl",

56175827 desc: "Used in the Hoon standard library.",

56185828 },

5829+ {

5830+ name: "Structure definition AST",

5831+ symbol: "spec",

5832+ usage: "stdlib",

5833+ slug: "https://urbit.org/docs/reference/library/4o/#spec",

5834+ desc: "Used in the Hoon standard library.",

5835+ },

56195836 {

56205837 name: "Gate to list (with state)",

56215838 symbol: "spin",

@@ -5714,6 +5931,13 @@ export const glossary = [

57145931 slug: "https://urbit.org/docs/reference/library/4f/#stag",

57155932 desc: "Used in the Hoon standard library.",

57165933 },

5934+ {

5935+ name: "Path parser",

5936+ symbol: "stap",

5937+ usage: "stdlib",

5938+ slug: "https://urbit.org/docs/reference/library/4m/#stap",

5939+ desc: "Used in the Hoon standard library.",

5940+ },

57175941 {

57185942 name: "Produce list of matches",

57195943 symbol: "star",

@@ -6015,6 +6239,13 @@ export const glossary = [

60156239 slug: "https://urbit.org/docs/reference/library/4l/#tashso",

60166240 desc: "Used in the Hoon standard library.",

60176241 },

6242+ {

6243+ name: "Fragment constructor",

6244+ symbol: "thunk",

6245+ usage: "stdlib",

6246+ slug: "https://urbit.org/docs/reference/library/4o/#thunk",

6247+ desc: "Used in the Hoon standard library.",

6248+ },

60186249 {

60196250 name: "Parse ` (tic)",

60206251 symbol: "tic",

@@ -6022,6 +6253,13 @@ export const glossary = [

60226253 slug: "https://urbit.org/docs/reference/library/4h/#tic",

60236254 desc: "Used in the Hoon standard library.",

60246255 },

6256+ {

6257+ name: "Partial noun",

6258+ symbol: "tine",

6259+ usage: "stdlib",

6260+ slug: "https://urbit.org/docs/reference/library/4o/#tine",

6261+ desc: "Used in the Hoon standard library.",

6262+ },

60256263 {

60266264 name: "Parse 1-999 decimal",

60276265 symbol: "ted:ab",

@@ -6036,6 +6274,13 @@ export const glossary = [

60366274 slug: "https://urbit.org/docs/reference/library/4b/#teff",

60376275 desc: "Used in the Hoon standard library.",

60386276 },

6277+ {

6278+ name: "Model builder",

6279+ symbol: "tent",

6280+ usage: "stdlib",

6281+ slug: "https://urbit.org/docs/reference/library/4o/#tent",

6282+ desc: "Used in the Hoon standard library.",

6283+ },

60396284 {

60406285 name: "Parse non-doz leading phonetic byte",

60416286 symbol: "tep:ab",

@@ -6072,7 +6317,7 @@ export const glossary = [

60726317 desc: "Used in the Hoon standard library.",

60736318 },

60746319 {

6075− name: "(Undocumented)",

6320+ name: "Test case",

60766321 symbol: "tiki",

60776322 usage: "stdlib",

60786323 slug: "https://urbit.org/docs/reference/library/4o/#tiki",

@@ -6120,13 +6365,6 @@ export const glossary = [

61206365 slug: "https://urbit.org/docs/reference/library/4a/#todpo",

61216366 desc: "Used in the Hoon standard library.",

61226367 },

6123− {

6124− name: "Tree of faces",

6125− symbol: "toga",

6126− usage: "stdlib",

6127− slug: "https://urbit.org/docs/reference/library/4o/#toga",

6128− desc: "Used in the Hoon standard library.",

6129− },

61306368 {

61316369 name: "Round IEEE float to nearest signed integer",

61326370 symbol: "toi:ff",

@@ -6183,6 +6421,13 @@ export const glossary = [

61836421 slug: "https://urbit.org/docs/reference/library/4a/#tokfa",

61846422 desc: "Used in the Hoon standard library.",

61856423 },

6424+ {

6425+ name: "Core chapter",

6426+ symbol: "tome",

6427+ usage: "stdlib",

6428+ slug: "https://urbit.org/docs/reference/library/4o/#tome",

6429+ desc: "Used in the Hoon standard library.",

6430+ },

61866431 {

61876432 name: "Nock result (error report)",

61886433 symbol: "tone",

@@ -6190,6 +6435,20 @@ export const glossary = [

61906435 slug: "https://urbit.org/docs/reference/library/3g/#tone",

61916436 desc: "Used in the Hoon standard library.",

61926437 },

6438+ {

6439+ name: "$tone done right",

6440+ symbol: "tony",

6441+ usage: "stdlib",

6442+ slug: "https://urbit.org/docs/reference/library/4o/#tony",

6443+ desc: "Used in the Hoon standard library.",

6444+ },

6445+ {

6446+ name: "Type decoration",

6447+ symbol: "tool",

6448+ usage: "stdlib",

6449+ slug: "https://urbit.org/docs/reference/library/4o/#tool",

6450+ desc: "Used in the Hoon standard library.",

6451+ },

61936452 {

61946453 name: "Nock result (stack trace)",

61956454 symbol: "toon",

@@ -6204,6 +6463,13 @@ export const glossary = [

62046463 slug: "https://urbit.org/docs/reference/library/2k/#topto",

62056464 desc: "Used in the Hoon standard library.",

62066465 },

6466+ {

6467+ name: "Topographic type",

6468+ symbol: "tope",

6469+ usage: "stdlib",

6470+ slug: "https://urbit.org/docs/reference/library/4o/#tope",

6471+ desc: "Used in the Hoon standard library.",

6472+ },

62076473 {

62086474 name: "Fetch prefix",

62096475 symbol: "tos:po",

@@ -6275,31 +6541,31 @@ export const glossary = [

62756541 desc: "Used in the Hoon standard library.",

62766542 },

62776543 {

6278− name: "XML template tree",

6279− symbol: "tuna",

6544+ name: "UTF-32 to UTF-8 text",

6545+ symbol: "tuft",

62806546 usage: "stdlib",

6281− slug: "https://urbit.org/docs/reference/library/4o/#tuna",

6547+ slug: "https://urbit.org/docs/reference/library/4b/#tuft",

62826548 desc: "Used in the Hoon standard library.",

62836549 },

62846550 {

6285− name: "UTF-32 to UTF-8 text",

6286− symbol: "tuft",

6551+ name: "Maybe interpolation",

6552+ symbol: "tuna:hoot",

62876553 usage: "stdlib",

6288− slug: "https://urbit.org/docs/reference/library/4b/#tuft",

6554+ slug: "https://urbit.org/docs/reference/library/4o/#tunahoot",

62896555 desc: "Used in the Hoon standard library.",

62906556 },

62916557 {

6292− name: "Gate to list",

6293− symbol: "turn",

6558+ name: "Complex",

6559+ symbol: "tune",

62946560 usage: "stdlib",

6295− slug: "https://urbit.org/docs/reference/library/2b/#turn",

6561+ slug: "https://urbit.org/docs/reference/library/4o/#tune",

62966562 desc: "Used in the Hoon standard library.",

62976563 },

62986564 {

6299− name: "List of expressions",

6300− symbol: "tusk",

6565+ name: "Gate to list",

6566+ symbol: "turn",

63016567 usage: "stdlib",

6302− slug: "https://urbit.org/docs/reference/library/4o/#tusk",

6568+ slug: "https://urbit.org/docs/reference/library/2b/#turn",

63036569 desc: "Used in the Hoon standard library.",

63046570 },

63056571 {

@@ -6317,7 +6583,14 @@ export const glossary = [

63176583 desc: "Used in the Hoon standard library.",

63186584 },

63196585 {

6320− name: "Pointer for type",

6586+ name: "Hoon type type",

6587+ symbol: "type",

6588+ usage: "stdlib",

6589+ slug: "https://urbit.org/docs/reference/library/4o/#type",

6590+ desc: "Used in the Hoon standard library.",

6591+ },

6592+ {

6593+ name: "Old type",

63216594 symbol: "typo",

63226595 usage: "stdlib",

63236596 slug: "https://urbit.org/docs/reference/library/4o/#typo",

@@ -6401,7 +6674,14 @@ export const glossary = [

64016674 desc: "Used in the Hoon standard library.",

64026675 },

64036676 {

6404− name: "Typed data",

6677+ name: "in/contra/bi/co",

6678+ symbol: "vair",

6679+ usage: "stdlib",

6680+ slug: "https://urbit.org/docs/reference/library/4o/#vair",

6681+ desc: "Used in the Hoon standard library.",

6682+ },

6683+ {

6684+ name: "Type-value pair",

64056685 symbol: "vase",

64066686 usage: "stdlib",

64076687 slug: "https://urbit.org/docs/reference/library/4o/#vase",

@@ -6414,6 +6694,13 @@ export const glossary = [

64146694 slug: "https://urbit.org/docs/reference/library/4k/#v-coco",

64156695 desc: "Used in the Hoon standard library.",

64166696 },

6697+ {

6698+ name: "Search trace",

6699+ symbol: "vein",

6700+ usage: "stdlib",

6701+ slug: "https://urbit.org/docs/reference/library/4o/#vein",

6702+ desc: "Used in the Hoon standard library.",

6703+ },

64176704 {

64186705 name: "Axis syntax parser",

64196706 symbol: "ven",

@@ -6422,7 +6709,14 @@ export const glossary = [

64226709 desc: "Used in the Hoon standard library.",

64236710 },

64246711 {

6425− name: "Convert during reboot",

6712+ name: "co/contra/in/bi",

6713+ symbol: "vial",

6714+ usage: "stdlib",

6715+ slug: "https://urbit.org/docs/reference/library/4o/#vial",

6716+ desc: "Used in the Hoon standard library.",

6717+ },

6718+ {

6719+ name: "Old vase",

64266720 symbol: "vise",

64276721 usage: "stdlib",

64286722 slug: "https://urbit.org/docs/reference/library/4o/#vise",

@@ -6526,6 +6820,20 @@ export const glossary = [

65266820 slug: "https://urbit.org/docs/reference/library/2b/#welp",

65276821 desc: "Used in the Hoon standard library.",

65286822 },

6823+ {

6824+ name: "Help slogan/section",

6825+ symbol: "what",

6826+ usage: "stdlib",

6827+ slug: "https://urbit.org/docs/reference/library/4o/#what",

6828+ desc: "Used in the Hoon standard library.",

6829+ },

6830+ {

6831+ name: "Documentation",

6832+ symbol: "whit",

6833+ usage: "stdlib",

6834+ slug: "https://urbit.org/docs/reference/library/4o/#whit",

6835+ desc: "Used in the Hoon standard library.",

6836+ },

65296837 {

65306838 name: "Knot unescape",

65316839 symbol: "wick",

@@ -6541,7 +6849,7 @@ export const glossary = [

65416849 desc: "Used in the Hoon standard library.",

65426850 },

65436851 {

6544− name: "Address in subject",

6852+ name: "Address in subject - search path",

65456853 symbol: "wing",

65466854 usage: "stdlib",

65476855 slug: "https://urbit.org/docs/reference/library/4o/#wing",

@@ -6568,6 +6876,13 @@ export const glossary = [

65686876 slug: "https://urbit.org/docs/reference/library/4b/#wood",

65696877 desc: "Used in the Hoon standard library.",

65706878 },

6879+ {

6880+ name: "Simple embed",

6881+ symbol: "woof",

6882+ usage: "stdlib",

6883+ slug: "https://urbit.org/docs/reference/library/4o/#woof",

6884+ desc: "Used in the Hoon standard library.",

6885+ },

65716886 {

65726887 name: "Product from edge",

65736888 symbol: "wonk",