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

git.iko.soy/urbit.org

on master help sign in

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

646edeetinnus-napbus5 years ago

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

compare with master

unifiedsplit

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

13#### Accepts

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

15+`mol` is a `dime`.

17#### Produces

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

21#### Source

23```hoon

24+++ scot

25+ ~/ %scot

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

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

25```

27```

27#### Examples

29#### Examples

29```

31```

30− > (scot %p ~pillyt)

32+> (scot %p ~pillyt)

31− ~.~pillyt

33+~.~pillyt

34+

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

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

33− '~pillyt'

36+'~pillyt'

34− > (scot %ux 0x12)

37+

35− ~.0x12

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

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

37− '0x12'

39+'0x12'

38− > (scot %if .127.0.0.1)

40+

39− ~..127.0.0.1

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

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

41− '.127.0.0.1'

42+'.127.0.0.1'

42− > (scot %ta ~.asd_a)

43+

43− ~.~.asd_a

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

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

45− '~.asd_a'

45+'~.asd_a'

46```

48---

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

56#### Accepts

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

58+`mol` is a `dime`.

60#### Produces

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

64#### Source

66```hoon

67+++ scow

68+ ~/ %scow

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

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

68```

70```

70#### Examples

72#### Examples

72```

74```

73− > (scow %p ~pillyt)

75+> (scow %p ~pillyt)

74− "~pillyt"

76+"~pillyt"

77+

75− > (scow %ux 0x12)

78+> (scow %ux 0x12)

76− "0x12"

79+"0x12"

80+

77− > (scow %if .127.0.0.1)

81+> (scow %if .127.0.0.1)

78− ".127.0.0.1"

82+".127.0.0.1"

83+

79− > (scow %ta ~.asd_a)

84+> (scow %ta ~.asd_a)

80− "~.asd_a"

85+"~.asd_a"

81```

86```

83---

88---

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

87Curried slaw

92Curried slaw

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

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

90−aura specified by `mod`.

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

92#### Accepts

97#### Accepts

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

99+`mod` is a `knot`.

100

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

101+`txt` is a `cord`.

102

98#### Produces

103#### Produces

104

100−A `gate`.

105+A `(unit @)`.

101

106

102#### Source

107#### Source

103

108

104```hoon

109```hoon

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

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

106```

111```

107

112

108#### Examples

113#### Examples

109

114

110```

115```

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

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

112− [~ ~pillyt]

117+[~ ~pillyt]

118+

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

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

114− [~ 0x12]

120+[~ 0x12]

121+

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

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

116− [~ .127.0.0.1]

123+[~ .127.0.0.1]

124+

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

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

118− [~ ~.asd_a

126+[~ ~.asd_a]

119```

127```

120

128

121---

129---

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

129

137

130#### Accepts

138#### Accepts

131

139

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

140+`mod` is a `term`

133

141

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

142+`txt` is a `knot`.

135

143

136#### Produces

144#### Produces

137

145

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

146+an atom.

139

147

140#### Source

148#### Source

141

149

142```hoon

150```hoon

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

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

144```

152```

145

153

146#### Examples

154#### Examples

147

155

148```

156```

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

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

150− ~pillyt

158+~pillyt

159+

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

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

152− ! exit

161+! exit

162+

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

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

154− 0x12

164+0x12

165+

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

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

156− ! exit

167+! exit

168+

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

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

158− .127.0.0.1

170+.127.0.0.1

171+

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

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

160− ! exit

173+! exit

174+

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

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

162− ~.asd_a

176+~.asd_a

177+

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

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

164− ! exit

179+! exit

165```

180```

166

181

167---

182---

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

170

185

171Parse cord to input aura

186Parse cord to input aura

172

187

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.

174

190

175#### Accepts

191#### Accepts

176

192

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

193+`mod` is a `term`.

178

194

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

195+`txt` is a `knot`.

180

196

181#### Produces

197#### Produces

182

198

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

185#### Source

201#### Source

186

202

187```hoon

203```hoon

188− ++ slaw

204+++ slaw

189− ~/ %slaw

205+ ~/ %slaw

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

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

191− ^- (unit @)

207+ ^- (unit @)

208+ ?+ mod

209+ :: slow fallback case to the full slay

210+ ::

192 =+ con=(slay txt)

211 =+ 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+ ==

194```

235```

195

236

196#### Examples

237#### Examples

197

238

198```

239```

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

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

200− [~ ~pillyt]

241+[~ ~pillyt]

242+

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

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

202− ~

244+~

245+

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

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

204− [~ 0x12]

247+[~ 0x12]

248+

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

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

206− ~

250+~

251+

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

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

208− [~ .127.0.0.1]

253+[~ .127.0.0.1]

254+

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

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

210− ~

256+~

257+

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

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

212− [~ ~.asd_a]

259+[~ ~.asd_a]

260+

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

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

214− ~

262+~

215```

263```

216

264

217---

265---

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

220

268

221Parse cord to coin

269Parse cord to coin

222

270

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

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

224

272

225#### Accepts

273#### Accepts

226

274

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

233#### Source

281#### Source

234

282

235```hoon

283```hoon

236− ++ slay

284+++ slay

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

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

238− =+ ^= vex

286+ =+ ^= vex

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

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

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

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

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

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

242− ?~ q.vex

290+ ?~ q.vex

243− ~

291+ ~

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

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

245− ::

246```

293```

247

294

248#### Examples

295#### Examples

249

296

250```

297```

251− > (slay '~pillyt')

298+> (slay '~pillyt')

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

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

300+

253− > (slay '0x12')

301+> (slay '0x12')

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

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

303+

255− > (slay '.127.0.0.1')

304+> (slay '.127.0.0.1')

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

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

257− > `@ud`.127.0.0.1

306+

258− 2.130.706.433

307+> (slay '!')

259− > (slay '._20_0w25_sam__')

308+~

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

275```

309```

276

310

277---

311---

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

285

319

286#### Accepts

320#### Accepts

287

321

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

322+`bon` is a `path`.

289

323

290#### Produces

324#### Produces

291

325

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

294#### Source

328#### Source

295

329

296```hoon

330```hoon

297− ++ smyt :: pretty print path

331+++ smyt

298− |= bon/path ^- tank

332+ |= bon=path ^- tank

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

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

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

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

301− ::

302```

335```

303

336

304#### Examples

337#### Examples

305

338

306```

339```

307− > (smyt %)

340+> (smyt %)

308− [ %rose

341+[ %rose

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

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

310− q

343+ q

344+ ~[

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

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

312− [%leaf p="try"]

346+ [%leaf p="base"]

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

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

314− ]

348+ ]

315− ]

349+]

350+

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

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

317− [ %rose

352+[ %rose

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

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

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

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

320− ]

355+]

321```

356```

322

357

323---

358---

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

339#### Source

374#### Source

340

375

341```hoon

376```hoon

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

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

343```

378```

344

379

345#### Examples

380#### Examples

346

381

347```

382```

348− > (spat %)

383+> (spat %)

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

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

385+

350− > (spat %/bin)

386+> (spat %/lib)

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

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

388+

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

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

353− '/as/les/top'

390+'/as/les/top'

354```

391```

355

392

356---

393---

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

372#### Source

409#### Source

373

410

374```hoon

411```hoon

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

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

376```

413```

377

414

378#### Examples

415#### Examples

379

416

380```

417```

381− > (spud %)

418+> (spud %)

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

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

420+

383− > (spud %/bin)

421+> (spud %/lib)

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

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

423+

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

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

386− "/as/les/top"

425+"/as/les/top"

387```

426```

388

427

389---

428---

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

392

431

393Parse cord to path

432Parse cord to path

394

433

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

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

396Crashes if it fails to parse.

435Crashes if it fails to parse.

397

436

398#### Accepts

437#### Accepts

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

406#### Source

445#### Source

407

446

408```hoon

447```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))

412```

449```

413

450

414#### Examples

451#### Examples

415

452

416```

453```

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

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

418− /as/lek/tor

455+/as/lek/tor

456+```

457+

458+---

459+

460+## `++stap`

461+

462+Path parser

419

463

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

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

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

422

465

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

466+#### Source

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

425

467

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

468+```hoon

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

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+```

428

478

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

479+#### Examples

430− /a/~pillyt/pals/1

431

480

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

481+```

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

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

483+/foo/bar/baz

434```

484```

435

485

436---

486---

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

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

9Nock subject to unit

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`.

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

13producing a `~`.

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

17`sub` is a subject noun.

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

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

21#### Produces

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

23+The `unit` of a noun.

25#### Source

27```hoon

28− ++ mack

28+++ mack

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

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

30− ^- (unit)

30+ ^- (unit)

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

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

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

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

33− ::

34```

33```

36#### Examples

35#### Examples

38```

37```

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

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

40− [~ [1 2 3]]

39+[~ [1 2 3]]

40+

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

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

42− [~ 42]

42+[~ 42]

43+

43− > (mack [4 0 4])

44+> (mack [4 0 4])

44− ~

45+~

46+

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

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

46− [~ 6]

48+[~ 6]

49+

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

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

48− [~ %no]

51+[~ %no]

49```

52```

51---

54---

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

55Mock interpreter

58Mock interpreter

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

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

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

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

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

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

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

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

62#### Accepts

65#### Accepts

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

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

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

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

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

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

70#### Produces

73#### Produces

72−A `++tone`.

75+A `tone`.

74#### Source

77#### Source

76```hoon

79```hoon

77− ++ mink

80+++ mink !.

78− ~/ %mink

81+ ~/ %mink

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

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

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

84+ ==

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

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

81− |- ^- tone

86+ |^ ^- tone

82− ?@ fol

87+ ?+ formula [%2 trace]

83− [%2 tax]

88+ [^ *]

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

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

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

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

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

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

87− hed

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

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

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

89− ?- -.tal

94+ ::

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

95+ [%0 axis=@]

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

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

92− $2 tal

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

93 ==

111 ==

94− ?+ fol

95− [%2 tax]

96 ::

112 ::

97− {$0 b/@}

113+ [%3 argument=*]

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

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

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

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

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

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

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

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

103 ::

117 ::

104− {$1 b/*}

118+ [%4 argument=*]

105− [%0 b.fol]

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

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

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

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

106 ::

123 ::

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

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

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

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

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

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

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

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

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

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

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

112 ::

130 ::

113− {$3 b/*}

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

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

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

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

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

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

134+ ?+ product.result

135+ [%2 trace]

136+ %& $(formula yes.formula)

137+ %| $(formula no.formula)

138+ ==

117 ::

139 ::

118− {$4 b/*}

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

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

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

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

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

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

143+ %= $

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

144+ subject product.subject

145+ formula next.formula

146+ ==

123 ::

147 ::

124− {$5 b/*}

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

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

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

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

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

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

151+ %= $

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

152+ subject [product.head subject]

153+ formula next.formula

154+ ==

129 ::

155 ::

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

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

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

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+ ==

132 ::

165 ::

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

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

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

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

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

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

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

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

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

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

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

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

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

172+ =/ mutant=(unit *)

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

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

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

174+ ?~ mutant [%2 trace]

142− $(fol d.fol)

175+ [%0 u.mutant]

143 ::

176 ::

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

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

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

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

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

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

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

180+ :- %0

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

181+ .* subject

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

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

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

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]

151 ==

208 ==

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+ ==

152− ::

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+ --

153```

240```

154

241

155#### Examples

242#### Examples

156

243

157```

244```

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

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

159− [%0 p=21]

246+[%0 product=21]

247+

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

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

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

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

250+

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

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

163− [%0 p=21]

252+[%0 product=115]

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

253+

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

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

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

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

255+[%1 block=0]

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

256+

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

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

171− [%2 p=~]

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

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

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

258+[%2 trace=~]

174```

259```

175

260

176---

261---

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

179

264

180Compute formula on subject with hint

265Compute formula on subject with hint

181

266

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

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

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

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

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

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

185indicating a block.

270indicating a block.

186

271

187#### Accepts

272#### Accepts

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

190

275

191`fol` is the formula as a noun.

276`fol` is the formula as a noun.

192

277

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`.

194

320

195#### Produces

321#### Produces

196

322

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

323+A `toon`.

198

324

199#### Source

325#### Source

200

326

201```hoon

327```hoon

202− ++ mock

328+++ mook

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

329+ |= ton=tone

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

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)

205 ::

371 ::

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)

206```

455```

207

456

208#### Examples

457#### Examples

209

458

210```

459```

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

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

212− [%0 p=6]

461+[~ 'a']

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

462+

214− [%0 p=999]

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

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

464+~

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"

225```

465```

226

466

227---

467---

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

230

470

231Slam gate with sample

471Slam gate with sample

232

472

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

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

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

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

235

475

236#### Accepts

476#### Accepts

237

477

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

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

239

479

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

480+`sam` is a sample noun.

241

481

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

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

243

483

244#### Produces

484#### Produces

245

485

246−A `++toon`.

486+A `toon`.

247

487

248#### Source

488#### Source

249

489

250```hoon

490```hoon

251− ++ mong

491+++ mong

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

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

253− ^- toon

493+ ^- toon

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

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

255− [%2 ~]

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

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

257− ::

258```

496```

259

497

260#### Examples

498#### Examples

261

499

262```

500```

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

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

264− [%0 p=20]

502+[%0 p=20]

503+

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

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

266− [%2 p=~]

505+[%2 p=~]

506+

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

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

268− [%0 p=20]

508+[%0 p=20]

509+

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

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

270− [%2 p=~]

511+[%2 p=~]

512+

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

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

272− [%0 p=24]

514+[%0 p=24]

515+

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

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

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

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

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

518+

276− [%0 p=42]

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

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

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

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

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

520+[%0 p=100]

281```

521```

282

522

283---

523---

284

524

285−## `++mook`

525+## `++mule`

286

526

287−Intelligently render crash annotation

527+Typed virtual

288

528

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

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

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

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

291

531

292#### Accepts

532#### Accepts

293

533

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

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

295

535

296#### Produces

536#### Produces

297

537

298−A `++toon`.

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

299

539

300#### Source

540#### Source

301

541

302```hoon

542```hoon

303− ++ mook

543+++ mule

304− |= ton/tone

544+ ~/ %mule

305− ^- toon

545+ |* tap=(trap)

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

546+ =/ mud (mute tap)

307− :- %2

547+ ?- -.mud

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

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

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

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

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− == ==

550+ ==

337− ::

338```

551```

339

552

340#### Examples

553#### Examples

341

554

342```

555```

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

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

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

557+[%.y p=2]

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

558+

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

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

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

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

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="####"]]]

353```

561```

354

562

355---

563---

356

564

357−## `++mule`

565+## `++mure`

358

566

359−Typed virtual

567+Untyped unitary virtual

360

568

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

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

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

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

363

571

364#### Accepts

572#### Accepts

365

573

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

574+A `trap`.

367

575

368#### Produces

576#### Produces

369

577

370−XX

578+A `(unit *)`.

371

579

372#### Source

580#### Source

373

581

374```hoon

582```hoon

375− ++ mule :: typed virtual

583+++ mure

376− ~/ %mule

584+ |= tap=(trap)

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

585+ ^- (unit)

378− =+ mud=(mute taq)

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

379− ?- -.mud

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

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

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

382− ==

383− ::

384```

588```

385

589

386#### Examples

590#### Examples

387

591

388```

592```

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

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

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

594+~

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

595+

392− [%.n p=~]

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

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

597+[~ 2]

394− [ %.n

598+

395− p

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

396− ~[

600+[~ 7.303.014]

397− [ %rose

601+

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

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

399− q

603+[~ 'foo']

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− ]

406```

604```

407

605

408---

606---

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

411

609

412Untyped virtual

610Untyped virtual

413

611

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

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

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

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

416−information.

417

614

418#### Accepts

615#### Accepts

419

616

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

617+`tap` is a `trap`.

421

618

422#### Produces

619#### Produces

423

620

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

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

622+failure.

425

623

426#### Source

624#### Source

427

625

428```hoon

626```hoon

429− ++ mute :: untyped virtual

627+++ mute

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

628+ |= tap=(trap)

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

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

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

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

433− ?- -.ton

631+ ?- -.ton

434− $0 [%& p.ton]

632+ %0 [%& p.ton]

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

633+ ::

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

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

636+ ::

436− $2 [%| p.ton]

637+ %2 [%| p.ton]

437− ==

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]

438```

655```

439

656

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+

440#### Examples

666#### Examples

441

667

442```

668```

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

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

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

670+16

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

671+

446− [%.n p=~]

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]]

447```

721```

448

722

449---

723---

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

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

4template = "doc.html"

5+++

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`.

11#### Source

13#### Source

13```hoon

15```hoon

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

16++$ abel typo

15```

17```

17#### Examples

19#### Examples

19```

21```

20− > *abel

22+> *abel

21− %void

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

22```

62```

24---

64---

26−## `++aura`

66+## `+$aura`

28'type' of atom

68'type' of atom

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

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

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

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

32−commonly used in urbit.

34#### Source

73#### Source

36```hoon

75```hoon

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

76++$ aura @ta

38```

77```

40#### Examples

79#### Examples

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

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

44```

83```

45− > `aura`%ux

84+> `aura`'ux'

46− ~.ux

85+~.ux

47```

86```

49---

88---

51−## `++base`

90+## `+$base`

53Base type

92Base type

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

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

56−boolean or null labelled with an aura.

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

58#### Source

97#### Source

60```hoon

99```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

62```

108```

109

64#### Examples

110#### Examples

111

66```

112```

67− > *base

113+> *base

68− %null

114+%void

115

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

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

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

117+[%tsbr p=[%base 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 ~]]

77```

118```

119

79---

120---

121

81−## `++beer`

122+## `+$woof`

123

83−Tape builder

124+Simple embed

125

85−Used to build tapes internally.

126+An atom or some `hoon`.

127

87#### Source

128#### Source

129

89```hoon

130```hoon

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

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

91```

132```

133

93#### Examples

134#### Examples

135

95```

136```

96− > `beer`'as'

137+> *woof

97− 29.537

138+0

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

139+

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

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

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

142+

143+> `woof`'foo'

144+7.303.014

100```

145```

101

146

102---

147---

103

148

104−## `++beet`

149+## `+$chum`

105

150

106−XML interpolation cases

151+Jet hint information

107

152

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.

109

155

110#### Source

156#### Source

111

157

112```hoon

158```hoon

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

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

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

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

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

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

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

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

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

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

119− == ::

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 ~]]

120```

174```

121

175

122---

176---

123

177

124−## `++chum`

178+## `+$coil`

125

179

126−Jet hint information

180+Tuple of core information

127

181

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

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

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

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

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

131

184

132#### Source

185#### Source

133

186

134```hoon

187```hoon

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

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

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

189+ q=type :: context

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

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

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

139− == ::

191+ == ::

140```

192```

141

193

142−#### Examples

194+---

143

195

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

196+## `+$garb`

145

197

146−```

198+Core metadata

147− > `chum`'hi'

148− lef=%hi

149

199

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

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

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

201+

202+#### Source

203+

204+```hoon

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

152```

206```

153

207

154---

208---

155

209

156−## `++coil`

210+## `+$poly`

157

211

158−Tuple of core information

212+Polarity

159

213

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

214+Whether a core is wet or dry.

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

162

215

163#### Source

216#### Source

164

217

165```hoon

218```hoon

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

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

167− q=type ::

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

169− == ::

170```

220```

171

221

172---

222---

173

223

174−## `++foot`

224+## `+$foot`

175

225

176Cases of arms by variance model.

226Cases of arms by variance model.

177

227

228+#### Source

229+

230+```hoon

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

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.

179

262

180#### Source

263#### Source

181

264

182```hoon

265```hoon

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

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

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

267+```

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

268+

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

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

187− == ::

295+ == ::

188```

296```

189

297

190#### Examples

298#### Examples

191

299

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

300+```

301+> (ream '^^$')

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

303+```

304+

305+---

193

306

307+## `+$null`

308+

309+Null, nil, etc

310+

311+Just `~`.

312+

313+#### Source

314+

315+```hoon

316++$ null ~

194```

317```

195− > *foot

196− [%yew p={}]

197

318

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

319+#### Examples

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

320+

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

321+```

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

322+> *null

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

323+~

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

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

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

206```

324```

207

325

208---

326---

209

327

210−## `++limb`

328+## `+$onyx`

329+

330+Arm activation

331+

332+#### Source

211

333

212```hoon

334```hoon

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

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

214```

336```

215

337

216−XX move to `++ut`

338+---

217

339

218−Reference into subject by name/axis

340+## `+$opal`

219

341

220−See also: section 2fC-2fD

342+Wing match

343+

344+Arm or leg of a wing.

345+

346+#### Source

221

347

222```hoon

348```hoon

223− > (ream '^^$')

349++$ opal :: limb match

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

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

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

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

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

352+ == ::

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

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

229```

353```

230

354

231---

355---

232

356

233−## `++line`

357+## `+$pica`

234

358

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.

236

363

237#### Source

364#### Source

238

365

239```hoon

366```hoon

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

367++$ pica (pair ? cord)

241```

368```

242

369

243−#### Examples

370+---

244

371

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)

245```

382```

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

383+

247− [ %bccm

384+---

248− p

385+

249− [ %kelp

386+## `+$plat`

250− p

387+

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

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

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

389+

253− ]

390+#### Source

254− ]

391+

255− ]

392+```hoon

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

393++$ plat

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

394+ $? %hoon

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

395+ %type

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

396+ %nock

397+ %tank

398+ ==

260```

399```

261

400

262---

401---

263

402

264−## `++metl`

403+## `+$pock`

404+

405+Changes

406+

407+#### Source

265

408

266```hoon

409```hoon

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

410++$ pock (pair axis nock)

268```

411```

269

412

270−XX move to `++ut`

413+---

271

414

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+```

273

424

274---

425---

275

426

276−## `++nock`

427+## `+$spec`

277

428

278−Virtual machine. See Nock.

429+Structure definition AST.

279

430

280#### Source

431#### Source

281

432

282```hoon

433```hoon

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

434++$ spec :: structure definition

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

293− == ::

466+ == ::

294```

467```

295

468

296#### Examples

469#### Examples

297

470

298```

471```

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

472+> *spec

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

473+[%base p=%null]

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

474+

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

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

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

303```

477```

304

478

305---

479---

306

480

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

308

503

309```hoon

504```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+ == ::

311```

509```

312

510

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

314

520

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+ == ::

315```

534```

316− > :type; *null

535+

317− ~

536+---

318− %~

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))

319```

548```

320

549

321---

550---

322

551

323−## `++port`

552+## `+$tope`

324

553

325−XX move to `++ut`

554+Topographic type

326

555

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

556+Describes the structure of a noun.

328

557

329#### Source

558#### Source

330

559

331```hoon

560```hoon

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

561++$ tope :: topographic type

333− $= q ::

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

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

563+ %| :: atom

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

564+ == ::

336− == ::

565+ (pair tope tope) :: cell

337− == ::

338```

566```

339

567

340#### Examples

568#### Examples

341

569

342```

570```

343− > *port

571+> *tope

572+%.n

573+

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

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

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

345```

576```

346

577

347---

578---

348

579

349−## `++span`

580+## `++hoot`

350

581

351−ASCII atom

582+Hoon tools

352

583

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

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

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

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

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

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

356−besides numbers and lowercase letters are permitted.

357

587

358#### Source

588#### Source

359

589

360```hoon

590```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])

362```

621```

363

622

364#### Examples

623#### Examples

365

624

366```

625```

367− > *span

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

368− ~.

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=~]

369

634

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'

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

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

636+[%foo %bar]

637+

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

379− 'foo-bar'

639+%foo

380```

640```

381

641

382---

642---

383

643

384−## `++tiki`

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

645+

646+Dynamic XML node

385

647

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).

387

652

388#### Source

653#### Source

389

654

390```hoon

655```hoon

391− ++ tiki :: test case

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

392```

657```

393

658

394#### Examples

659#### Examples

395

660

396```

661```

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

662+> *manx:hoot

398−

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

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

664+

400− [ %tsls

665+> `manx:hoot`;foo;

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

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

402− q

667+

403− [ %wthz

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

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

669+"<foo></foo>"

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

670+

406− ]

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=~]]

407 ]

685 ]

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

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

409− [ %tsls

687+ c

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

688+ ~[

411− q

689+ [ g=[n=%xxx a=~]

412− [ %wthz

690+ c=~[[g=[n=%$ a=~[[n=%$ v="hello"]]] c=~]]

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

691+ ]

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

415 ]

692 ]

416 ]

693 ]

694+ ]

695+]

696+

697+> (en-xml:html a)

698+"<foo><bar>abc</bar><baz><xxx>hello</xxx></baz></foo>"

417```

699```

418

700

419---

701---

420

702

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+```

422

715

423−Tree of faces

716+#### Examples

424

717

425−A face, or tree of faces. A `++toga` is applied to anything assigned

718+```

426−using `^=`.

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+---

427

743

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).

429

751

430#### Source

752#### Source

431

753

432```hoon

754```hoon

433− ++ toga :: face control

755++$ mart (list [n=mane v=(list beer)])

434− [2 p=toga q=toga] :: cell toga

435− == ::

436```

756```

437

757

438#### Examples

758#### Examples

439

759

440```

760```

441− > a=1

761+> *mart:hoot

442− a=1

762+~

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− ]

452

763

453− > [a ~]=[1 2 3]

764+> `manx:hoot`;foo.bar;

454− [a=1 2 3]

765+[g=[n=%foo a=~[[n=%class v=~['b' 'a' 'r']]]] c=~]

455− > (ream '[a ~]=[1 2 3]')

766+

456− [ %ktts

767+> `mart:hoot`a.g:`manx:hoot`;foo.bar;

457− p=[%2 p=p=%a q=[%0 ~]]

768+~[[n=%class v=~['b' 'a' 'r']]]

458− q=[%cltr p=~[[%dtzy p=%ud q=1] [%dtzy p=%ud q=2] [%dtzy p=%ud q=3]]]

769+

459− ]

770+> (en-xml:html ;foo.bar;)

771+"<foo class=\"bar\"></foo>"

460```

772```

461

773

462---

774---

463

775

464−## `++tone`

776+### `+$marx:hoot`

465

777

466−Intermediate Nock computation result

778+Dynamic XML tag

467

779

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).

469

783

470#### Source

784#### Source

471

785

472```hoon

786```hoon

473− ++ tone $% [%0 p=*] :: success

787++$ marx $~([%$ ~] [n=mane a=mart])

474```

788```

475

789

476#### Examples

790#### Examples

477

791

478```

792```

479− > (mink [[20 21] 0 3] ,~)

793+> `manx:hoot`;foo.bar;

480− [%0 p=21]

794+[g=[n=%foo a=~[[n=%class v=~['b' 'a' 'r']]]] c=~]

481

795

482− > (mink [[0] !=(.^(cy//=main/1))] ,~)

796+> `marx:hoot`g:`manx:hoot`;foo.bar;

483− [%1 p=~[[31.075 1.685.027.454 1.852.399.981 49 0]]]

797+[n=%foo a=~[[n=%class v=~['b' 'a' 'r']]]]

484− > (path [31.075 1.685.027.454 1.852.399.981 49 0])

485− /cy/~zod/main/1

486

798

487− > (mink [[1 2] !=(~|(%hi +(.)))] ,~)

799+> (en-xml:html ;foo.bar;)

488− [%2 p=~[[~.yelp 26.984]]]

800+"<foo class=\"bar\"></foo>"

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− ]

508```

801```

509

802

510---

803---

511

804

512−## `++tuna`

805+### `+$mare:hoot`

513

806

514−XML template tree

807+Node or nodes

515

808

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).

517

811

518#### Source

812#### Source

519

813

520```hoon

814```hoon

521− ++ tuna :: tagflow

815++$ mare (each manx marl)

522− [%d p=hoon] :: dynamic list

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

524− [%f p=(list tuna)] :: subflow

525− == ::

526```

816```

527

817

528#### Examples

818#### Examples

529

819

530−Leaf %a contains plain-text, %b an empty tag, %c a static list, %d a

820+```

531−dynamic list, %e a full node element containing a hoon and a list of

821+> *mare:hoot

532−tuna, and %f is a empty node.

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`

533

834

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+```

535

864

536---

865---

537

866

538−## `++tusk`

867+## `+$hoon`

539

868

540−List of expressions

869+Hoon AST

541

870

542−List of `++hoon`s. In `:*`, for example, your contents is

871+See the [Rune section](/docs/hoon/reference/rune) of the Hoon reference for

543−a `++tusk`.

872+details of what many of these relate to.

544

873

545#### Source

874#### Source

546

875

547```hoon

876```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+ == ::

549```

1008```

550

1009

551#### Examples

1010#### Examples

552

1011

553```

1012```

554− > (ream '[1 2 3]')

1013+> *hoon

555− [%cltr p=~[[%dtzy p=%ud q=1] [%dtzy p=%ud q=2] [%dtzy p=%ud q=3]]]

1014+[%zpzp ~]

556− > (tusk +:(ream '[1 2 3]'))

1015+

557− ~[[%dtzy p=%ud q=1] [%dtzy p=%ud q=2] [%dtzy p=%ud q=3]]

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+]

558```

1027```

559

1028

560---

1029---

561

1030

562−## `++hoon`

1031+## `+$tyre`

563

1032

564−Expression

1033+List, term hoon

565

1034

566−An expression, or AST.

1035+Associative list of `term` `hoon`, used in jet hint processing.

567

1036

568−See Rune section of Hoon reference

1037+#### Source

1038+

1039+```hoon

1040++$ tyre (list [p=term q=hoon]) ::

1041+```

569

1042

570---

1043---

571

1044

572−## `++tyke`

1045+## `+$tyke`

573

1046

574List of 'maybe' hoons

1047List of 'maybe' hoons

575

1048

576−List of `++unit` `++hoon`, or gaps left to be inferred, in `++path`

1049+List of `unit` `hoon`, or gaps left to be inferred, in `path` parsing. When you

577−parsing. When you use a path such as `/=main=/pub/src/doc` the path is in fact

1050+use a path such as `/=base=/gen/code` the path is in fact a `tyke`, where the

578−a `++tyke`, where the `=` are inferred from your current path.

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.

579

1066

580#### Source

1067#### Source

581

1068

582```hoon

1069```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+ == ::

584```

1085```

585

1086

586#### Examples

1087#### Examples

587

1088

588```

1089```

589− > (scan "/==as=" porc:vast)

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

590− [0 ~[~ ~ [~ [%dtzy p=%tas q=29.537]] ~]]

1091+[[4 0 1] [1 20] 0 4]

591− > `tyke`+:(scan "/==as=" porc:vast)

1092+

592− ~[~ ~ [~ [%dtzy p=%tas q=29.537]] ~]

1093+> (nock !=([+(.) 20]))

1094+[p=[%4 p=[%0 p=1]] q=[%1 p=20]]

593```

1095```

594

1096

595---

1097---

596

1098

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+---

598

1116

599−Pointer for `++type`

1117+## `+$type`

600

1118

601−Pointer for `++type`. `++typo` preserves the previous `++type` in your

1119+Hoon type type

602−context when upating.

603

1120

604#### Source

1121#### Source

605

1122

606```hoon

1123```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+ == ::

608```

1136```

609

1137

610#### Examples

1138#### Examples

611

1139

612−See also: `++seem`, `++vise`, `++type`

1140+```

1141+> `type`[%cell [%atom %ud ~] [%atom %ud ~]]

1142+#t/[@ud @ud]

1143+```

613

1144

614---

1145---

615

1146

616−## `++tyre`

1147+## `+$tony`

617

1148

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+---

619

1166

620−Associative list of `++term` `++hoon`, used in jet hint processing.

1167+## `+$tine`

1168+

1169+Partial noun

621

1170

622#### Source

1171#### Source

623

1172

624```hoon

1173```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+ == ::

626```

1179```

627

1180

628---

1181---

629

1182

630−## `++vase`

1183+## `+$tool`

631

1184

632−Typed data. A `++vase` is used wherever typed data is explicitly worked

1185+Type decoration

633−with.

634

1186

635#### Source

1187#### Source

636

1188

637```hoon

1189```hoon

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+

638− ++ vase ,[p=type q=*] :: type-value pair

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=*]

639```

1235```

640

1236

641#### Examples

1237#### Examples

642

1238

643```

1239```

644− > `vase`!>(~)

1240+> *vase

645− [p=[%cube p=0 q=[%atom p=%n]] q=0]

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)))

646```

1355```

647

1356

648---

1357---

649

1358

650−## `++vise`

1359+## `+$wing`

651

1360

652−Convert during reboot

1361+Search path

653

1362

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`.

655

1365

656#### Source

1366#### Source

657

1367

658```hoon

1368```hoon

659− ++ vise ,[p=typo q=*] :: old vase

1369++$ wing (list limb)

660```

1370```

661

1371

662#### Examples

1372#### Examples

663

1373

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+```

665

1381

666---

1382---

667

1383

668−## `++wing`

1384+## `+$block`

1385+

1386+Abstract identity of resource awaited

1387+

1388+#### Source

669

1389

670```hoon

1390```hoon

671− ++ wing (list limb) ::

1391++$ block

1392+ path

672```

1393```

673

1394

674−Address in subject. A `++wing` is a path to a value in the subject. A

1395+---

675−term alone is the trivial case of a `++wing`.

676

1396

677−See also: `++hoon`

1397+## `+$result`

678

1398

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))

679```

1419```

680− > (ream 'a.+.c')

1420+

681− [%cnzz p=~[%a [%.y p=3] %c]]

1421+---

682− > (wing +:(ream 'a.+.c'))

1422+

683− ~[%a [%.y p=3] %c]

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+ ==

684```

1471```

685

1472

686---

1473---

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).

16<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#ab' title="Primitive parser engine"><code>++ab</code></a>

17<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#absfl' title="Absolute value"><code>++abs:fl</code></a>

18<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>

20<a class="tooltip" href='/docs/hoon/reference/stdlib/4h/#ace' title="Parse space"><code>++ace</code></a>

21<a class="tooltip" href='/docs/hoon/reference/stdlib/4k/#a-coco' title="Render decimal"><code>++a-co:co</code></a>

22<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).

29<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#addrq' title="Add (quadprecision float)"><code>++add:rq</code></a>

30<a class="tooltip" href='/docs/hoon/reference/stdlib/2n/#aftr' title="Pair after"><code>++aftr</code></a>

31<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>

32<a class="tooltip" href='/docs/hoon/reference/stdlib/4i/#alf' title="Parse alphabetic characters"><code>++alf</code></a>

33<a class="tooltip" href='/docs/hoon/reference/stdlib/4i/#alf' title="Parse alphabetic characters"><code>++alf</code></a>

33<a class="tooltip" href='/docs/hoon/reference/stdlib/2i/#allby' title="Logical AND (map and wet gate)"><code>++all:by</code></a>

34<a class="tooltip" href='/docs/hoon/reference/stdlib/2i/#allby' title="Logical AND (map and wet gate)"><code>++all:by</code></a>

34<a class="tooltip" href='/docs/hoon/reference/stdlib/2h/#allin' title="Logical AND (set and wet gate)"><code>++all:in</code></a>

35<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).

42<a class="tooltip" href='/docs/hoon/reference/stdlib/2h/#aptin' title="Check correctness (set)"><code>++apt:in</code></a>

43<a class="tooltip" href='/docs/hoon/reference/stdlib/2h/#aptin' title="Check correctness (set)"><code>++apt:in</code></a>

43<a class="tooltip" href='/docs/hoon/reference/stdlib/2k/#aptto' title="Check correctness of queue"><code>++apt:to</code></a>

44<a class="tooltip" href='/docs/hoon/reference/stdlib/2k/#aptto' title="Check correctness of queue"><code>++apt:to</code></a>

44<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/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>

46<a class="tooltip" href='/docs/hoon/reference/stdlib/2q/#axis' title="Tree address"><code>+$axis</code></a>

48<a class="tooltip" href='/docs/hoon/reference/stdlib/2q/#axis' title="Tree address"><code>+$axis</code></a>

48### b

50### b

@@ -51,12 +53,11 @@ Can be navigated [alphabetically](#alphabetical) or [by section](#by-section).

51<a class="tooltip" href='/docs/hoon/reference/stdlib/2k/#balto' title="Balance queue"><code>++bal:to</code></a>

53<a class="tooltip" href='/docs/hoon/reference/stdlib/2k/#balto' title="Balance queue"><code>++bal:to</code></a>

52<a class="tooltip" href='/docs/hoon/reference/stdlib/4h/#bar' title="Parse | (bar)"><code>++bar</code></a>

54<a class="tooltip" href='/docs/hoon/reference/stdlib/4h/#bar' title="Parse | (bar)"><code>++bar</code></a>

53<a class="tooltip" href='/docs/hoon/reference/stdlib/4h/#bas' title="Parse \ (bas)"><code>++bas</code></a>

55<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>

55<a class="tooltip" href='/docs/hoon/reference/stdlib/4f/#bass' title="Parser modifier (LSBordered ++list as atom of ++base)"><code>++bass</code></a>

57<a class="tooltip" href='/docs/hoon/reference/stdlib/4f/#bass' title="Parser modifier (LSBordered ++list as atom of ++base)"><code>++bass</code></a>

56<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#bayag' title="Parses binary number"><code>++bay:ag</code></a>

58<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#bayag' title="Parses binary number"><code>++bay:ag</code></a>

57<a class="tooltip" href='/docs/hoon/reference/stdlib/2q/#bean' title="Boolean"><code>+$bean</code></a>

59<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>

60+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#beerhoot' title="Simple embed"><code>+$beer:hoot</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/4e/#bend' title="Conditional composer"><code>++bend</code></a>

61<a class="tooltip" href='/docs/hoon/reference/stdlib/4e/#bend' title="Conditional composer"><code>++bend</code></a>

61<a class="tooltip" href='/docs/hoon/reference/stdlib/4i/#bet' title="Parse hep and lus axis syntax"><code>++bet</code></a>

62<a class="tooltip" href='/docs/hoon/reference/stdlib/4i/#bet' title="Parse hep and lus axis syntax"><code>++bet</code></a>

62<a class="tooltip" href='/docs/hoon/reference/stdlib/2c/#bex' title="Binary exponent"><code>++bex</code></a>

63<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).

75<a class="tooltip" href='/docs/hoon/reference/stdlib/1c/#bite' title="Atom slice specificier"><code>$bite</code></a>

76<a class="tooltip" href='/docs/hoon/reference/stdlib/1c/#bite' title="Atom slice specificier"><code>$bite</code></a>

76<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#bixab' title="Parse hex pair"><code>++bix:ab</code></a>

77<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#bixab' title="Parse hex pair"><code>++bix:ab</code></a>

77<a class="tooltip" href='/docs/hoon/reference/stdlib/4l/#biskso' title="Parse auraatom pair"><code>++bisk:so</code></a>

78<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>

78<a class="tooltip" href='/docs/hoon/reference/stdlib/1c/#bloq' title="Blocksize"><code>$bloq</code></a>

80<a class="tooltip" href='/docs/hoon/reference/stdlib/1c/#bloq' title="Blocksize"><code>$bloq</code></a>

79<a class="tooltip" href='/docs/hoon/reference/stdlib/2a/#bond' title="Replace null"><code>++bond</code></a>

81<a class="tooltip" href='/docs/hoon/reference/stdlib/2a/#bond' title="Replace null"><code>++bond</code></a>

80<a class="tooltip" href='/docs/hoon/reference/stdlib/4f/#boss' title="Parser modifier: LSB"><code>++boss</code></a>

82<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).

96<a class="tooltip" href='/docs/hoon/reference/stdlib/3c/#cetyo' title="Days in a century"><code>++cet:yo</code></a>

98<a class="tooltip" href='/docs/hoon/reference/stdlib/3c/#cetyo' title="Days in a century"><code>++cet:yo</code></a>

97<a class="tooltip" href='/docs/hoon/reference/stdlib/4a/#chafa' title="Decode base58check character"><code>++cha:fa</code></a>

99<a class="tooltip" href='/docs/hoon/reference/stdlib/4a/#chafa' title="Decode base58check character"><code>++cha:fa</code></a>

98<a class="tooltip" href='/docs/hoon/reference/stdlib/2q/#char' title="Character"><code>+$char</code></a>

100<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>

100<a class="tooltip" href='/docs/hoon/reference/stdlib/4i/#cit' title="Octal digit"><code>++cit</code></a>

102<a class="tooltip" href='/docs/hoon/reference/stdlib/4i/#cit' title="Octal digit"><code>++cit</code></a>

101<a class="tooltip" href='/docs/hoon/reference/stdlib/2a/#clap' title="Combine two units with function"><code>++clap</code></a>

103<a class="tooltip" href='/docs/hoon/reference/stdlib/2a/#clap' title="Combine two units with function"><code>++clap</code></a>

102<a class="tooltip" href='/docs/hoon/reference/stdlib/2a/#clef' title="Compose two units with function"><code>++clef</code></a>

104<a class="tooltip" href='/docs/hoon/reference/stdlib/2a/#clef' title="Compose two units with function"><code>++clef</code></a>

103<a class="tooltip" href='/docs/hoon/reference/stdlib/3a/#cmpsi' title="Compare (signed integer)"><code>++cmp:si</code></a>

105<a class="tooltip" href='/docs/hoon/reference/stdlib/3a/#cmpsi' title="Compare (signed integer)"><code>++cmp:si</code></a>

104<a class="tooltip" href='/docs/hoon/reference/stdlib/4k/#co' title="Literal rendering engine"><code>++co</code></a>

106<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>

106<a class="tooltip" href='/docs/hoon/reference/stdlib/3g/#coin' title="Nounliteral syntax cases"><code>+$coin</code></a>

108<a class="tooltip" href='/docs/hoon/reference/stdlib/3g/#coin' title="Nounliteral syntax cases"><code>+$coin</code></a>

107<a class="tooltip" href='/docs/hoon/reference/stdlib/4h/#col' title="Parse : (col)"><code>++col</code></a>

109<a class="tooltip" href='/docs/hoon/reference/stdlib/4h/#col' title="Parse : (col)"><code>++col</code></a>

108<a class="tooltip" href='/docs/hoon/reference/stdlib/4f/#cold' title="Replace with constant"><code>++cold</code></a>

110<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).

113<a class="tooltip" href='/docs/hoon/reference/stdlib/2q/#cord' title="UTF8 text"><code>+$cord</code></a>

115<a class="tooltip" href='/docs/hoon/reference/stdlib/2q/#cord' title="UTF8 text"><code>+$cord</code></a>

114<a class="tooltip" href='/docs/hoon/reference/stdlib/2n/#cork' title="Compose forward"><code>++cork</code></a>

116<a class="tooltip" href='/docs/hoon/reference/stdlib/2n/#cork' title="Compose forward"><code>++cork</code></a>

115<a class="tooltip" href='/docs/hoon/reference/stdlib/2n/#corl' title="Compose backward"><code>++corl</code></a>

117<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>

116<a class="tooltip" href='/docs/hoon/reference/stdlib/4b/#crip' title="Tape to cord"><code>++crip</code></a>

119<a class="tooltip" href='/docs/hoon/reference/stdlib/4b/#crip' title="Tape to cord"><code>++crip</code></a>

117<a class="tooltip" href='/docs/hoon/reference/stdlib/4l/#crubso' title="Parse @da, @dr, @p, @t"><code>++crub:so</code></a>

120<a class="tooltip" href='/docs/hoon/reference/stdlib/4l/#crubso' title="Parse @da, @dr, @p, @t"><code>++crub:so</code></a>

118<a class="tooltip" href='/docs/hoon/reference/stdlib/2p/#cue' title="Unpack atom to noun"><code>++cue</code></a>

121<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).

159<a class="tooltip" href='/docs/hoon/reference/stdlib/4i/#doh' title="@p separator"><code>++doh</code></a>

162<a class="tooltip" href='/docs/hoon/reference/stdlib/4i/#doh' title="@p separator"><code>++doh</code></a>

160<a class="tooltip" href='/docs/hoon/reference/stdlib/4h/#doq' title="Parse double quote"><code>++doq</code></a>

163<a class="tooltip" href='/docs/hoon/reference/stdlib/4h/#doq' title="Parse double quote"><code>++doq</code></a>

161<a class="tooltip" href='/docs/hoon/reference/stdlib/2f/#dor' title="Depth order"><code>++dor</code></a>

164<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>

162<a class="tooltip" href='/docs/hoon/reference/stdlib/4h/#dot' title="Parse period"><code>++dot</code></a>

166<a class="tooltip" href='/docs/hoon/reference/stdlib/4h/#dot' title="Parse period"><code>++dot</code></a>

163<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#drgff' title="@r to decimal float"><code>++drg:ff</code></a>

167<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#drgff' title="@r to decimal float"><code>++drg:ff</code></a>

164<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#drgfl' title="Get printable decimal (signed and unsigned integer cell)"><code>++drg:fl</code></a>

168<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).

233<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#fmars' title="Fused multiplyadd (singleprecision float)"><code>++fma:rs</code></a>

237<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#fmars' title="Fused multiplyadd (singleprecision float)"><code>++fma:rs</code></a>

234<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#fmarq' title="Fused multiplyadd (quadprecision float)"><code>++fma:rq</code></a>

238<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#fmarq' title="Fused multiplyadd (quadprecision float)"><code>++fma:rq</code></a>

235<a class="tooltip" href='/docs/hoon/reference/stdlib/3a/#fo' title="Modulo prime"><code>++fo</code></a>

239<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>

237<a class="tooltip" href='/docs/hoon/reference/stdlib/2n/#fore' title="Pair before"><code>++fore</code></a>

241<a class="tooltip" href='/docs/hoon/reference/stdlib/2n/#fore' title="Pair before"><code>++fore</code></a>

238<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#fosrh' title="@rs to @rh"><code>++fos:rh</code></a>

242<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#fosrh' title="@rs to @rh"><code>++fos:rh</code></a>

239<a class="tooltip" href='/docs/hoon/reference/stdlib/3a/#frafo' title="Divide (modular base)"><code>++fra:fo</code></a>

243<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).

250<a class="tooltip" href='/docs/hoon/reference/stdlib/4i/#gap' title="Plural whitespace"><code>++gap</code></a>

254<a class="tooltip" href='/docs/hoon/reference/stdlib/4i/#gap' title="Plural whitespace"><code>++gap</code></a>

251<a class="tooltip" href='/docs/hoon/reference/stdlib/4i/#gaq' title="End of line"><code>++gaq</code></a>

255<a class="tooltip" href='/docs/hoon/reference/stdlib/4i/#gaq' title="End of line"><code>++gaq</code></a>

252<a class="tooltip" href='/docs/hoon/reference/stdlib/4h/#gar' title="Parse > (gar)"><code>++gar</code></a>

256<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>

253<a class="tooltip" href='/docs/hoon/reference/stdlib/2i/#gasby' title="Concatenate (map)"><code>++gas:by</code></a>

258<a class="tooltip" href='/docs/hoon/reference/stdlib/2i/#gasby' title="Concatenate (map)"><code>++gas:by</code></a>

254<a class="tooltip" href='/docs/hoon/reference/stdlib/2h/#gasin' title="Concatenate (set)"><code>++gas:in</code></a>

259<a class="tooltip" href='/docs/hoon/reference/stdlib/2h/#gasin' title="Concatenate (set)"><code>++gas:in</code></a>

255<a class="tooltip" href='/docs/hoon/reference/stdlib/2j/#gasju' title="Concatenate (jug)"><code>++gas:ju</code></a>

260<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).

297<a class="tooltip" href='/docs/hoon/reference/stdlib/2j/#hasju' title="Check contents (jug)"><code>++has:ju</code></a>

302<a class="tooltip" href='/docs/hoon/reference/stdlib/2j/#hasju' title="Check contents (jug)"><code>++has:ju</code></a>

298<a class="tooltip" href='/docs/hoon/reference/stdlib/4h/#hax' title="Parse # (hax)"><code>++hax</code></a>

303<a class="tooltip" href='/docs/hoon/reference/stdlib/4h/#hax' title="Parse # (hax)"><code>++hax</code></a>

299<a class="tooltip" href='/docs/hoon/reference/stdlib/2n/#head' title="Get head of cell"><code>++head</code></a>

304<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>

300<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#hefab' title="Parse non-dozzod phonetic pair"><code>++hef:ab</code></a>

306<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#hefab' title="Parse non-dozzod phonetic pair"><code>++hef:ab</code></a>

301<a class="tooltip" href='/docs/hoon/reference/stdlib/4f/#here' title="Placebased apply"><code>++here</code></a>

307<a class="tooltip" href='/docs/hoon/reference/stdlib/4f/#here' title="Placebased apply"><code>++here</code></a>

302<a class="tooltip" href='/docs/hoon/reference/stdlib/4h/#hep' title="Parse (hep)"><code>++hep</code></a>

308<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).

307<a class="tooltip" href='/docs/hoon/reference/stdlib/4i/#hit' title="Parse single hexadecimal digit"><code>++hit</code></a>

313<a class="tooltip" href='/docs/hoon/reference/stdlib/4i/#hit' title="Parse single hexadecimal digit"><code>++hit</code></a>

308<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#hofab' title="Parse 2-4 @q phonetic pair"><code>++hof:ab</code></a>

314<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#hofab' title="Parse 2-4 @q phonetic pair"><code>++hof:ab</code></a>

309<a class="tooltip" href='/docs/hoon/reference/stdlib/2b/#homo' title="Homogenize list"><code>++homo</code></a>

315<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>

310<a class="tooltip" href='/docs/hoon/reference/stdlib/3c/#horyo' title="Seconds in hour"><code>++hor:yo</code></a>

318<a class="tooltip" href='/docs/hoon/reference/stdlib/3c/#horyo' title="Seconds in hour"><code>++hor:yo</code></a>

311<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#hufab' title="Parse 1-4 @q phonetic pairs"><code>++huf:ab</code></a>

319<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>

312<a class="tooltip" href='/docs/hoon/reference/stdlib/2a/#hunt' title="Select between two units by a rule"><code>++hunt</code></a>

321<a class="tooltip" href='/docs/hoon/reference/stdlib/2a/#hunt' title="Select between two units by a rule"><code>++hunt</code></a>

313<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#hyfab' title="Parse four @q phonetic pairs"><code>++hyf:ab</code></a>

322<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#hyfab' title="Parse four @q phonetic pairs"><code>++hyf:ab</code></a>

314

323

@@ -361,9 +370,9 @@ Can be navigated [alphabetically](#alphabetical) or [by section](#by-section).

361<a class="tooltip" href='/docs/hoon/reference/stdlib/2b/#lien' title="Logical OR on list"><code>++lien</code></a>

370<a class="tooltip" href='/docs/hoon/reference/stdlib/2b/#lien' title="Logical OR on list"><code>++lien</code></a>

362<a class="tooltip" href='/docs/hoon/reference/stdlib/2a/#lift' title="Curried bind"><code>++lift</code></a>

371<a class="tooltip" href='/docs/hoon/reference/stdlib/2a/#lift' title="Curried bind"><code>++lift</code></a>

363<a class="tooltip" href='/docs/hoon/reference/stdlib/3g/#like' title="Generic edge"><code>++like</code></a>

372<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>

365<a class="tooltip" href='/docs/hoon/reference/stdlib/2b/#limo' title="Construct list from nullterminated tuple"><code>++limo</code></a>

374<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>

367<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#lipag' title="Parse IPv4 address"><code>++lip:ag</code></a>

376<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#lipag' title="Parse IPv4 address"><code>++lip:ag</code></a>

368<a class="tooltip" href='/docs/hoon/reference/stdlib/1c/#list' title="Mold constructor (list)"><code>++list</code></a>

377<a class="tooltip" href='/docs/hoon/reference/stdlib/1c/#list' title="Mold constructor (list)"><code>++list</code></a>

369<a class="tooltip" href='/docs/hoon/reference/stdlib/1c/#lone' title="Mold generator (face on mold)"><code>++lone</code></a>

378<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).

391

400

392### m

401### m

393

402

403+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#manxhoot' title="Dynamic XML node"><code>+$manx:hoot</code></a>

394<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#mard' title="Initialize ff (rd core)"><code>++ma:rd</code></a>

404<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#mard' title="Initialize ff (rd core)"><code>++ma:rd</code></a>

395<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#marh' title="Initialize ff (rh core)"><code>++ma:rh</code></a>

405<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#marh' title="Initialize ff (rh core)"><code>++ma:rh</code></a>

396<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#mars' title="Initialize ff (rs core)"><code>++ma:rs</code></a>

406<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#mars' title="Initialize ff (rs core)"><code>++ma:rs</code></a>

397<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#marq' title="Initialize ff (rq core)"><code>++ma:rq</code></a>

407<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#marq' title="Initialize ff (rq core)"><code>++ma:rq</code></a>

398<a class="tooltip" href='/docs/hoon/reference/stdlib/4n/#mack' title="Nock subject to unit"><code>++mack</code></a>

408<a class="tooltip" href='/docs/hoon/reference/stdlib/4n/#mack' title="Nock subject to unit"><code>++mack</code></a>

399<a class="tooltip" href='/docs/hoon/reference/stdlib/2l/#malt' title="Map from list"><code>++malt</code></a>

409<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>

400<a class="tooltip" href='/docs/hoon/reference/stdlib/2o/#map' title="Mold generator (map)"><code>++map</code></a>

411<a class="tooltip" href='/docs/hoon/reference/stdlib/2o/#map' title="Mold generator (map)"><code>++map</code></a>

401<a class="tooltip" href='/docs/hoon/reference/stdlib/2i/#marby' title="Add with validation (map)"><code>++mar:by</code></a>

412<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>

402<a class="tooltip" href='/docs/hoon/reference/stdlib/1b/#mas' title="Address within head/tail"><code>++mas</code></a>

418<a class="tooltip" href='/docs/hoon/reference/stdlib/1b/#mas' title="Address within head/tail"><code>++mas</code></a>

403<a class="tooltip" href='/docs/hoon/reference/stdlib/4f/#mask' title="Match character"><code>++mask</code></a>

419<a class="tooltip" href='/docs/hoon/reference/stdlib/4f/#mask' title="Match character"><code>++mask</code></a>

404<a class="tooltip" href='/docs/hoon/reference/stdlib/2p/#mat' title="Lengthencode"><code>++mat</code></a>

420<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).

409<a class="tooltip" href='/docs/hoon/reference/stdlib/4i/#mes' title="Parse hexabyte"><code>++mes</code></a>

425<a class="tooltip" href='/docs/hoon/reference/stdlib/4i/#mes' title="Parse hexabyte"><code>++mes</code></a>

410<a class="tooltip" href='/docs/hoon/reference/stdlib/4b/#mesc' title="Escape special characters"><code>++mesc</code></a>

426<a class="tooltip" href='/docs/hoon/reference/stdlib/4b/#mesc' title="Escape special characters"><code>++mesc</code></a>

411<a class="tooltip" href='/docs/hoon/reference/stdlib/2c/#met' title="Measure"><code>++met</code></a>

427<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>

413<a class="tooltip" href='/docs/hoon/reference/stdlib/1a/#min' title="Minimum (atom)"><code>++min</code></a>

428<a class="tooltip" href='/docs/hoon/reference/stdlib/1a/#min' title="Minimum (atom)"><code>++min</code></a>

414<a class="tooltip" href='/docs/hoon/reference/stdlib/4n/#mink' title="Mock (virtual Nock) interpreter"><code>++mink</code></a>

429<a class="tooltip" href='/docs/hoon/reference/stdlib/4n/#mink' title="Mock (virtual Nock) interpreter"><code>++mink</code></a>

415<a class="tooltip" href='/docs/hoon/reference/stdlib/3c/#mityo' title="Seconds in minute"><code>++mit:yo</code></a>

430<a class="tooltip" href='/docs/hoon/reference/stdlib/3c/#mityo' title="Seconds in minute"><code>++mit:yo</code></a>

416<a class="tooltip" href='/docs/hoon/reference/stdlib/2d/#mix' title="Binary XOR (atom)"><code>++mix</code></a>

431<a class="tooltip" href='/docs/hoon/reference/stdlib/2d/#mix' title="Binary XOR (atom)"><code>++mix</code></a>

417<a class="tooltip" href='/docs/hoon/reference/stdlib/4i/#mixed-case-symbol' title="Mixed-case term"><code>++mixed-case-symbol</code></a>

432<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>

418<a class="tooltip" href='/docs/hoon/reference/stdlib/4n/#mock' title="Compute formula on subject with hint"><code>++mock</code></a>

434<a class="tooltip" href='/docs/hoon/reference/stdlib/4n/#mock' title="Compute formula on subject with hint"><code>++mock</code></a>

419<a class="tooltip" href='/docs/hoon/reference/stdlib/1a/#mod' title="Modulus (atom)"><code>++mod</code></a>

435<a class="tooltip" href='/docs/hoon/reference/stdlib/1a/#mod' title="Modulus (atom)"><code>++mod</code></a>

420<a class="tooltip" href='/docs/hoon/reference/stdlib/3c/#mohyo' title="Days in month"><code>++moh:yo</code></a>

436<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>

421<a class="tooltip" href='/docs/hoon/reference/stdlib/2l/#molt' title="Map from pair list"><code>++molt</code></a>

438<a class="tooltip" href='/docs/hoon/reference/stdlib/2l/#molt' title="Map from pair list"><code>++molt</code></a>

422<a class="tooltip" href='/docs/hoon/reference/stdlib/4n/#mong' title="Slam gate with sample"><code>++mong</code></a>

439<a class="tooltip" href='/docs/hoon/reference/stdlib/4n/#mong' title="Slam gate with sample"><code>++mong</code></a>

423<a class="tooltip" href='/docs/hoon/reference/stdlib/4n/#mook' title="Intelligently render crash annotation"><code>++mook</code></a>

440<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).

437<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#mulrs' title="Multiply (singleprecision float)"><code>++mul:rs</code></a>

454<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#mulrs' title="Multiply (singleprecision float)"><code>++mul:rs</code></a>

438<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#mulrq' title="Multiply (quadprecision float)"><code>++mul:rq</code></a>

455<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#mulrq' title="Multiply (quadprecision float)"><code>++mul:rq</code></a>

439<a class="tooltip" href='/docs/hoon/reference/stdlib/4n/#mule' title="Typed virtual"><code>++mule</code></a>

456<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>

440<a class="tooltip" href='/docs/hoon/reference/stdlib/4n/#mute' title="Untyped virtual"><code>++mute</code></a>

458<a class="tooltip" href='/docs/hoon/reference/stdlib/4n/#mute' title="Untyped virtual"><code>++mute</code></a>

441<a class="tooltip" href='/docs/hoon/reference/stdlib/2b/#murn' title="Maybe transform"><code>++murn</code></a>

459<a class="tooltip" href='/docs/hoon/reference/stdlib/2b/#murn' title="Maybe transform"><code>++murn</code></a>

442<a class="tooltip" href='/docs/hoon/reference/stdlib/2m/#my' title="Map from raw noun"><code>++my</code></a>

460<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).

455<a class="tooltip" href='/docs/hoon/reference/stdlib/2k/#nipto' title="Remove root of queue"><code>++nip:to</code></a>

473<a class="tooltip" href='/docs/hoon/reference/stdlib/2k/#nipto' title="Remove root of queue"><code>++nip:to</code></a>

456<a class="tooltip" href='/docs/hoon/reference/stdlib/4i/#nix' title="Parse letters and underscore"><code>++nix</code></a>

474<a class="tooltip" href='/docs/hoon/reference/stdlib/4i/#nix' title="Parse letters and underscore"><code>++nix</code></a>

457<a class="tooltip" href='/docs/hoon/reference/stdlib/2m/#nl' title="Noun to container operations"><code>++nl</code></a>

475<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>

459<a class="tooltip" href='/docs/hoon/reference/stdlib/2d/#not' title="Binary NOT (atom)"><code>++not</code></a>

477<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>

460<a class="tooltip" href='/docs/hoon/reference/stdlib/2q/#noun' title="Any noun"><code>+$noun</code></a>

479<a class="tooltip" href='/docs/hoon/reference/stdlib/2q/#noun' title="Any noun"><code>+$noun</code></a>

461<a class="tooltip" href='/docs/hoon/reference/stdlib/4l/#nuckso' title="Toplevel coin parser"><code>++nuck:so</code></a>

480<a class="tooltip" href='/docs/hoon/reference/stdlib/4l/#nuckso' title="Toplevel coin parser"><code>++nuck:so</code></a>

462<a class="tooltip" href='/docs/hoon/reference/stdlib/4i/#nud' title="Parse numeric character"><code>++nud</code></a>

481<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>

464<a class="tooltip" href='/docs/hoon/reference/stdlib/4l/#nuskso' title="Parse coin literal with escapes"><code>++nusk:so</code></a>

483<a class="tooltip" href='/docs/hoon/reference/stdlib/4l/#nuskso' title="Parse coin literal with escapes"><code>++nusk:so</code></a>

465

484

466### o

485### o

@@ -468,6 +487,8 @@ Can be navigated [alphabetically](#alphabetical) or [by section](#by-section).

468<a class="tooltip" href='/docs/hoon/reference/stdlib/3f/#ob' title="Reversible scrambling v2"><code>++ob</code></a>

487<a class="tooltip" href='/docs/hoon/reference/stdlib/3f/#ob' title="Reversible scrambling v2"><code>++ob</code></a>

469<a class="tooltip" href='/docs/hoon/reference/stdlib/3d/#og' title="Container arm for SHA256 powered RNG"><code>++og</code></a>

488<a class="tooltip" href='/docs/hoon/reference/stdlib/3d/#og' title="Container arm for SHA256 powered RNG"><code>++og</code></a>

470<a class="tooltip" href='/docs/hoon/reference/stdlib/3a/#oldsi' title="Sign and absolute value"><code>++old:si</code></a>

489<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>

471<a class="tooltip" href='/docs/hoon/reference/stdlib/2b/#oust' title="Remove from list"><code>++oust</code></a>

492<a class="tooltip" href='/docs/hoon/reference/stdlib/2b/#oust' title="Remove from list"><code>++oust</code></a>

472<a class="tooltip" href='/docs/hoon/reference/stdlib/2c/#outfe' title="Maximum integer value"><code>++out:fe</code></a>

493<a class="tooltip" href='/docs/hoon/reference/stdlib/2c/#outfe' title="Maximum integer value"><code>++out:fe</code></a>

473<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>

494<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).

482<a class="tooltip" href='/docs/hoon/reference/stdlib/2q/#path' title="Like unix path"><code>+$path</code></a>

503<a class="tooltip" href='/docs/hoon/reference/stdlib/2q/#path' title="Like unix path"><code>+$path</code></a>

483<a class="tooltip" href='/docs/hoon/reference/stdlib/1b/#peg' title="Address within address"><code>++peg</code></a>

504<a class="tooltip" href='/docs/hoon/reference/stdlib/1b/#peg' title="Address within address"><code>++peg</code></a>

484<a class="tooltip" href='/docs/hoon/reference/stdlib/4h/#pal' title="Parse ( (pal)"><code>++pal</code></a>

505<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>

485<a class="tooltip" href='/docs/hoon/reference/stdlib/4h/#par' title="Parse ) (par)"><code>++par</code></a>

507<a class="tooltip" href='/docs/hoon/reference/stdlib/4h/#par' title="Parse ) (par)"><code>++par</code></a>

486<a class="tooltip" href='/docs/hoon/reference/stdlib/4l/#perdso' title="Parsing coin literal without prefixes"><code>++perd:so</code></a>

508<a class="tooltip" href='/docs/hoon/reference/stdlib/4l/#perdso' title="Parsing coin literal without prefixes"><code>++perd:so</code></a>

487<a class="tooltip" href='/docs/hoon/reference/stdlib/4f/#perk' title="Parse cube fork"><code>++perk</code></a>

509<a class="tooltip" href='/docs/hoon/reference/stdlib/4f/#perk' title="Parse cube fork"><code>++perk</code></a>

488<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#pevab' title="Parse 1-5 @uv base-32 chars"><code>++pev:ab</code></a>

510<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#pevab' title="Parse 1-5 @uv base-32 chars"><code>++pev:ab</code></a>

489<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#pewab' title="Parse <= 5 in base 64"><code>++pew:ab</code></a>

511<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#pewab' title="Parse <= 5 in base 64"><code>++pew:ab</code></a>

490<a class="tooltip" href='/docs/hoon/reference/stdlib/4e/#pfix' title="Discard first rule"><code>++pfix</code></a>

512<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>

491<a class="tooltip" href='/docs/hoon/reference/stdlib/3g/#pint' title="Parsing range"><code>+$pint</code></a>

514<a class="tooltip" href='/docs/hoon/reference/stdlib/3g/#pint' title="Parsing range"><code>+$pint</code></a>

492<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#pivab' title="Parse 5 @uv base-32 chars"><code>++piv:ab</code></a>

515<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#pivab' title="Parse 5 @uv base-32 chars"><code>++piv:ab</code></a>

493<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#piwab' title="Parse 5 @uw base-64 chars"><code>++piw:ab</code></a>

516<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>

494<a class="tooltip" href='/docs/hoon/reference/stdlib/4e/#plug' title="Parse to tuple"><code>++plug</code></a>

518<a class="tooltip" href='/docs/hoon/reference/stdlib/4e/#plug' title="Parse to tuple"><code>++plug</code></a>

495<a class="tooltip" href='/docs/hoon/reference/stdlib/4f/#plus' title="List of at least one match"><code>++plus</code></a>

519<a class="tooltip" href='/docs/hoon/reference/stdlib/4f/#plus' title="List of at least one match"><code>++plus</code></a>

496<a class="tooltip" href='/docs/hoon/reference/stdlib/4a/#po' title="Phonetic base"><code>++po</code></a>

520<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>

497<a class="tooltip" href='/docs/hoon/reference/stdlib/1c/#pole' title="Mold generator of faceless list"><code>++pole</code></a>

522<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>

499<a class="tooltip" href='/docs/hoon/reference/stdlib/4e/#pose' title="Parse options"><code>++pose</code></a>

525<a class="tooltip" href='/docs/hoon/reference/stdlib/4e/#pose' title="Parse options"><code>++pose</code></a>

500<a class="tooltip" href='/docs/hoon/reference/stdlib/2g/#pow' title="Computes a to the power of b"><code>++pow</code></a>

526<a class="tooltip" href='/docs/hoon/reference/stdlib/2g/#pow' title="Computes a to the power of b"><code>++pow</code></a>

501<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#prcfl' title="Force precision of 2 or greater (floating point)"><code>++prc:fl</code></a>

527<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).

545<a class="tooltip" href='/docs/hoon/reference/stdlib/2c/#rep' title="Assemble single"><code>++rep</code></a>

571<a class="tooltip" href='/docs/hoon/reference/stdlib/2c/#rep' title="Assemble single"><code>++rep</code></a>

546<a class="tooltip" href='/docs/hoon/reference/stdlib/2i/#repby' title="Reduce to product (map)"><code>++rep:by</code></a>

572<a class="tooltip" href='/docs/hoon/reference/stdlib/2i/#repby' title="Reduce to product (map)"><code>++rep:by</code></a>

547<a class="tooltip" href='/docs/hoon/reference/stdlib/2h/#repin' title="Accumulate elements (set)"><code>++rep:in</code></a>

573<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>

548<a class="tooltip" href='/docs/hoon/reference/stdlib/2c/#rev' title="Reverse"><code>++rev</code></a>

575<a class="tooltip" href='/docs/hoon/reference/stdlib/2c/#rev' title="Reverse"><code>++rev</code></a>

549<a class="tooltip" href='/docs/hoon/reference/stdlib/4b/#rfat' title="Print loobean"><code>++rf:at</code></a>

576<a class="tooltip" href='/docs/hoon/reference/stdlib/4b/#rfat' title="Print loobean"><code>++rf:at</code></a>

550<a class="tooltip" href='/docs/hoon/reference/stdlib/2i/#ribby' title="Transform + product (map)"><code>++rib:by</code></a>

577<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).

607<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#searq' title="Convert from quadprecision float to fn"><code>++sea:rq</code></a>

634<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#searq' title="Convert from quadprecision float to fn"><code>++sea:rq</code></a>

608<a class="tooltip" href='/docs/hoon/reference/stdlib/4f/#sear' title="Conditional ++cook"><code>++sear</code></a>

635<a class="tooltip" href='/docs/hoon/reference/stdlib/4f/#sear' title="Conditional ++cook"><code>++sear</code></a>

609<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#sebab' title="Parse 1"><code>++seb:ab</code></a>

636<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>

610<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#sedab' title="Parse nonzero decimal digit"><code>++sed:ab</code></a>

638<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#sedab' title="Parse nonzero decimal digit"><code>++sed:ab</code></a>

611<a class="tooltip" href='/docs/hoon/reference/stdlib/4h/#sel' title="Parse [ (sel)"><code>++sel</code></a>

639<a class="tooltip" href='/docs/hoon/reference/stdlib/4h/#sel' title="Parse [ (sel)"><code>++sel</code></a>

612<a class="tooltip" href='/docs/hoon/reference/stdlib/4h/#mic' title="Parse ; (mic)"><code>++mic</code></a>

640<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).

649<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#sixab' title="Parse a hexadecimal digit"><code>++six:ab</code></a>

677<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#sixab' title="Parse a hexadecimal digit"><code>++six:ab</code></a>

650<a class="tooltip" href='/docs/hoon/reference/stdlib/2b/#skid' title="Separate list into two lists from slammed elments"><code>++skid</code></a>

678<a class="tooltip" href='/docs/hoon/reference/stdlib/2b/#skid' title="Separate list into two lists from slammed elments"><code>++skid</code></a>

651<a class="tooltip" href='/docs/hoon/reference/stdlib/2b/#skim' title="Produce list of elements from boolean gate"><code>++skim</code></a>

679<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>

652<a class="tooltip" href='/docs/hoon/reference/stdlib/2b/#skip' title="Produce list of elements failing boolean gate"><code>++skip</code></a>

681<a class="tooltip" href='/docs/hoon/reference/stdlib/2b/#skip' title="Produce list of elements failing boolean gate"><code>++skip</code></a>

653<a class="tooltip" href='/docs/hoon/reference/stdlib/2b/#slag' title="Produce all elements from index in list"><code>++slag</code></a>

682<a class="tooltip" href='/docs/hoon/reference/stdlib/2b/#slag' title="Produce all elements from index in list"><code>++slag</code></a>

654<a class="tooltip" href='/docs/hoon/reference/stdlib/4m/#slat' title="Curried slaw"><code>++slat</code></a>

683<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).

657<a class="tooltip" href='/docs/hoon/reference/stdlib/4m/#slay' title="Parse cord to coin"><code>++slay</code></a>

686<a class="tooltip" href='/docs/hoon/reference/stdlib/4m/#slay' title="Parse cord to coin"><code>++slay</code></a>

658<a class="tooltip" href='/docs/hoon/reference/stdlib/5c/#slog' title="Deify printf"><code>++slog</code></a>

687<a class="tooltip" href='/docs/hoon/reference/stdlib/5c/#slog' title="Deify printf"><code>++slog</code></a>

659<a class="tooltip" href='/docs/hoon/reference/stdlib/4f/#slug' title="Use gate to parse delimited list"><code>++slug</code></a>

688<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>

660<a class="tooltip" href='/docs/hoon/reference/stdlib/4m/#smyt' title="Render path as tank"><code>++smyt</code></a>

690<a class="tooltip" href='/docs/hoon/reference/stdlib/4m/#smyt' title="Render path as tank"><code>++smyt</code></a>

661<a class="tooltip" href='/docs/hoon/reference/stdlib/2b/#snag' title="Produce element at specific index (list)"><code>++snag</code></a>

691<a class="tooltip" href='/docs/hoon/reference/stdlib/2b/#snag' title="Produce element at specific index (list)"><code>++snag</code></a>

662<a class="tooltip" href='/docs/hoon/reference/stdlib/2m/#snagnl' title="Produce element from list at specific nullterminated noun"><code>++snag:nl</code></a>

692<a class="tooltip" href='/docs/hoon/reference/stdlib/2m/#snagnl' title="Produce element from list at specific nullterminated noun"><code>++snag:nl</code></a>

663<a class="tooltip" href='/docs/hoon/reference/stdlib/2b/#snip' title="Drop tail off list"><code>++snip</code></a>

693<a class="tooltip" href='/docs/hoon/reference/stdlib/2b/#snip' title="Drop tail off list"><code>++snip</code></a>

664<a class="tooltip" href='/docs/hoon/reference/stdlib/2b/#snoc' title="Append noun to list"><code>++snoc</code></a>

694<a class="tooltip" href='/docs/hoon/reference/stdlib/2b/#snoc' title="Append noun to list"><code>++snoc</code></a>

665<a class="tooltip" href='/docs/hoon/reference/stdlib/4l/#so' title="Coin parser engine"><code>++so</code></a>

695<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>

666<a class="tooltip" href='/docs/hoon/reference/stdlib/2a/#some' title="Wrap value in unit"><code>++some</code></a>

697<a class="tooltip" href='/docs/hoon/reference/stdlib/2a/#some' title="Wrap value in unit"><code>++some</code></a>

667<a class="tooltip" href='/docs/hoon/reference/stdlib/4h/#soq' title="Parse ' (soq)"><code>++soq</code></a>

698<a class="tooltip" href='/docs/hoon/reference/stdlib/4h/#soq' title="Parse ' (soq)"><code>++soq</code></a>

668<a class="tooltip" href='/docs/hoon/reference/stdlib/2b/#sort' title="Quicksort (list)"><code>++sort</code></a>

699<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).

670<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#sowab' title="Parse @uw base-64 letter/symbol"><code>++sow:ab</code></a>

701<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#sowab' title="Parse @uw base-64 letter/symbol"><code>++sow:ab</code></a>

671<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#soxab' title="Parse hexadecimal letter"><code>++sox:ab</code></a>

702<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#soxab' title="Parse hexadecimal letter"><code>++sox:ab</code></a>

672<a class="tooltip" href='/docs/hoon/reference/stdlib/4i/#soz' title="Parse triple singlequote"><code>++soz</code></a>

703<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>

674<a class="tooltip" href='/docs/hoon/reference/stdlib/4m/#spat' title="Render path as cord"><code>++spat</code></a>

704<a class="tooltip" href='/docs/hoon/reference/stdlib/4m/#spat' title="Render path as cord"><code>++spat</code></a>

675<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#spdfl' title="Produce smallest denormalized float"><code>++spd:fl</code></a>

705<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>

676<a class="tooltip" href='/docs/hoon/reference/stdlib/2b/#spin' title="Gate to list (with state)"><code>++spin</code></a>

707<a class="tooltip" href='/docs/hoon/reference/stdlib/2b/#spin' title="Gate to list (with state)"><code>++spin</code></a>

677<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#spnfl' title="Produce smallest normal float"><code>++spn:fl</code></a>

708<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#spnfl' title="Produce smallest normal float"><code>++spn:fl</code></a>

678<a class="tooltip" href='/docs/hoon/reference/stdlib/3g/#spot' title="Stack trace line"><code>+$spot</code></a>

709<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).

687<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#sqtrq' title="Produce square root of quadprecision float"><code>++sqt:rq</code></a>

718<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#sqtrq' title="Produce square root of quadprecision float"><code>++sqt:rq</code></a>

688<a class="tooltip" href='/docs/hoon/reference/stdlib/4m/#stab' title="Parse cord to path"><code>++stab</code></a>

719<a class="tooltip" href='/docs/hoon/reference/stdlib/4m/#stab' title="Parse cord to path"><code>++stab</code></a>

689<a class="tooltip" href='/docs/hoon/reference/stdlib/4f/#stag' title="Add label"><code>++stag</code></a>

720<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>

690<a class="tooltip" href='/docs/hoon/reference/stdlib/4f/#star' title="Produce list of matches"><code>++star</code></a>

722<a class="tooltip" href='/docs/hoon/reference/stdlib/4f/#star' title="Produce list of matches"><code>++star</code></a>

691<a class="tooltip" href='/docs/hoon/reference/stdlib/1c/#step' title="Atom size or offset, in bloqs"><code>++step</code></a>

723<a class="tooltip" href='/docs/hoon/reference/stdlib/1c/#step' title="Atom size or offset, in bloqs"><code>++step</code></a>

692<a class="tooltip" href='/docs/hoon/reference/stdlib/4f/#stet' title="Add faces to rangeparser pairs in list"><code>++stet</code></a>

724<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).

737<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#tedab' title="Parse 1-999 decimal"><code>++ted:ab</code></a>

769<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#tedab' title="Parse 1-999 decimal"><code>++ted:ab</code></a>

738<a class="tooltip" href='/docs/hoon/reference/stdlib/4b/#teff' title="UTF8 length"><code>++teff</code></a>

770<a class="tooltip" href='/docs/hoon/reference/stdlib/4b/#teff' title="UTF8 length"><code>++teff</code></a>

739<a class="tooltip" href='/docs/hoon/reference/stdlib/3f/#tailob' title="Reverse +feis"><code>++tail:ob</code></a>

771<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>

740<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#tepab' title="Parse non-doz leading phonetic byte"><code>++tep:ab</code></a>

773<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#tepab' title="Parse non-doz leading phonetic byte"><code>++tep:ab</code></a>

741<a class="tooltip" href='/docs/hoon/reference/stdlib/2q/#term' title="Hoon constant"><code>+$term</code></a>

774<a class="tooltip" href='/docs/hoon/reference/stdlib/2q/#term' title="Hoon constant"><code>+$term</code></a>

742<a class="tooltip" href='/docs/hoon/reference/stdlib/2n/#test' title="Test for equality"><code>++test</code></a>

775<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>

743<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#tidab' title="Parse 3 decimal digits"><code>++tid:ab</code></a>

777<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>

745<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#tilab' title="Parse 3 lowercase letters"><code>++til:ab</code></a>

779<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>

746<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#tipab' title="Leading phonetic byte"><code>++tip:ab</code></a>

781<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#tipab' title="Leading phonetic byte"><code>++tip:ab</code></a>

747<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#tiqab' title="Trailing phonetic syllable"><code>++tiq:ab</code></a>

782<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#tiqab' title="Trailing phonetic syllable"><code>++tiq:ab</code></a>

748<a class="tooltip" href='/docs/hoon/reference/stdlib/4h/#tis' title="Parse = (tis)"><code>++tis</code></a>

783<a class="tooltip" href='/docs/hoon/reference/stdlib/4h/#tis' title="Parse = (tis)"><code>++tis</code></a>

749<a class="tooltip" href='/docs/hoon/reference/stdlib/2k/#to' title="Queue operations"><code>++to</code></a>

784<a class="tooltip" href='/docs/hoon/reference/stdlib/2k/#to' title="Queue operations"><code>++to</code></a>

750<a class="tooltip" href='/docs/hoon/reference/stdlib/4a/#todpo' title="Fetch suffix"><code>++tod:po</code></a>

785<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>

752<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#toiff' title="Round IEEE float to nearest signed integer"><code>++toi:ff</code></a>

786<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#toiff' title="Round IEEE float to nearest signed integer"><code>++toi:ff</code></a>

753<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#toifl' title="Round float to nearest signed integer"><code>++toi:fl</code></a>

787<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#toifl' title="Round float to nearest signed integer"><code>++toi:fl</code></a>

754<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#toird' title="Round doubleprecision float to nearest signed integer"><code>++toi:rd</code></a>

788<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).

757<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#toirq' title="Round quadprecision float to nearest signed integer"><code>++toi:rq</code></a>

791<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#toirq' title="Round quadprecision float to nearest signed integer"><code>++toi:rq</code></a>

758<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#tojfl' title="Round unsigned and signed integer to float"><code>++toj:fl</code></a>

792<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#tojfl' title="Round unsigned and signed integer to float"><code>++toj:fl</code></a>

759<a class="tooltip" href='/docs/hoon/reference/stdlib/4a/#tokfa' title="Compute base58check checksum"><code>++tok:fa</code></a>

793<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>

760<a class="tooltip" href='/docs/hoon/reference/stdlib/3g/#tone' title="Nock result (error report)"><code>+$tone</code></a>

795<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>

761<a class="tooltip" href='/docs/hoon/reference/stdlib/3g/#toon' title="Nock result (stack trace)"><code>+$toon</code></a>

798<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>

762<a class="tooltip" href='/docs/hoon/reference/stdlib/2k/#topto' title="Produce head of queue"><code>++top:to</code></a>

800<a class="tooltip" href='/docs/hoon/reference/stdlib/2k/#topto' title="Produce head of queue"><code>++top:to</code></a>

763<a class="tooltip" href='/docs/hoon/reference/stdlib/4a/#tospo' title="Fetch prefix"><code>++tos:po</code></a>

801<a class="tooltip" href='/docs/hoon/reference/stdlib/4a/#tospo' title="Fetch prefix"><code>++tos:po</code></a>

764<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#tosrh' title="Convert halfprecision float to singleprecision float"><code>++tos:rh</code></a>

802<a class="tooltip" href='/docs/hoon/reference/stdlib/3b/#tosrh' title="Convert halfprecision float to singleprecision float"><code>++tos:rh</code></a>

765<a class="tooltip" href='/docs/hoon/reference/stdlib/2q/#tour' title="UTF-32 clusters"><code>+$tour</code></a>

803<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>

766<a class="tooltip" href='/docs/hoon/reference/stdlib/1c/#trap' title="Core with one arm $"><code>++trap</code></a>

805<a class="tooltip" href='/docs/hoon/reference/stdlib/1c/#trap' title="Core with one arm $"><code>++trap</code></a>

767<a class="tooltip" href='/docs/hoon/reference/stdlib/1c/#tree' title="Mold generator (tree)"><code>++tree</code></a>

806<a class="tooltip" href='/docs/hoon/reference/stdlib/1c/#tree' title="Mold generator (tree)"><code>++tree</code></a>

768<a class="tooltip" href='/docs/hoon/reference/stdlib/1c/#trel' title="Mold generator (tuple of three types)"><code>++trel</code></a>

807<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).

770<a class="tooltip" href='/docs/hoon/reference/stdlib/4b/#trip' title="Cord to tape"><code>++trip</code></a>

809<a class="tooltip" href='/docs/hoon/reference/stdlib/4b/#trip' title="Cord to tape"><code>++trip</code></a>

771<a class="tooltip" href='/docs/hoon/reference/stdlib/4b/#tuba' title="UTF8 to UTF32 tape"><code>++tuba</code></a>

810<a class="tooltip" href='/docs/hoon/reference/stdlib/4b/#tuba' title="UTF8 to UTF32 tape"><code>++tuba</code></a>

772<a class="tooltip" href='/docs/hoon/reference/stdlib/4b/#tufa' title="UTF32 to UTF8 tape"><code>++tufa</code></a>

811<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>

774<a class="tooltip" href='/docs/hoon/reference/stdlib/4b/#tuft' title="UTF32 to UTF8 text"><code>++tuft</code></a>

812<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>

775<a class="tooltip" href='/docs/hoon/reference/stdlib/2b/#turn' title="Gate to list"><code>++turn</code></a>

815<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>

777<a class="tooltip" href='/docs/hoon/reference/stdlib/4l/#twidso' title="Parse coins without ~ prefix"><code>++twid:so</code></a>

816<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>

817+<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>

818+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#typo' title="Old type"><code>+$typo</code></a>

780−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#tyre' title="List, term hoon"><code>++tyre</code></a>

819+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#tyre' title="List, term hoon"><code>+$tyre</code></a>

781

820

782### u

821### u

783

822

@@ -795,11 +834,14 @@ Can be navigated [alphabetically](#alphabetical) or [by section](#by-section).

795

834

796<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#vne' title="Render base 32"><code>++v:ne</code></a>

835<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#vne' title="Render base 32"><code>++v:ne</code></a>

797<code>++vang</code>

836<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>

799<code>++vast</code>

839<code>++vast</code>

800<a class="tooltip" href='/docs/hoon/reference/stdlib/4k/#v-coco' title="Render base-32 with minimum length"><code>++v-co:co</code></a>

840<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>

801<a class="tooltip" href='/docs/hoon/reference/stdlib/4i/#ven' title="Axis syntax parser"><code>++ven</code></a>

842<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>

803<a class="tooltip" href='/docs/hoon/reference/stdlib/4i/#vit' title="Parse base 64 digit"><code>++vit</code></a>

845<a class="tooltip" href='/docs/hoon/reference/stdlib/4i/#vit' title="Parse base 64 digit"><code>++vit</code></a>

804<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#vizag' title="Parse base 32 digit with dot separators"><code>++viz:ag</code></a>

846<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#vizag' title="Parse base 32 digit with dot separators"><code>++viz:ag</code></a>

805<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#voyab' title="Parse bas, soq, or bix"><code>++voy:ab</code></a>

847<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).

817<a class="tooltip" href='/docs/hoon/reference/stdlib/2b/#weld' title="Concatenate two lists"><code>++weld</code></a>

859<a class="tooltip" href='/docs/hoon/reference/stdlib/2b/#weld' title="Concatenate two lists"><code>++weld</code></a>

818<a class="tooltip" href='/docs/hoon/reference/stdlib/2m/#weldnl' title="Concatenate nullterminated nouns"><code>++weld:nl</code></a>

860<a class="tooltip" href='/docs/hoon/reference/stdlib/2m/#weldnl' title="Concatenate nullterminated nouns"><code>++weld:nl</code></a>

819<a class="tooltip" href='/docs/hoon/reference/stdlib/2b/#welp' title="Perfect concatenate (lists)"><code>++welp</code></a>

861<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>

820<a class="tooltip" href='/docs/hoon/reference/stdlib/4l/#whenso' title="Parse date"><code>++when:so</code></a>

863<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>

821<a class="tooltip" href='/docs/hoon/reference/stdlib/4b/#wick' title="Knot unescape"><code>++wick</code></a>

865<a class="tooltip" href='/docs/hoon/reference/stdlib/4b/#wick' title="Knot unescape"><code>++wick</code></a>

822<a class="tooltip" href='/docs/hoon/reference/stdlib/4c/#winre' title="Render at indent"><code>++win:re</code></a>

866<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>

824<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#wizag' title="Parse base 64 number"><code>++wiz:ag</code></a>

868<a class="tooltip" href='/docs/hoon/reference/stdlib/4j/#wizag' title="Parse base 64 number"><code>++wiz:ag</code></a>

825<a class="tooltip" href='/docs/hoon/reference/stdlib/4b/#woad' title="Unescape cord"><code>++woad</code></a>

869<a class="tooltip" href='/docs/hoon/reference/stdlib/4b/#woad' title="Unescape cord"><code>++woad</code></a>

826<a class="tooltip" href='/docs/hoon/reference/stdlib/4b/#wood' title="Escape cord"><code>++wood</code></a>

870<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>

827<a class="tooltip" href='/docs/hoon/reference/stdlib/3g/#wonk' title="Product from edge"><code>++wonk</code></a>

872<a class="tooltip" href='/docs/hoon/reference/stdlib/3g/#wonk' title="Product from edge"><code>++wonk</code></a>

828<a class="tooltip" href='/docs/hoon/reference/stdlib/3f/#wredun' title="Restore structure"><code>++wred:un</code></a>

873<a class="tooltip" href='/docs/hoon/reference/stdlib/3f/#wredun' title="Restore structure"><code>++wred:un</code></a>

829<a class="tooltip" href='/docs/hoon/reference/stdlib/3f/#wrenun' title="Conceal structure"><code>++wren:un</code></a>

874<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).

1766<a class="tooltip" href='/docs/hoon/reference/stdlib/4m/#spat' title="Render path as cord"><code>++spat</code></a>

1811<a class="tooltip" href='/docs/hoon/reference/stdlib/4m/#spat' title="Render path as cord"><code>++spat</code></a>

1767<a class="tooltip" href='/docs/hoon/reference/stdlib/4m/#spud' title="Render path as tape"><code>++spud</code></a>

1812<a class="tooltip" href='/docs/hoon/reference/stdlib/4m/#spud' title="Render path as tape"><code>++spud</code></a>

1768<a class="tooltip" href='/docs/hoon/reference/stdlib/4m/#stab' title="Parse cord to path"><code>++stab</code></a>

1813<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>

1769

1815

1770### 4n: parsing (virtualization)

1816### 4n: parsing (virtualization)

1771

1817

1772<a class="tooltip" href='/docs/hoon/reference/stdlib/4n/#mack' title="Nock subject to unit"><code>++mack</code></a>

1818<a class="tooltip" href='/docs/hoon/reference/stdlib/4n/#mack' title="Nock subject to unit"><code>++mack</code></a>

1773<a class="tooltip" href='/docs/hoon/reference/stdlib/4n/#mink' title="Mock (virtual Nock) interpreter"><code>++mink</code></a>

1819<a class="tooltip" href='/docs/hoon/reference/stdlib/4n/#mink' title="Mock (virtual Nock) interpreter"><code>++mink</code></a>

1774<a class="tooltip" href='/docs/hoon/reference/stdlib/4n/#mock' title="Compute formula on subject with hint"><code>++mock</code></a>

1820<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>

1776<a class="tooltip" href='/docs/hoon/reference/stdlib/4n/#mook' title="Intelligently render crash annotation"><code>++mook</code></a>

1821<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>

1777<a class="tooltip" href='/docs/hoon/reference/stdlib/4n/#mule' title="Typed virtual"><code>++mule</code></a>

1824<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>

1778<a class="tooltip" href='/docs/hoon/reference/stdlib/4n/#mute' title="Untyped virtual"><code>++mute</code></a>

1826<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>

1779

1829

1780### 4o: parsing (molds)

1830### 4o: parsing (molds)

1781

1831

1782−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#abel' title="Compiler alias"><code>++abel</code></a>

1832+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#abel' title="Original sin: type"><code>+$abel</code></a>

1783−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#aura' title="'Type' of atom"><code>++aura</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>

1784−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#base' title="Base type"><code>++base</code></a>

1836+<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>

1837+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#woof' title="Simple embed"><code>+$woof</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>

1838+<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>

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>

1789−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#foot' title="Cases of arms by variance model"><code>++foot</code></a>

1842+<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>

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>

1791−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#line' title="(Undocumented)"><code>++line</code></a>

1860+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#tope' title="Topographic type"><code>+$tope</code></a>

1792−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#metl' title="(Undocumented)"><code>++metl</code></a>

1861+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#hoot' title="Hoon tools"><code>++hoot</code></a>

1793−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#nock' title="Virtual machine (see Nock)"><code>++nock</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>

1794−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#null' title="(Undocumented)"><code>++null</code></a>

1864+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#manxhoot' title="Dynamic XML node"><code>+$manx:hoot</code></a>

1795−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#port' title="(Undocumented)"><code>++port</code></a>

1865+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#marlhoot' title="Dynamic XML nodes"><code>+$marl:hoot</code></a>

1796−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#span' title="ASCII atom"><code>++span</code></a>

1866+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#marthoot' title="Dynamic XML attributes"><code>+$mart:hoot</code></a>

1797−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#tiki' title="(Undocumented)"><code>++tiki</code></a>

1867+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#marxhoot' title="Dynamic XML tag"><code>+$marx:hoot</code></a>

1798−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#toga' title="Tree of faces"><code>++toga</code></a>

1868+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#marehoot' title="Node or nodes"><code>+$mare:hoot</code></a>

1799−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#tone'><code>+$tone</code></a>

1869+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#maruhoot' title="Interpolation or nodes"><code>+$maru:hoot</code></a>

1800−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#tuna' title="XML template tree"><code>++tuna</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>

1801−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#tusk' title="List of expressions"><code>++tusk</code></a>

1872+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#tyre' title="List, term hoon"><code>+$tyre</code></a>

1802−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#tyke' title="List of 'maybe' hoons"><code>++tyke</code></a>

1873+<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>

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>

1804−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#tyre' title="List, term hoon"><code>++tyre</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>

1805−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#vase' title="Typed data"><code>++vase</code></a>

1882+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#vase' title="Type-value pair"><code>+$vase</code></a>

1806−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#vise' title="Convert during reboot"><code>++vise</code></a>

1883+<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#vise' title="Old vase"><code>+$vise</code></a>

1807−<a class="tooltip" href='/docs/hoon/reference/stdlib/4o/#wing' title="Address in subject"><code>++wing</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>

1808

1897

1809### 5a: compiler utilities

1898### 5a: compiler utilities

1810

1899

lib/glossary.js+370−55

@@ -1403,7 +1403,7 @@ export const glossary = [

1403 desc: "Used in the Hoon standard library.",

1404 },

1405 {

1406− name: "Compiler alias",

1406+ name: "Original sin: type",

1407 symbol: "abel",

1408 usage: "stdlib",

1409 slug: "https://urbit.org/docs/reference/library/4o/#abel",

@@ -1493,6 +1493,13 @@ export const glossary = [

1493 slug: "https://urbit.org/docs/reference/library/4j/#ag",

1494 desc: "Used in the Hoon standard library.",

1495 },

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+ },

1496 {

1503 {

1497 name: "Parse alphabetic characters",

1504 name: "Parse alphabetic characters",

1498 symbol: "alf",

1505 symbol: "alf",

@@ -1584,6 +1591,13 @@ export const glossary = [

1584 slug: "https://urbit.org/docs/reference/library/4b/#at",

1591 slug: "https://urbit.org/docs/reference/library/4b/#at",

1585 desc: "Used in the Hoon standard library.",

1592 desc: "Used in the Hoon standard library.",

1586 },

1593 },

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+ },

1587 {

1601 {

1588 name: "'Type' of atom",

1602 name: "'Type' of atom",

1589 symbol: "aura",

1603 symbol: "aura",

@@ -1655,17 +1669,10 @@ export const glossary = [

1655 desc: "Used in the Hoon standard library.",

1669 desc: "Used in the Hoon standard library.",

1656 },

1670 },

1657 {

1671 {

1658− name: "Tape builder",

1672+ name: "Simple embed",

1659− symbol: "beer",

1673+ symbol: "beer:hoot",

1660 usage: "stdlib",

1674 usage: "stdlib",

1661− slug: "https://urbit.org/docs/reference/library/4o/#beer",

1675+ slug: "https://urbit.org/docs/reference/library/4o/#beerhoot",

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",

1669 desc: "Used in the Hoon standard library.",

1676 desc: "Used in the Hoon standard library.",

1670 },

1677 },

1671 {

1678 {

@@ -1787,6 +1794,13 @@ export const glossary = [

1787 slug: "https://urbit.org/docs/reference/library/4l/#biskso",

1794 slug: "https://urbit.org/docs/reference/library/4l/#biskso",

1788 desc: "Used in the Hoon standard library.",

1795 desc: "Used in the Hoon standard library.",

1789 },

1796 },

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+ },

1790 {

1804 {

1791 name: "Blocksize",

1805 name: "Blocksize",

1792 symbol: "bloq",

1806 symbol: "bloq",

@@ -2046,6 +2060,13 @@ export const glossary = [

2046 slug: "https://urbit.org/docs/reference/library/4b/#crip",

2060 slug: "https://urbit.org/docs/reference/library/4b/#crip",

2047 desc: "Used in the Hoon standard library.",

2061 desc: "Used in the Hoon standard library.",

2048 },

2062 },

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+ },

2049 {

2070 {

2050 name: "Parse @da, @dr, @p, @t",

2071 name: "Parse @da, @dr, @p, @t",

2051 symbol: "crub:so",

2072 symbol: "crub:so",

@@ -2347,6 +2368,13 @@ export const glossary = [

2347 slug: "https://urbit.org/docs/reference/library/2f/#dor",

2368 slug: "https://urbit.org/docs/reference/library/2f/#dor",

2348 desc: "Used in the Hoon standard library.",

2369 desc: "Used in the Hoon standard library.",

2349 },

2370 },

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+ },

2350 {

2378 {

2351 name: "Parse period",

2379 name: "Parse period",

2352 symbol: "dot",

2380 symbol: "dot",

@@ -2921,6 +2949,13 @@ export const glossary = [

2921 slug: "https://urbit.org/docs/reference/library/4h/#gar",

2949 slug: "https://urbit.org/docs/reference/library/4h/#gar",

2922 desc: "Used in the Hoon standard library.",

2950 desc: "Used in the Hoon standard library.",

2923 },

2951 },

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+ },

2924 {

2959 {

2925 name: "Concatenate (map)",

2960 name: "Concatenate (map)",

2926 symbol: "gas:by",

2961 symbol: "gas:by",

@@ -3236,6 +3271,13 @@ export const glossary = [

3236 slug: "https://urbit.org/docs/reference/library/4j/#hefab",

3271 slug: "https://urbit.org/docs/reference/library/4j/#hefab",

3237 desc: "Used in the Hoon standard library.",

3272 desc: "Used in the Hoon standard library.",

3238 },

3273 },

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+ },

3239 {

3281 {

3240 name: "Place-based apply",

3282 name: "Place-based apply",

3241 symbol: "here",

3283 symbol: "here",

@@ -3299,6 +3341,13 @@ export const glossary = [

3299 slug: "https://urbit.org/docs/reference/library/2b/#homo",

3341 slug: "https://urbit.org/docs/reference/library/2b/#homo",

3300 desc: "Used in the Hoon standard library.",

3342 desc: "Used in the Hoon standard library.",

3301 },

3343 },

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+ },

3302 {

3351 {

3303 name: "Seconds in hour",

3352 name: "Seconds in hour",

3304 symbol: "hor:yo",

3353 symbol: "hor:yo",

@@ -3306,6 +3355,13 @@ export const glossary = [

3306 slug: "https://urbit.org/docs/reference/library/3c/#horyo",

3355 slug: "https://urbit.org/docs/reference/library/3c/#horyo",

3307 desc: "Used in the Hoon standard library.",

3356 desc: "Used in the Hoon standard library.",

3308 },

3357 },

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+ },

3309 {

3365 {

3310 name: "Parse 1-4 @q phonetic pairs",

3366 name: "Parse 1-4 @q phonetic pairs",

3311 symbol: "huf:ab",

3367 symbol: "huf:ab",

@@ -3313,6 +3369,13 @@ export const glossary = [

3313 slug: "https://urbit.org/docs/reference/library/4j/#hufab",

3369 slug: "https://urbit.org/docs/reference/library/4j/#hufab",

3314 desc: "Used in the Hoon standard library.",

3370 desc: "Used in the Hoon standard library.",

3315 },

3371 },

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+ },

3316 {

3379 {

3317 name: "Select between two units by a rule",

3380 name: "Select between two units by a rule",

3318 symbol: "hunt",

3381 symbol: "hunt",

@@ -3615,10 +3678,10 @@ export const glossary = [

3615 desc: "Used in the Hoon standard library.",

3678 desc: "Used in the Hoon standard library.",

3616 },

3679 },

3617 {

3680 {

3618− name: "(Undocumented)",

3681+ name: "Lexical segment",

3619− symbol: "line",

3682+ symbol: "link",

3620 usage: "stdlib",

3683 usage: "stdlib",

3621− slug: "https://urbit.org/docs/reference/library/4o/#line",

3684+ slug: "https://urbit.org/docs/reference/library/4o/#link",

3622 desc: "Used in the Hoon standard library.",

3685 desc: "Used in the Hoon standard library.",

3623 },

3686 },

3624 {

3687 {

@@ -3831,6 +3894,20 @@ export const glossary = [

3831 slug: "https://urbit.org/docs/reference/library/2l/#malt",

3894 slug: "https://urbit.org/docs/reference/library/2l/#malt",

3832 desc: "Used in the Hoon standard library.",

3895 desc: "Used in the Hoon standard library.",

3833 },

3896 },

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+ },

3834 {

3911 {

3835 name: "Mold generator (map)",

3912 name: "Mold generator (map)",

3836 symbol: "map",

3913 symbol: "map",

@@ -3845,6 +3922,41 @@ export const glossary = [

3845 slug: "https://urbit.org/docs/reference/library/2i/#marby",

3922 slug: "https://urbit.org/docs/reference/library/2i/#marby",

3846 desc: "Used in the Hoon standard library.",

3923 desc: "Used in the Hoon standard library.",

3847 },

3924 },

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+ },

3848 {

3960 {

3849 name: "Address within head/tail",

3961 name: "Address within head/tail",

3850 symbol: "mas",

3962 symbol: "mas",

@@ -3915,13 +4027,6 @@ export const glossary = [

3915 slug: "https://urbit.org/docs/reference/library/2c/#met",

4027 slug: "https://urbit.org/docs/reference/library/2c/#met",

3916 desc: "Used in the Hoon standard library.",

4028 desc: "Used in the Hoon standard library.",

3917 },

4029 },

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− },

3925 {

4030 {

3926 name: "Minimum (atom)",

4031 name: "Minimum (atom)",

3927 symbol: "min",

4032 symbol: "min",

@@ -3957,6 +4062,13 @@ export const glossary = [

3957 slug: "https://urbit.org/docs/reference/library/4i/#mixed-case-symbol",

4062 slug: "https://urbit.org/docs/reference/library/4i/#mixed-case-symbol",

3958 desc: "Used in the Hoon standard library.",

4063 desc: "Used in the Hoon standard library.",

3959 },

4064 },

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+ },

3960 {

4072 {

3961 name: "Compute formula on subject with hint",

4073 name: "Compute formula on subject with hint",

3962 symbol: "mock",

4074 symbol: "mock",

@@ -3978,6 +4090,13 @@ export const glossary = [

3978 slug: "https://urbit.org/docs/reference/library/3c/#mohyo",

4090 slug: "https://urbit.org/docs/reference/library/3c/#mohyo",

3979 desc: "Used in the Hoon standard library.",

4091 desc: "Used in the Hoon standard library.",

3980 },

4092 },

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+ },

3981 {

4100 {

3982 name: "Map from pair list",

4101 name: "Map from pair list",

3983 symbol: "molt",

4102 symbol: "molt",

@@ -4111,6 +4230,13 @@ export const glossary = [

4111 slug: "https://urbit.org/docs/reference/library/4n/#mule",

4230 slug: "https://urbit.org/docs/reference/library/4n/#mule",

4112 desc: "Used in the Hoon standard library.",

4231 desc: "Used in the Hoon standard library.",

4113 },

4232 },

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+ },

4114 {

4240 {

4115 name: "Untyped virtual",

4241 name: "Untyped virtual",

4116 symbol: "mute",

4242 symbol: "mute",

@@ -4217,7 +4343,7 @@ export const glossary = [

4217 desc: "Used in the Hoon standard library.",

4343 desc: "Used in the Hoon standard library.",

4218 },

4344 },

4219 {

4345 {

4220− name: "Virtual machine (see Nock)",

4346+ name: "Virtual Nock",

4221 symbol: "nock",

4347 symbol: "nock",

4222 usage: "stdlib",

4348 usage: "stdlib",

4223 slug: "https://urbit.org/docs/reference/library/4o/#nock",

4349 slug: "https://urbit.org/docs/reference/library/4o/#nock",

@@ -4230,6 +4356,13 @@ export const glossary = [

4230 slug: "https://urbit.org/docs/reference/library/2d/#not",

4356 slug: "https://urbit.org/docs/reference/library/2d/#not",

4231 desc: "Used in the Hoon standard library.",

4357 desc: "Used in the Hoon standard library.",

4232 },

4358 },

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+ },

4233 {

4366 {

4234 name: "Any noun",

4367 name: "Any noun",

4235 symbol: "noun",

4368 symbol: "noun",

@@ -4252,7 +4385,7 @@ export const glossary = [

4252 desc: "Used in the Hoon standard library.",

4385 desc: "Used in the Hoon standard library.",

4253 },

4386 },

4254 {

4387 {

4255− name: "(Undocumented)",

4388+ name: "Null, nil, etc",

4256 symbol: "null",

4389 symbol: "null",

4257 usage: "stdlib",

4390 usage: "stdlib",

4258 slug: "https://urbit.org/docs/reference/library/4o/#null",

4391 slug: "https://urbit.org/docs/reference/library/4o/#null",

@@ -4286,6 +4419,20 @@ export const glossary = [

4286 slug: "https://urbit.org/docs/reference/library/3a/#oldsi",

4419 slug: "https://urbit.org/docs/reference/library/3a/#oldsi",

4287 desc: "Used in the Hoon standard library.",

4420 desc: "Used in the Hoon standard library.",

4288 },

4421 },

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+ },

4289 {

4436 {

4290 name: "Remove from list",

4437 name: "Remove from list",

4291 symbol: "oust",

4438 symbol: "oust",

@@ -4321,6 +4468,13 @@ export const glossary = [

4321 slug: "https://urbit.org/docs/reference/library/1c/#pair",

4468 slug: "https://urbit.org/docs/reference/library/1c/#pair",

4322 desc: "Used in the Hoon standard library.",

4469 desc: "Used in the Hoon standard library.",

4323 },

4470 },

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+ },

4324 {

4478 {

4325 name: "Parse & (pam)",

4479 name: "Parse & (pam)",

4326 symbol: "pam",

4480 symbol: "pam",

@@ -4398,6 +4552,13 @@ export const glossary = [

4398 slug: "https://urbit.org/docs/reference/library/4e/#pfix",

4552 slug: "https://urbit.org/docs/reference/library/4e/#pfix",

4399 desc: "Used in the Hoon standard library.",

4553 desc: "Used in the Hoon standard library.",

4400 },

4554 },

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+ },

4401 {

4562 {

4402 name: "Parsing range",

4563 name: "Parsing range",

4403 symbol: "pint",

4564 symbol: "pint",

@@ -4419,6 +4580,13 @@ export const glossary = [

4419 slug: "https://urbit.org/docs/reference/library/4j/#piwab",

4580 slug: "https://urbit.org/docs/reference/library/4j/#piwab",

4420 desc: "Used in the Hoon standard library.",

4581 desc: "Used in the Hoon standard library.",

4421 },

4582 },

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+ },

4422 {

4590 {

4423 name: "Parse to tuple",

4591 name: "Parse to tuple",

4424 symbol: "plug",

4592 symbol: "plug",

@@ -4440,6 +4608,13 @@ export const glossary = [

4440 slug: "https://urbit.org/docs/reference/library/4a/#po",

4608 slug: "https://urbit.org/docs/reference/library/4a/#po",

4441 desc: "Used in the Hoon standard library.",

4609 desc: "Used in the Hoon standard library.",

4442 },

4610 },

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+ },

4443 {

4618 {

4444 name: "Mold generator of faceless list",

4619 name: "Mold generator of faceless list",

4445 symbol: "pole",

4620 symbol: "pole",

@@ -4448,7 +4623,14 @@ export const glossary = [

4448 desc: "Used in the Hoon standard library.",

4623 desc: "Used in the Hoon standard library.",

4449 },

4624 },

4450 {

4625 {

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",

4452 symbol: "port",

4634 symbol: "port",

4453 usage: "stdlib",

4635 usage: "stdlib",

4454 slug: "https://urbit.org/docs/reference/library/4o/#port",

4636 slug: "https://urbit.org/docs/reference/library/4o/#port",

@@ -4755,6 +4937,13 @@ export const glossary = [

4755 slug: "https://urbit.org/docs/reference/library/2h/#repin",

4937 slug: "https://urbit.org/docs/reference/library/2h/#repin",

4756 desc: "Used in the Hoon standard library.",

4938 desc: "Used in the Hoon standard library.",

4757 },

4939 },

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+ },

4758 {

4947 {

4759 name: "Print loobean",

4948 name: "Print loobean",

4760 symbol: "rf:at",

4949 symbol: "rf:at",

@@ -5154,6 +5343,13 @@ export const glossary = [

5154 slug: "https://urbit.org/docs/reference/library/4j/#sebab",

5343 slug: "https://urbit.org/docs/reference/library/4j/#sebab",

5155 desc: "Used in the Hoon standard library.",

5344 desc: "Used in the Hoon standard library.",

5156 },

5345 },

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+ },

5157 {

5353 {

5158 name: "Parse non-zero decimal digit",

5354 name: "Parse non-zero decimal digit",

5159 symbol: "sed:ab",

5355 symbol: "sed:ab",

@@ -5448,6 +5644,13 @@ export const glossary = [

5448 slug: "https://urbit.org/docs/reference/library/2b/#skim",

5644 slug: "https://urbit.org/docs/reference/library/2b/#skim",

5449 desc: "Used in the Hoon standard library.",

5645 desc: "Used in the Hoon standard library.",

5450 },

5646 },

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+ },

5451 {

5654 {

5452 name: "Produce list of elements failing boolean gate",

5655 name: "Produce list of elements failing boolean gate",

5453 symbol: "skip",

5656 symbol: "skip",

@@ -5504,6 +5707,13 @@ export const glossary = [

5504 slug: "https://urbit.org/docs/reference/library/4f/#slug",

5707 slug: "https://urbit.org/docs/reference/library/4f/#slug",

5505 desc: "Used in the Hoon standard library.",

5708 desc: "Used in the Hoon standard library.",

5506 },

5709 },

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+ },

5507 {

5717 {

5508 name: "Render path as tank",

5718 name: "Render path as tank",

5509 symbol: "smyt",

5719 symbol: "smyt",

@@ -5546,6 +5756,13 @@ export const glossary = [

5546 slug: "https://urbit.org/docs/reference/library/4l/#so",

5756 slug: "https://urbit.org/docs/reference/library/4l/#so",

5547 desc: "Used in the Hoon standard library.",

5757 desc: "Used in the Hoon standard library.",

5548 },

5758 },

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+ },

5549 {

5766 {

5550 name: "Wrap value in unit",

5767 name: "Wrap value in unit",

5551 symbol: "some",

5768 symbol: "some",

@@ -5595,13 +5812,6 @@ export const glossary = [

5595 slug: "https://urbit.org/docs/reference/library/4i/#soz",

5812 slug: "https://urbit.org/docs/reference/library/4i/#soz",

5596 desc: "Used in the Hoon standard library.",

5813 desc: "Used in the Hoon standard library.",

5597 },

5814 },

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− },

5605 {

5815 {

5606 name: "Render path as cord",

5816 name: "Render path as cord",

5607 symbol: "spat",

5817 symbol: "spat",

@@ -5616,6 +5826,13 @@ export const glossary = [

5616 slug: "https://urbit.org/docs/reference/library/3b/#spdfl",

5826 slug: "https://urbit.org/docs/reference/library/3b/#spdfl",

5617 desc: "Used in the Hoon standard library.",

5827 desc: "Used in the Hoon standard library.",

5618 },

5828 },

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+ },

5619 {

5836 {

5620 name: "Gate to list (with state)",

5837 name: "Gate to list (with state)",

5621 symbol: "spin",

5838 symbol: "spin",

@@ -5714,6 +5931,13 @@ export const glossary = [

5714 slug: "https://urbit.org/docs/reference/library/4f/#stag",

5931 slug: "https://urbit.org/docs/reference/library/4f/#stag",

5715 desc: "Used in the Hoon standard library.",

5932 desc: "Used in the Hoon standard library.",

5716 },

5933 },

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+ },

5717 {

5941 {

5718 name: "Produce list of matches",

5942 name: "Produce list of matches",

5719 symbol: "star",

5943 symbol: "star",

@@ -6015,6 +6239,13 @@ export const glossary = [

6015 slug: "https://urbit.org/docs/reference/library/4l/#tashso",

6239 slug: "https://urbit.org/docs/reference/library/4l/#tashso",

6016 desc: "Used in the Hoon standard library.",

6240 desc: "Used in the Hoon standard library.",

6017 },

6241 },

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+ },

6018 {

6249 {

6019 name: "Parse ` (tic)",

6250 name: "Parse ` (tic)",

6020 symbol: "tic",

6251 symbol: "tic",

@@ -6022,6 +6253,13 @@ export const glossary = [

6022 slug: "https://urbit.org/docs/reference/library/4h/#tic",

6253 slug: "https://urbit.org/docs/reference/library/4h/#tic",

6023 desc: "Used in the Hoon standard library.",

6254 desc: "Used in the Hoon standard library.",

6024 },

6255 },

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+ },

6025 {

6263 {

6026 name: "Parse 1-999 decimal",

6264 name: "Parse 1-999 decimal",

6027 symbol: "ted:ab",

6265 symbol: "ted:ab",

@@ -6036,6 +6274,13 @@ export const glossary = [

6036 slug: "https://urbit.org/docs/reference/library/4b/#teff",

6274 slug: "https://urbit.org/docs/reference/library/4b/#teff",

6037 desc: "Used in the Hoon standard library.",

6275 desc: "Used in the Hoon standard library.",

6038 },

6276 },

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+ },

6039 {

6284 {

6040 name: "Parse non-doz leading phonetic byte",

6285 name: "Parse non-doz leading phonetic byte",

6041 symbol: "tep:ab",

6286 symbol: "tep:ab",

@@ -6072,7 +6317,7 @@ export const glossary = [

6072 desc: "Used in the Hoon standard library.",

6317 desc: "Used in the Hoon standard library.",

6073 },

6318 },

6074 {

6319 {

6075− name: "(Undocumented)",

6320+ name: "Test case",

6076 symbol: "tiki",

6321 symbol: "tiki",

6077 usage: "stdlib",

6322 usage: "stdlib",

6078 slug: "https://urbit.org/docs/reference/library/4o/#tiki",

6323 slug: "https://urbit.org/docs/reference/library/4o/#tiki",

@@ -6120,13 +6365,6 @@ export const glossary = [

6120 slug: "https://urbit.org/docs/reference/library/4a/#todpo",

6365 slug: "https://urbit.org/docs/reference/library/4a/#todpo",

6121 desc: "Used in the Hoon standard library.",

6366 desc: "Used in the Hoon standard library.",

6122 },

6367 },

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− },

6130 {

6368 {

6131 name: "Round IEEE float to nearest signed integer",

6369 name: "Round IEEE float to nearest signed integer",

6132 symbol: "toi:ff",

6370 symbol: "toi:ff",

@@ -6183,6 +6421,13 @@ export const glossary = [

6183 slug: "https://urbit.org/docs/reference/library/4a/#tokfa",

6421 slug: "https://urbit.org/docs/reference/library/4a/#tokfa",

6184 desc: "Used in the Hoon standard library.",

6422 desc: "Used in the Hoon standard library.",

6185 },

6423 },

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+ },

6186 {

6431 {

6187 name: "Nock result (error report)",

6432 name: "Nock result (error report)",

6188 symbol: "tone",

6433 symbol: "tone",

@@ -6190,6 +6435,20 @@ export const glossary = [

6190 slug: "https://urbit.org/docs/reference/library/3g/#tone",

6435 slug: "https://urbit.org/docs/reference/library/3g/#tone",

6191 desc: "Used in the Hoon standard library.",

6436 desc: "Used in the Hoon standard library.",

6192 },

6437 },

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+ },

6193 {

6452 {

6194 name: "Nock result (stack trace)",

6453 name: "Nock result (stack trace)",

6195 symbol: "toon",

6454 symbol: "toon",

@@ -6204,6 +6463,13 @@ export const glossary = [

6204 slug: "https://urbit.org/docs/reference/library/2k/#topto",

6463 slug: "https://urbit.org/docs/reference/library/2k/#topto",

6205 desc: "Used in the Hoon standard library.",

6464 desc: "Used in the Hoon standard library.",

6206 },

6465 },

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+ },

6207 {

6473 {

6208 name: "Fetch prefix",

6474 name: "Fetch prefix",

6209 symbol: "tos:po",

6475 symbol: "tos:po",

@@ -6275,31 +6541,31 @@ export const glossary = [

6275 desc: "Used in the Hoon standard library.",

6541 desc: "Used in the Hoon standard library.",

6276 },

6542 },

6277 {

6543 {

6278− name: "XML template tree",

6544+ name: "UTF-32 to UTF-8 text",

6279− symbol: "tuna",

6545+ symbol: "tuft",

6280 usage: "stdlib",

6546 usage: "stdlib",

6281− slug: "https://urbit.org/docs/reference/library/4o/#tuna",

6547+ slug: "https://urbit.org/docs/reference/library/4b/#tuft",

6282 desc: "Used in the Hoon standard library.",

6548 desc: "Used in the Hoon standard library.",

6283 },

6549 },

6284 {

6550 {

6285− name: "UTF-32 to UTF-8 text",

6551+ name: "Maybe interpolation",

6286− symbol: "tuft",

6552+ symbol: "tuna:hoot",

6287 usage: "stdlib",

6553 usage: "stdlib",

6288− slug: "https://urbit.org/docs/reference/library/4b/#tuft",

6554+ slug: "https://urbit.org/docs/reference/library/4o/#tunahoot",

6289 desc: "Used in the Hoon standard library.",

6555 desc: "Used in the Hoon standard library.",

6290 },

6556 },

6291 {

6557 {

6292− name: "Gate to list",

6558+ name: "Complex",

6293− symbol: "turn",

6559+ symbol: "tune",

6294 usage: "stdlib",

6560 usage: "stdlib",

6295− slug: "https://urbit.org/docs/reference/library/2b/#turn",

6561+ slug: "https://urbit.org/docs/reference/library/4o/#tune",

6296 desc: "Used in the Hoon standard library.",

6562 desc: "Used in the Hoon standard library.",

6297 },

6563 },

6298 {

6564 {

6299− name: "List of expressions",

6565+ name: "Gate to list",

6300− symbol: "tusk",

6566+ symbol: "turn",

6301 usage: "stdlib",

6567 usage: "stdlib",

6302− slug: "https://urbit.org/docs/reference/library/4o/#tusk",

6568+ slug: "https://urbit.org/docs/reference/library/2b/#turn",

6303 desc: "Used in the Hoon standard library.",

6569 desc: "Used in the Hoon standard library.",

6304 },

6570 },

6305 {

6571 {

@@ -6317,7 +6583,14 @@ export const glossary = [

6317 desc: "Used in the Hoon standard library.",

6583 desc: "Used in the Hoon standard library.",

6318 },

6584 },

6319 {

6585 {

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",

6321 symbol: "typo",

6594 symbol: "typo",

6322 usage: "stdlib",

6595 usage: "stdlib",

6323 slug: "https://urbit.org/docs/reference/library/4o/#typo",

6596 slug: "https://urbit.org/docs/reference/library/4o/#typo",

@@ -6401,7 +6674,14 @@ export const glossary = [

6401 desc: "Used in the Hoon standard library.",

6674 desc: "Used in the Hoon standard library.",

6402 },

6675 },

6403 {

6676 {

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",

6405 symbol: "vase",

6685 symbol: "vase",

6406 usage: "stdlib",

6686 usage: "stdlib",

6407 slug: "https://urbit.org/docs/reference/library/4o/#vase",

6687 slug: "https://urbit.org/docs/reference/library/4o/#vase",

@@ -6414,6 +6694,13 @@ export const glossary = [

6414 slug: "https://urbit.org/docs/reference/library/4k/#v-coco",

6694 slug: "https://urbit.org/docs/reference/library/4k/#v-coco",

6415 desc: "Used in the Hoon standard library.",

6695 desc: "Used in the Hoon standard library.",

6416 },

6696 },

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+ },

6417 {

6704 {

6418 name: "Axis syntax parser",

6705 name: "Axis syntax parser",

6419 symbol: "ven",

6706 symbol: "ven",

@@ -6422,7 +6709,14 @@ export const glossary = [

6422 desc: "Used in the Hoon standard library.",

6709 desc: "Used in the Hoon standard library.",

6423 },

6710 },

6424 {

6711 {

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",

6426 symbol: "vise",

6720 symbol: "vise",

6427 usage: "stdlib",

6721 usage: "stdlib",

6428 slug: "https://urbit.org/docs/reference/library/4o/#vise",

6722 slug: "https://urbit.org/docs/reference/library/4o/#vise",

@@ -6526,6 +6820,20 @@ export const glossary = [

6526 slug: "https://urbit.org/docs/reference/library/2b/#welp",

6820 slug: "https://urbit.org/docs/reference/library/2b/#welp",

6527 desc: "Used in the Hoon standard library.",

6821 desc: "Used in the Hoon standard library.",

6528 },

6822 },

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+ },

6529 {

6837 {

6530 name: "Knot unescape",

6838 name: "Knot unescape",

6531 symbol: "wick",

6839 symbol: "wick",

@@ -6541,7 +6849,7 @@ export const glossary = [

6541 desc: "Used in the Hoon standard library.",

6849 desc: "Used in the Hoon standard library.",

6542 },

6850 },

6543 {

6851 {

6544− name: "Address in subject",

6852+ name: "Address in subject - search path",

6545 symbol: "wing",

6853 symbol: "wing",

6546 usage: "stdlib",

6854 usage: "stdlib",

6547 slug: "https://urbit.org/docs/reference/library/4o/#wing",

6855 slug: "https://urbit.org/docs/reference/library/4o/#wing",

@@ -6568,6 +6876,13 @@ export const glossary = [

6568 slug: "https://urbit.org/docs/reference/library/4b/#wood",

6876 slug: "https://urbit.org/docs/reference/library/4b/#wood",

6569 desc: "Used in the Hoon standard library.",

6877 desc: "Used in the Hoon standard library.",

6570 },

6878 },

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+ },

6571 {

6886 {

6572 name: "Product from edge",

6887 name: "Product from edge",

6573 symbol: "wonk",

6888 symbol: "wonk",