ilyakooo0/urbit
1
0
Fork 0
mirror of https://github.com/ilyakooo0/urbit.git synced 2024-12-15 10:02:47 +03:00
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/test' into typedclay

Browse Source 
Conflicts:
	urb/urbit.pill
	urb/zod/main/app/helm/core.hook
	urb/zod/main/arvo/ford.hoon
This commit is contained in:
Philip C Monk 2015-04-23 20:46:25 -04:00
commit ca788cac3c
64 changed files with 1629 additions and 1387 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

48
main/app/helm/core.hook
View File

@ -114,8 +114,8 @@
::
++ he-wish-reset
^+ .
=- %_(+ moz (weld zum moz))
^= zum %- flop ^- (list move)
=- %_(+ moz (weld (flop zum) moz))
^- zum=(list move)
=+ top=`path`/(scot %p our.hid)/main/(scot %da lat.hid)/arvo
:- [ost %pass /reset %d %flog %vega (weld top `path`/hoon)]
%+ turn
@ -136,31 +136,25 @@
::
++ he-wish-reload
|= all=(list term)
%_ +>.$
moz
%- weld
:_ moz
%+ turn all
=+ ark=(arch .^(%cy /(scot %p our.hid)/main/(scot %da lat.hid)/arvo))
=+ van=(~(tap by r.ark))
|= nam=@tas
=. nam
?. =(1 (met 3 nam))
nam
=+ ^- zaz=(list ,[p=span ~])
(skim van |=([a=term ~] =(nam (end 3 1 a))))
?> ?=([[@ ~] ~] zaz)
`term`p.i.zaz
=+ tip=(end 3 1 nam)
=+ pax=[(scot %p our.hid) %main (scot %da lat.hid) %arvo nam %hoon ~]
:* ost
%pass
/reload
%d
%flog
[%veer ?:(=('z' tip) %$ tip) pax (,@ .^(%cx pax))]
==
==
=- %_(+ moz (weld (flop zum) moz))
^- zum=(list move)
=+ top=`path`/(scot %p our.hid)/main/(scot %da lat.hid)/arvo
%+ turn all
=+ ark=(arch .^(%cy /(scot %p our.hid)/main/(scot %da lat.hid)/arvo))
=+ van=(~(tap by r.ark))
|= nam=@tas
=. nam
?. =(1 (met 3 nam))
nam
=+ ^- zaz=(list ,[p=span ~])
(skim van |=([a=term ~] =(nam (end 3 1 a))))
?> ?=([[@ ~] ~] zaz)
`term`p.i.zaz
=+ tip=(end 3 1 nam)
=. tip ?:(=('z' tip) %$ tip)
=+ pax=`path`(welp top /[nam])
=+ txt=((hard ,@) .^(%cx (welp pax /hoon)))
[ost %pass /reload %d %flog %veer tip pax txt]
::
++ he-wish-sync
|= [syd=@tas her=@p sud=@tas ~]

17
main/app/sole/core.hook
View File

@ -556,6 +556,7 @@
^+ +>
?^ ris
(ta-ser txt)
:: ~& ven.say.inp
%- ta-hom(pos.inp (add (lent txt) pos.inp))
:- %mor
|- ^- (list sole-edit)
@ -573,18 +574,10 @@
=- [(add pos.inp (lent p.vew)) (weld (tuba p.vew) q.vew)]
^= vew ^- (pair tape (list ,@c))
?: vis.pom [cad.pom buf.say.inp]
:- ;: welp
cad.pom
?~ buf.say.inp ~
;: welp
"<"
(scow %p (end 4 1 (sham buf.say.inp)))
"> "
==
==
=+ len=(lent buf.say.inp)
|- ^- (list ,@c)
?:(=(0 len) ~ [`@c`'*' $(len (dec len))])
:- %+ welp cad.pom
?~ buf.say.inp ~
"<{(scow %p (end 4 1 (sham buf.say.inp)))}> "
(turn buf.say.inp ,_`@c`'*')
--
--
++ peer

8
main/app/talk/core.hook
View File

@ -1737,7 +1737,13 @@
|= oug=?
^- tape
?+ -.sep ""
%url (weld ": " (scag 62 (earn p.sep)))
%url
=+ txt=(earn p.sep)
%+ weld "/ "
?: (gte 62 (lent txt))
txt
(weld (scag 61 (earn p.sep)) "…")
::
%lin
=+ txt=(trip q.sep)
?: p.sep

25
main/arvo/eyre.hoon
View File

@ -102,10 +102,11 @@
-- ::
|% :: models
++ bolo :: eyre state
$: %0 :: version
$: %1 :: version
gub=@t :: random identity
hov=(unit ship) :: master for remote
ged=duct :: client interface
ded=(set duct) :: killed requests
pox=(map ,@uvH duct) :: proxied sessions
ask=[p=@ud q=(map ,@ud ,[p=duct q=hiss])] :: outgoing by number
kes=(map duct ,@ud) :: outgoing by duct
@ -443,7 +444,7 @@
::
%thud :: cancel request
:: ford-kill :: XX discriminate
+>.$
+>.$(ded (~(put in ded) hen))
::
%wart :: remote request
=+ mez=((soft gram) r.kyz)
@ -623,6 +624,8 @@
::
++ give-thou :: done request
|= hit=httr
?: (~(has in ded) hen) :: request closed
+>(ded (~(del in ded) hen))
+>(mow :_(mow [hen %give %thou hit]))
::
++ mean-json |=([sas=@uG err=ares] (give-json sas ~ (ares-to-json err)))
@ -1140,8 +1143,9 @@
=. eve (add-even ven)
=< abet
?~ ude done
:: ~& got-even/ude
(give-even(hen p.u.ude, ude ~) q.u.ude num ven)
=. hen p.u.ude
=. ..ix (pass-note of//[ire] [%t %rest era])
(give-even(ude ~) q.u.ude num ven)
::
++ give-even
|= [pol=? num=@u ven=even] ^+ done
@ -1165,7 +1169,7 @@
++ poll
|= a=@u ^+ ..ix
?: =(a p.eve)
?^ ude ~&(e/ix/wait/%replaced abet(u.ude [hen &]))
?^ ude ~&(e/ix/wait/replaced=p.u.ude abet(u.ude [hen &]))
=. era (add ~s30 now)
(pass-note:abet(ude [~ hen &]) of//[ire] [%t %wait era])
?: (gth a p.eve) ~|(seq-high/cur=p.eve !!)
@ -1219,10 +1223,15 @@
^- (unit ,@da)
~
::
++ load :: clam previous state
|= old=bolo ::_[.(wix **)]:*bolo
++ load :: take previous state
=+ bol0=*bolo
=> .(-.bol0 %0, |4.bol0 |5.bol0) :: missing ded
|= old=?(bolo _bol0)
^+ ..^$
..^$(+>- old) ::(wix ~))
?- -.old
%1 ..^$(+>- old)
%0 $(-.old %1, |4.old [*(set duct) |4.old])
==
::
++ scry
|= [our=(unit (set monk)) ren=@tas who=ship syd=desk lot=coin tyl=path]

4
main/arvo/ford.hoon
View File

@ -1,5 +1,5 @@
!:::::
:: :: %ford, new execution control
:: :: %ford, new execution control
!? 164
::::
|= pit=vase
@ -10,7 +10,7 @@
++ bead ,[p=(set beam) q=gage] :: computed result
++ gift :: out result <-$
$% [%made p=@uvH q=(each gage tang)] :: computed result
[%news ~] :: fresh depends
[%news ~] :: fresh depends
== ::
++ heel path :: functional ending
++ hock :: standard label

3
main/arvo/zuse.hoon
View File

@ -966,8 +966,9 @@
(add (div ~s1 2.000) (sub a ~1970.1.1))
::
++ jesc
=+ utf=|=(a=@ ['\\' 'u' ((x-co 4):co a)])
|= a=@ ^- tape
?+ a [a ~]
?+ a ?:((gth a 0x1f) [a ~] (utf a))
10 "\\n"
34 "\\\""
92 "\\\\"

2
main/lib/base.css
View File

@ -144,4 +144,4 @@ input {
#ship:focus,
input:focus {
background-color: #eee;
}
}

15
main/lib/sole/core.hook
View File

@ -32,8 +32,8 @@
:: for any sole state +>, obeys
::
:: =+ [x=(transmute a b) y=(transmute b a)]
:: .= (apply:(apply b) x)
:: (apply:(apply a) y)
:: .= (apply:(apply a) x)
:: (apply:(apply b) y)
::
++ transmute :: dex as after sin
|= [sin=sole-edit dex=sole-edit]
@ -65,7 +65,7 @@
?- -.dex
%del ?:((lte p.sin p.dex) dex(p +(p.dex)) dex)
%ins ?: =(p.sin p.dex)
?:((gth q.sin q.dex) dex dex(p +(p.dex)))
?:((lth q.sin q.dex) dex dex(p +(p.dex)))
?:((lte p.sin p.dex) dex(p +(p.dex)) dex)
==
==
@ -85,7 +85,8 @@
++ inverse :: relative inverse
|= ted=sole-edit
^- sole-edit
=. ted ?.(?=([%mor * ~] ted) ted i.p.ted)
:: =. ted ?.(?=([%mor * ~] ted) ted i.p.ted) :: XX why?
~| [ted abet]
?- -.ted
%del [%ins p.ted (snag p.ted buf)]
%ins [%del p.ted]
@ -102,13 +103,14 @@
++ receive :: naturalize event
|= sole-change
^- [sole-edit sole-share]
?> &(=(his.ler his.ven) (lte own.ler own.ven))
~| [ler ven]
?> &(=(his.ler his.ven) (lte own.ler own.ven))
?> |(!=(own.ler own.ven) =(haw (sham buf)) =(haw 0)) :: trust the clock
=. leg (scag (sub own.ven own.ler) leg)
:: ~? !=(own.ler own.ven) [%miss-leg leg]
=+ dat=(transmute [%mor leg] ted)
=+ dat=(transmute [%mor (flop leg)] ted)
:: ~? !=(~ leg) [%transmute from/ted to/dat ~]
:: =- ~& (tufa buf) -
[dat abet:(apply(his.ven +(his.ven)) dat)]
::
++ remit :: conditional accept
@ -124,6 +126,7 @@
++ transmit :: outgoing change
|= ted=sole-edit
^- [sole-change sole-share]
:: =- ~& (tufa buf) -
[[[his.ven own.ven] (sham buf) ted] (commit ted)]
::
++ transceive :: receive and invert

2
main/lib/urb.js
View File

@ -33,7 +33,7 @@ window.urb.req = function(method,url,params,json,cb) {
if(res.data.reload)
res.reload = res.data.reload
} catch(e) {
if(urb.wall || true) document.write(this.responseText) // XX
if(urb.wall !== false) document.write(this.responseText) // XX
err = {
message:"Failed to parse JSON",
raw:this.responseText

6
main/mar/react-snip/door.hook
View File

@ -53,6 +53,12 @@
")"
==
++ react-snip-js (crip tape)
++ react-snip-json
::?> ?=([[%div ~] [[%h1 ~] *] [[%div ~] *] ~]] own) :: xx mystery fish-loop
%^ jobe
head/(jape tape(own &2.own))
body/(jape tape(own &3.own))
~
:: ++ js react-snip-js :: convert to %js
++ mime [/text/javascript (taco react-snip-js)] :: convert to %mime
--

5
main/mar/sole-action/door.hook
View File

@ -14,8 +14,7 @@
|= jon=^json ^- sole-action
%- need %. jon
=> [jo ..sole-action]
|^ =- ~! (-) -
(fo %ret (of det/change ~))
|^ (fo %ret (of det/change ~))
++ fo
|* [a=term b=fist]
|=(c=json ?.(=([%s a] c) (b c) (some [a ~])))
@ -30,7 +29,7 @@
++ edit
%+ fo %nop
%+ ra mor/|=(json (edit +<))
(of del/ni set/(cu tuba sa) ins/(ot at/ni new/char ~) ~)
(of del/ni set/(cu tuba sa) ins/(ot at/ni cha/char ~) ~)
--
::
++ noun sole-action :: clam from %noun

18
main/mar/sole-effect/door.hook
View File

@ -14,20 +14,20 @@
^- ^json
=+ cha
=< (jobe ted/(. ted) ler/a/~[(jone own.ler) (jone his.ler)] ~)
|= ted=sole-edit
?- -.ted
|= det=sole-edit
?- -.det
%nop [%s 'nop']
%mor [%a (turn p.ted ..$)]
%del (joba %del (jone p.ted))
%set (joba %set (jape (tufa p.ted)))
%ins (joba %ins (jobe at/(jone p.ted) new/s/(tuft q.ted) ~))
%mor [%a (turn p.det ..$)]
%del (joba %del (jone p.det))
%set (joba %set (jape (tufa p.det)))
%ins (joba %ins (jobe at/(jone p.det) cha/s/(tuft q.det) ~))
==
--
--
++ wush
|= [wid=@u tan=tang]
^- tape
=+ rolt=|=(a=wall `tape`?~(a ~ :(weld i.a "\0a" $(a t.a))))
=+ rolt=|=(a=wall `tape`?~(a ~ ?~(t.a i.a :(weld i.a "\0a" $(a t.a)))))
(rolt (turn tan |=(a=tank (rolt (wash 0^wid a)))))
::
--
@ -47,8 +47,8 @@
%err (joba %hop (jone p.sef))
%txt (joba %txt (jape p.sef))
%tan (joba %tan (jape (wush 160 p.sef)))
%det json:~(grow mar-sole-change +.sef)
%pro (jobe vis/b/vis.sef tag/s/tag.sef cad/(jape cad.sef) ~)
%det (joba %det json:~(grow mar-sole-change +.sef))
%pro (joba %pro (jobe vis/b/vis.sef tag/s/tag.sef cad/(jape cad.sef) ~))
?(%bel %clr %nex) (joba %act %s -.sef)
==
--

4
main/pub/doc/hoon/library.md
View File

@ -1,4 +1,4 @@
Library
=======
========
<list dataPreview="true"></list>
<list dataPreview="true" titlesOnly="true"></list>

4
main/pub/doc/hoon/library/0.md
View File

@ -1,7 +1,7 @@
volume 0, Kelvin Versioning
volume 0, Kelvin Versioning.
===========================
### ++hoon
<h3 id="++hoon"><code>++hoon</code></h3>
++ hoon %164 :: version stub

200
main/pub/doc/hoon/library/1.md
View File

@ -3,7 +3,7 @@ volume 1, Hoon Structures
------------------------------------------------------------------------
### ++abel
<h3 id="++abel"><code>++abel</code></h3>
++ abel typo :: original sin: type
@ -16,7 +16,7 @@ See also: `++typo`
------------------------------------------------------------------------
### ++axis
<h3 id="++axis"><code>++axis</code></h3>
++ axis ,@ :: tree address
@ -36,7 +36,7 @@ See also: `++clue`, `++limb`, `++slot`, `++peg`, and Section 2fC
------------------------------------------------------------------------
### ++also
<h3 id="++also"><code>++also</code></h3>
++ also ,[p=term q=wing r=type] :: alias
@ -44,7 +44,7 @@ XX unused?
------------------------------------------------------------------------
### ++base
<h3 id="++base"><code>++base</code></h3>
++ base ?([%atom p=odor] %noun %cell %bean %null) :: axils, @ * ^ ? ~
@ -66,7 +66,7 @@ See also: `++tile`, `++twig`
------------------------------------------------------------------------
### ++bean
<h3 id="++bean"><code>++bean</code></h3>
++ bean ,? :: 0=&=yes, 1=|=no
@ -83,7 +83,7 @@ The Urbit version of a boolean, which we call a loobean. 0 or & is
------------------------------------------------------------------------
### ++beer
<h3 id="++beer"><code>++beer</code></h3>
++ beer $|(@ [~ p=twig]) :: simple embed
@ -98,7 +98,7 @@ See also: `++phax`, `++scat`, section 2fD
------------------------------------------------------------------------
### ++beet
<h3 id="++beet"><code>++beet</code></h3>
++ beet $| @ :: advanced embed
$% [%a p=twig] :: take tape
@ -114,7 +114,7 @@ See also: `++sail`, section 2fD
------------------------------------------------------------------------
### ++bloq
<h3 id="++bloq"><code>++bloq</code></h3>
++ bloq ,@ :: blockclass
@ -129,7 +129,7 @@ See also: section 2cA
------------------------------------------------------------------------
### ++calf
<h3 id="++calf"><code>++calf</code></h3>
++ calf ,[p=(map ,@ud wine) q=wine] ::
@ -150,7 +150,7 @@ See also: `++wine`, `++dole`, `++doge`, `++dish`, section 2fC
------------------------------------------------------------------------
### ++char
<h3 id="++char"><code>++char</code></h3>
++ char ,@tD :: UTF-8 byte
@ -167,7 +167,7 @@ See also: `++tape`, `++lust`, `++just`, `++mask`, chapter 2f
------------------------------------------------------------------------
### ++chub
<h3 id="++chub"><code>++chub</code></h3>
++ chub :: registered battery
$: p=(pair chum tyre) :: definition
@ -181,7 +181,7 @@ See also: Section 2fB.
------------------------------------------------------------------------
### ++chum
<h3 id="++chum"><code>++chum</code></h3>
++ chum $? lef=term :: jet name
[std=term kel=@] :: kelvin version
@ -205,7 +205,7 @@ See also: `++twig`, `++clue`
------------------------------------------------------------------------
### ++clue
<h3 id="++clue"><code>++clue</code></h3>
++ clue ,[p=axis q=chum r=tyre] :: battery definition
@ -217,7 +217,7 @@ See also: section 2fB
------------------------------------------------------------------------
### ++coil
<h3 id="++coil"><code>++coil</code></h3>
++ coil $: p=?(%gold %iron %lead %zinc) :: core type
q=type ::
@ -232,7 +232,7 @@ See also: `++core`, Section 2fB
------------------------------------------------------------------------
### ++coin
<h3 id="++coin"><code>++coin</code></h3>
++ coin $% [%$ p=dime] ::
[%blob p=*] ::
@ -264,7 +264,7 @@ See also: `++so`, `++co`, Section 2eL, `++dime`
------------------------------------------------------------------------
### ++cord
<h3 id="++cord"><code>++cord</code></h3>
++ cord ,@t :: text atom (UTF-8)
@ -287,7 +287,7 @@ See also: `++trip`, `++crip`, Section 2eJ
------------------------------------------------------------------------
### ++date
<h3 id="++date"><code>++date</code></h3>
++ date ,[[a=? y=@ud] m=@ud t=tarp] :: parsed date
@ -302,7 +302,7 @@ See also: `++year`, `++yore`, Section 2cH, `++stud`, `++dust`, Section
------------------------------------------------------------------------
### ++dime
<h3 id="++dime"><code>++dime</code></h3>
++ dime ,[p=@ta q=@] ::
@ -319,7 +319,7 @@ See also: `++so`, `++co`, Section 2eL, `++coin`
------------------------------------------------------------------------
### ++dram
<h3 id="++dram"><code>++dram</code></h3>
++ dram $% [| p=(map ,@tas dram)] :: simple unix dir
[& p=@ud q=@] ::
@ -333,7 +333,7 @@ XX Unused
------------------------------------------------------------------------
### ++each
<h3 id="++each"><code>++each</code></h3>
++ each |*([a=$+(* *) b=$+(* *)] $%([& p=a] [| p=b])) :: either a or b
@ -345,7 +345,7 @@ Tile generator: produces a dicriminated fork between two types.
------------------------------------------------------------------------
### ++edge
<h3 id="++edge"><code>++edge</code></h3>
++ edge ,[p=hair q=(unit ,[p=* q=nail])] :: parsing output
@ -360,7 +360,7 @@ See also: Section 2eD, `++rule`
------------------------------------------------------------------------
### ++foot
<h3 id="++foot"><code>++foot</code></h3>
++ foot $% [%ash p=twig] :: dry arm, geometric
[%elm p=twig] :: wet arm, generic
@ -386,7 +386,7 @@ See also: `++ap`, `++ut`, Section 2fB, Section 2fC
------------------------------------------------------------------------
### ++gate
<h3 id="++gate"><code>++gate</code></h3>
++ gate $+(* *) :: general gate
@ -407,7 +407,7 @@ See also: `++lift`, `++cork`, Core Language Doc
------------------------------------------------------------------------
### ++hair
<h3 id="++hair"><code>++hair</code></h3>
++ hair ,[p=@ud q=@ud] :: parsing trace
@ -427,7 +427,7 @@ See also: `++last`, Section 2eB
------------------------------------------------------------------------
### ++like
<h3 id="++like"><code>++like</code></h3>
++ like |* a=_,* :: generic edge
|= b=_`*`[(hair) ~] ::
@ -455,7 +455,7 @@ See also: `++easy`, `++just`/`++jest`, `++knee`, `++mask`, `++shim`,
------------------------------------------------------------------------
### ++limb
<h3 id="++limb"><code>++limb</code></h3>
++ limb $|(term $%([%& p=axis] [%| p=@ud q=term])) ::
@ -474,7 +474,7 @@ See also: section 2fC-2fD
------------------------------------------------------------------------
### ++line
<h3 id="++line"><code>++line</code></h3>
++ line ,[p=[%leaf p=odor q=@] q=tile] :: %kelp case
@ -501,7 +501,7 @@ Used in compilation and grammar, section 2fC-2fD
------------------------------------------------------------------------
### ++list
<h3 id="++list"><code>++list</code></h3>
++ list |* a=_,* :: null-term list
$|(~ [i=a t=(list a)]) ::
@ -520,7 +520,7 @@ See also: `++turn`, `++snag`, section 2bB.
------------------------------------------------------------------------
### ++lone
<h3 id="++lone"><code>++lone</code></h3>
++ lone |*(a=$+(* *) ,p=a) :: just one thing
@ -530,7 +530,7 @@ Tile generator. `++lone` puts face of `p` on something.
------------------------------------------------------------------------
### ++mane
<h3 id="++mane"><code>++mane</code></h3>
++ mane $|(@tas [@tas @tas]) :: XML name/space
@ -549,7 +549,7 @@ See also: `++sail` doc, Section 3bD
------------------------------------------------------------------------
### ++manx
<h3 id="++manx"><code>++manx</code></h3>
++ manx ,[g=marx c=marl] :: XML node
@ -561,7 +561,7 @@ See also: `++sail` doc, Section 3bD
------------------------------------------------------------------------
### ++marl
<h3 id="++marl"><code>++marl</code></h3>
++ marl (list manx) :: XML node list
@ -573,7 +573,7 @@ See also: `++sail` doc
------------------------------------------------------------------------
### ++mars
<h3 id="++mars"><code>++mars</code></h3>
++ mars ,[t=[n=%$ a=[i=[n=%$ v=tape] t=~]] c=~] :: XML cdata
@ -583,7 +583,7 @@ See also: `++sail` doc
------------------------------------------------------------------------
### ++mart
<h3 id="++mart"><code>++mart</code></h3>
++ mart (list ,[n=mane v=tape]) :: XML attributes
@ -596,7 +596,7 @@ See also: `++sail` doc
------------------------------------------------------------------------
### ++marx
<h3 id="++marx"><code>++marx</code></h3>
++ marx ,[n=mane a=mart] :: XML tag
@ -609,7 +609,7 @@ See also: `++sail` doc
------------------------------------------------------------------------
### ++metl
<h3 id="++metl"><code>++metl</code></h3>
++ metl ?(%gold %iron %zinc %lead) :: core variance
@ -619,7 +619,7 @@ See also: `++coil`
------------------------------------------------------------------------
### ++noun
<h3 id="++noun"><code>++noun</code></h3>
++ noun ,* :: any noun
@ -630,7 +630,7 @@ Used nowhere XX
------------------------------------------------------------------------
### ++null
<h3 id="++null"><code>++null</code></h3>
++ null ,~ :: null, nil, etc
@ -642,7 +642,7 @@ Used nowhere XX
------------------------------------------------------------------------
### ++odor
<h3 id="++odor"><code>++odor</code></h3>
++ odor ,@ta :: atom format
@ -657,7 +657,7 @@ See also: `++base`, odor reference
------------------------------------------------------------------------
### ++tarp
<h3 id="++tarp"><code>++tarp</code></h3>
++ tarp ,[d=@ud h=@ud m=@ud s=@ud f=(list ,@ux)] :: parsed time
@ -677,7 +677,7 @@ See also: `++date`, `++yell`/`++yule`, Section 2cH
------------------------------------------------------------------------
### ++time
<h3 id="++time"><code>++time</code></h3>
++ time ,@da :: galactic time
@ -693,7 +693,7 @@ See also: `++date`, odor reference
------------------------------------------------------------------------
### ++tree
<h3 id="++tree"><code>++tree</code></h3>
++ tree |* a=_,* :: binary tree
$|(~ [n=a l=(tree a) r=(tree a)]) ::
@ -706,7 +706,7 @@ left/right sub `++tree`s of the same type. Pretty-printed with `{}`.
------------------------------------------------------------------------
### ++nail
<h3 id="++nail"><code>++nail</code></h3>
++ nail ,[p=hair q=tape] :: parsing input
@ -721,7 +721,7 @@ See also: `++roll`
------------------------------------------------------------------------
### ++numb
<h3 id="++numb"><code>++numb</code></h3>
++ numb ,@ :: just a number
@ -729,7 +729,7 @@ Used nowhere XX
------------------------------------------------------------------------
### ++pair
<h3 id="++pair"><code>++pair</code></h3>
++ pair |*([a=$+(* *) b=$+(* *)] ,[p=a q=b]) :: just a pair
@ -740,7 +740,7 @@ Tile generator. Produces a tuple of two of the types passed in.
------------------------------------------------------------------------
### ++pass
<h3 id="++pass"><code>++pass</code></h3>
++ pass ,@ :: public key
@ -750,7 +750,7 @@ See also: `++acru`, `++crua`, `++crub`
------------------------------------------------------------------------
### ++path
<h3 id="++path"><code>++path</code></h3>
++ path (list span) :: filesys location
@ -762,7 +762,7 @@ A filesystem path. A `++path` is a list of `++span`, `@ta`. Used in
------------------------------------------------------------------------
### ++pint
<h3 id="++pint"><code>++pint</code></h3>
++ pint ,[p=[p=@ q=@] q=[p=@ q=@]] :: line/column range
@ -777,7 +777,7 @@ hairs indicating from - to.
------------------------------------------------------------------------
### ++pole
<h3 id="++pole"><code>++pole</code></h3>
++ pole |* a=_,* :: nameless list
$|(~ [a (pole a)]) ::
@ -790,7 +790,7 @@ without the `i=` and `t=`.
------------------------------------------------------------------------
### ++port
<h3 id="++port"><code>++port</code></h3>
++ port $: p=axis ::
$= q ::
@ -808,7 +808,7 @@ Type and location of core-shaped thing? XX Compiler Internals
------------------------------------------------------------------------
### ++post
<h3 id="++post"><code>++post</code></h3>
++ post $: p=axis ::
$= q ::
@ -827,7 +827,7 @@ Type and location of possibly core-shaped thing? XX Compiler Internals
------------------------------------------------------------------------
### ++prop
<h3 id="++prop"><code>++prop</code></h3>
++ prop $: p=axis ::
$= q ::
@ -843,7 +843,7 @@ Verified core-shaped thing? XX Compiler Internals
------------------------------------------------------------------------
### ++qual
<h3 id="++qual"><code>++qual</code></h3>
++ qual |* [a=$+(* *) b=$+(* *) c=$+(* *) d=$+(* *)] :: just a quadruple
,[p=a q=b r=c s=d] ::
@ -855,7 +855,7 @@ Tile generator. A `++qual` is a tuple of four of the types passed in..
------------------------------------------------------------------------
### ++rege
<h3 id="++rege"><code>++rege</code></h3>
++ rege $| ?(%dote %ende %sart %empt %boun %bout) :: parsed regex
$% [%lite p=char] :: literal
@ -885,7 +885,7 @@ See also: `++rexp`, `++repg`, `++pars`
------------------------------------------------------------------------
### ++ring
<h3 id="++ring"><code>++ring</code></h3>
++ ring ,@ :: private key
@ -895,7 +895,7 @@ See also: `++acru`, `++crua`, `++crub`.
------------------------------------------------------------------------
### ++rule
<h3 id="++rule"><code>++rule</code></h3>
++ rule |=(tub=nail `edge`[p.tub ~ ~ tub]) :: parsing rule
@ -916,7 +916,7 @@ See also: `++cold`, Section 2eC
------------------------------------------------------------------------
### ++span
<h3 id="++span"><code>++span</code></h3>
++ span ,@ta :: text-atom (ASCII)
@ -941,7 +941,7 @@ besides numbers and lowercase letters are permitted.
------------------------------------------------------------------------
### ++spot
<h3 id="++spot"><code>++spot</code></h3>
++ spot ,[p=path q=pint] :: range in file
@ -957,7 +957,7 @@ See also: `++pint`
------------------------------------------------------------------------
### ++tang
<h3 id="++tang"><code>++tang</code></h3>
++ tang (list tank) :: general error
@ -965,7 +965,7 @@ Unused XX
------------------------------------------------------------------------
### ++tank
<h3 id="++tank"><code>++tank</code></h3>
++ tank $% [%leaf p=tape] :: printing formats
$: %palm ::
@ -996,7 +996,7 @@ list of `++tank` delimted by the strings in `p`.
------------------------------------------------------------------------
### ++tape
<h3 id="++tape"><code>++tape</code></h3>
++ tape (list char) :: like a string
@ -1010,7 +1010,7 @@ list of chars.
------------------------------------------------------------------------
### ++term
<h3 id="++term"><code>++term</code></h3>
++ term ,@tas :: Hoon ASCII subset
@ -1030,7 +1030,7 @@ always preceded by `%`. This means a term is always cubical. The empty
------------------------------------------------------------------------
### ++tiki
<h3 id="++tiki"><code>++tiki</code></h3>
++ tiki :: test case
$% [& p=(unit term) q=wing] :: simple wing
@ -1062,13 +1062,13 @@ A `++wing` or `++twig`.
------------------------------------------------------------------------
### ++tile
<h3 id="++tile"><code>++tile</code></h3>
See the Tile section of the Hoon Reference.
------------------------------------------------------------------------
### ++toga
<h3 id="++toga"><code>++toga</code></h3>
++ toga :: face control
$| p=term :: two togas
@ -1104,7 +1104,7 @@ using `^=`.
------------------------------------------------------------------------
### ++trap
<h3 id="++trap"><code>++trap</code></h3>
++ trap ,_|.(_*) :: makes perfect sense
@ -1121,7 +1121,7 @@ See also: `|.`
------------------------------------------------------------------------
### ++trel
<h3 id="++trel"><code>++trel</code></h3>
++ trel |* [a=$+(* *) b=$+(* *) c=$+(* *)] :: just a triple
,[p=a q=b r=c] ::
@ -1133,7 +1133,7 @@ Tile generator. `++trel` is a tuple of three of the types passed in.
------------------------------------------------------------------------
### ++tuna
<h3 id="++tuna"><code>++tuna</code></h3>
++ tuna :: tagflow
$% [%a p=twig] :: plain text
@ -1154,13 +1154,13 @@ See also: `++sail`
------------------------------------------------------------------------
### ++twig
<h3 id="++twig"><code>++twig</code></h3>
See Twig section of Hoon reference
------------------------------------------------------------------------
### ++tine
<h3 id="++tine"><code>++tine</code></h3>
++ tine (list ,[p=tile q=twig]) ::
@ -1186,7 +1186,7 @@ See also: `++twig`
------------------------------------------------------------------------
### ++tusk
<h3 id="++tusk"><code>++tusk</code></h3>
++ tusk (list twig) ::
@ -1202,7 +1202,7 @@ See also: `++twig`
------------------------------------------------------------------------
### ++tyre
<h3 id="++tyre"><code>++tyre</code></h3>
++ tyre (list ,[p=term q=twig]) ::
@ -1212,7 +1212,7 @@ See also: `++twig`
------------------------------------------------------------------------
### ++tyke
<h3 id="++tyke"><code>++tyke</code></h3>
++ tyke (list (unit twig)) ::
@ -1227,7 +1227,7 @@ where the `=` are inferred from your current path.
------------------------------------------------------------------------
### ++tram
<h3 id="++tram"><code>++tram</code></h3>
++ tram (list ,[p=wing q=twig]) ::
@ -1246,7 +1246,7 @@ See also: `++twig`
------------------------------------------------------------------------
### ++nock
<h3 id="++nock"><code>++nock</code></h3>
++ nock $& [p=nock q=nock] :: autocons
$% [%0 p=@] :: axis select
@ -1272,7 +1272,7 @@ See Nock doc
------------------------------------------------------------------------
### ++tone
<h3 id="++tone"><code>++tone</code></h3>
++ tone $% [%0 p=*] :: success
[%1 p=(list)] :: blocks
@ -1314,7 +1314,7 @@ trace is not yet rendered.
------------------------------------------------------------------------
### ++toon
<h3 id="++toon"><code>++toon</code></h3>
++ toon $% [%0 p=*] :: success
[%1 p=(list)] :: blocks
@ -1337,7 +1337,7 @@ requests blocked on (`%1`), or failure with stack trace (`%2`).
------------------------------------------------------------------------
### ++tune
<h3 id="++tune"><code>++tune</code></h3>
++ tune $% [%0 p=vase] ::
[%1 p=(list)] ::
@ -1350,7 +1350,7 @@ Probably typed `tone`?
------------------------------------------------------------------------
### ++twin
<h3 id="++twin"><code>++twin</code></h3>
++ twin ,[p=term q=wing r=axis s=type] :: alias info
@ -1368,13 +1368,13 @@ Aliasing. Used in `%bull` `++type` to typecheck aliased faces.
------------------------------------------------------------------------
### ++type
<h3 id="++type"><code>++type</code></h3>
See Type section of Hoon reference
------------------------------------------------------------------------
### ++typo
<h3 id="++typo"><code>++typo</code></h3>
++ typo type :: old type
@ -1385,7 +1385,7 @@ See also: `++seem`, `++vise`, `++type`
------------------------------------------------------------------------
### ++udal
<h3 id="++udal"><code>++udal</code></h3>
++ udal :: atomic change (%b)
$: p=@ud :: blockwidth
@ -1396,7 +1396,7 @@ XX Unused
------------------------------------------------------------------------
### ++udon
<h3 id="++udon"><code>++udon</code></h3>
++ udon :: abstract delta
$: p=umph :: preprocessor
@ -1412,7 +1412,7 @@ See `%clay` doc
------------------------------------------------------------------------
### ++umph
<h3 id="++umph"><code>++umph</code></h3>
++ umph :: change filter
$| $? %a :: no filter
@ -1426,7 +1426,7 @@ See `%clay` doc
------------------------------------------------------------------------
### ++unce
<h3 id="++unce"><code>++unce</code></h3>
++ unce |* a=_,* :: change part
$% [%& p=@ud] :: skip[copy]
@ -1437,7 +1437,7 @@ See `%clay` doc
------------------------------------------------------------------------
### ++unit
<h3 id="++unit"><code>++unit</code></h3>
++ unit |* a=_,* :: maybe
$|(~ [~ u=a]) ::
@ -1455,7 +1455,7 @@ See also: `++bind`, Section 2bA
------------------------------------------------------------------------
### ++upas
<h3 id="++upas"><code>++upas</code></h3>
++ upas :: tree change (%d)
$& [p=upas q=upas] :: cell
@ -1468,7 +1468,7 @@ See `%clay` doc
------------------------------------------------------------------------
### ++urge
<h3 id="++urge"><code>++urge</code></h3>
++ urge |*(a=_,* (list (unce a))) :: list change
@ -1476,7 +1476,7 @@ See `%clay` doc
------------------------------------------------------------------------
### ++vase
<h3 id="++vase"><code>++vase</code></h3>
++ vase ,[p=type q=*] :: type-value pair
@ -1490,7 +1490,7 @@ See `%arvo` doc
------------------------------------------------------------------------
### ++vise
<h3 id="++vise"><code>++vise</code></h3>
++ vise ,[p=typo q=*] :: old vase
@ -1500,7 +1500,7 @@ See `++typo`, `++seer`
------------------------------------------------------------------------
### ++wall
<h3 id="++wall"><code>++wall</code></h3>
++ wall (list tape) :: text lines (no \n)
@ -1523,7 +1523,7 @@ See also: `++wash`
------------------------------------------------------------------------
### ++wain
<h3 id="++wain"><code>++wain</code></h3>
++ wain (list cord) :: text lines (no \n)
@ -1556,7 +1556,7 @@ See also: `++lore`, `++role`
------------------------------------------------------------------------
### ++wing
<h3 id="++wing"><code>++wing</code></h3>
++ wing (list limb) ::
@ -1572,7 +1572,7 @@ See also: `++twig`
------------------------------------------------------------------------
### ++wine
<h3 id="++wine"><code>++wine</code></h3>
++ wine $| ?(%noun %path %tank %void %wall %wool %yarn)
$% [%atom p=term] ::
@ -1654,7 +1654,7 @@ See also: `++calf`
------------------------------------------------------------------------
### ++wonk
<h3 id="++wonk"><code>++wonk</code></h3>
++ wonk |*(veq=edge ?~(q.veq !! p.u.q.veq)) ::
:: ::
@ -1682,7 +1682,7 @@ See also: `++edge`, Section 2eC
------------------------------------------------------------------------
### ++map
<h3 id="++map"><code>++map</code></h3>
++ map |* [a=_,* b=_,*] :: associative tree
$|(~ [n=[p=a q=b] l=(map a b) r=(map a b)]) ::
@ -1700,7 +1700,7 @@ See also: `++by`
------------------------------------------------------------------------
### ++qeu
<h3 id="++qeu"><code>++qeu</code></h3>
++ qeu |* a=_,* :: queue
$|(~ [n=a l=(qeu a) r=(qeu a)]) ::
@ -1717,7 +1717,7 @@ See also: `++to`
------------------------------------------------------------------------
### ++set
<h3 id="++set"><code>++set</code></h3>
++ set |* a=_,* :: set
$|(~ [n=a l=(set a) r=(set a)]) ::
@ -1736,7 +1736,7 @@ See also: `++in`
------------------------------------------------------------------------
### ++jar
<h3 id="++jar"><code>++jar</code></h3>
++ jar |*([a=_,* b=_,*] (map a (list b))) :: map of lists
@ -1760,7 +1760,7 @@ See also: `++ja`, `++by`, `++map`, `++list`
------------------------------------------------------------------------
### ++jug
<h3 id="++jug"><code>++jug</code></h3>
++ jug |*([a=_,* b=_,*] (map a (set b))) :: map of sets

32
main/pub/doc/hoon/library/2a.md
View File

@ -1,7 +1,7 @@
chapter 2a, basic unsigned math
===============================
### ++add
<h3 id="++add"><code>++add</code></h3>
Add
@ -28,7 +28,7 @@ Produces the sum of `a` and `b` as an atom.
------------------------------------------------------------------------
### ++cap
<h3 id="++cap"><code>++cap</code></h3>
Tree head
@ -59,7 +59,7 @@ within the tail.
------------------------------------------------------------------------
### ++dec
<h3 id="++dec"><code>++dec</code></h3>
Decrement
@ -86,7 +86,7 @@ Produces `a-1` as an atom.
------------------------------------------------------------------------
### ++div
<h3 id="++div"><code>++div</code></h3>
Divide
@ -117,7 +117,7 @@ Computes `a` divided by `b`, producing an atom.
------------------------------------------------------------------------
### ++fac
<h3 id="++fac"><code>++fac</code></h3>
Factorial
@ -142,7 +142,7 @@ Computes the factorial of `a`, producing an atom.
------------------------------------------------------------------------
### ++gte
<h3 id="++gte"><code>++gte</code></h3>
Greater-than/equal
@ -168,7 +168,7 @@ Tests whether `a` is greater than a number `b`, producing a loobean.
------------------------------------------------------------------------
### ++gth
<h3 id="++gth"><code>++gth</code></h3>
Greater-than
@ -192,7 +192,7 @@ Tests whether `a` is greater than `b`, producing a loobean.
------------------------------------------------------------------------
### ++lte
<h3 id="++lte"><code>++lte</code></h3>
Less-than/equal
@ -219,7 +219,7 @@ Tests whether `a` is less than or equal to `b`, producing a loobean.
------------------------------------------------------------------------
### ++lth
<h3 id="++lth"><code>++lth</code></h3>
Less-than
@ -252,7 +252,7 @@ Tests whether `a` is less than `b`, producing a loobean.
------------------------------------------------------------------------
### ++mas
<h3 id="++mas"><code>++mas</code></h3>
Axis within head/tail
@ -287,7 +287,7 @@ Computes the axis of `a` within the head or the tail, producing an atom.
~zod/try=> (mas 1)
! exit
### ++max
<h3 id="++max"><code>++max</code></h3>
Maximum
@ -314,7 +314,7 @@ Computes the maximum of `a` and `b`, producing an atom.
------------------------------------------------------------------------
### ++min
<h3 id="++min"><code>++min</code></h3>
Minimum
@ -341,7 +341,7 @@ Computes the minimum of `a` and `b`, producing an atom.
------------------------------------------------------------------------
### ++mod
<h3 id="++mod"><code>++mod</code></h3>
Modulus
@ -361,7 +361,7 @@ Computes the remainder of dividing `a` by `b`, producing an atom.
------------------------------------------------------------------------
### ++mul
<h3 id="++mul"><code>++mul</code></h3>
Multiply
@ -388,7 +388,7 @@ Multiplies `a` by `b`, producing an atom.
------------------------------------------------------------------------
### ++peg
<h3 id="++peg"><code>++peg</code></h3>
Axis within axis
@ -419,7 +419,7 @@ Computes the axis of `b` within axis `a`, producing an atom.
------------------------------------------------------------------------
### ++sub
<h3 id="++sub"><code>++sub</code></h3>
Subtract

68
main/pub/doc/hoon/library/2b.md
View File

@ -4,7 +4,7 @@ chapter 2b, basic containers
Section 2bA, units
------------------
### ++biff
<h3 id="++biff"><code>++biff</code></h3>
Unit as argument
@ -27,7 +27,7 @@ Applies a gate that produces a unit, `b`, to the value (`u.a`) of a unit
------------------------------------------------------------------------
### ++bind
<h3 id="++bind"><code>++bind</code></h3>
Bind
@ -51,7 +51,7 @@ unit.
------------------------------------------------------------------------
### ++bond
<h3 id="++bond"><code>++bond</code></h3>
Replace null
@ -77,7 +77,7 @@ unit is not empty, then the original unit is produced.
------------------------------------------------------------------------
### ++both
<h3 id="++both"><code>++both</code></h3>
Group unit values
@ -101,7 +101,7 @@ Produces a unit whose value is a cell of the values of two input units
------------------------------------------------------------------------
### ++clap
<h3 id="++clap"><code>++clap</code></h3>
Apply gate to two units
@ -133,7 +133,7 @@ two units `a` and `b`.
------------------------------------------------------------------------
### ++drop
<h3 id="++drop"><code>++drop</code></h3>
Unit list
@ -155,7 +155,7 @@ Produces a [list]() of the value from a unit `a`.
------------------------------------------------------------------------
### ++fall
<h3 id="++fall"><code>++fall</code></h3>
Default unit
@ -177,7 +177,7 @@ null.
------------------------------------------------------------------------
### ++lift
<h3 id="++lift"><code>++lift</code></h3>
Fmap
@ -201,7 +201,7 @@ produces a unit value.
------------------------------------------------------------------------
### ++mate
<h3 id="++mate"><code>++mate</code></h3>
Choose
@ -237,7 +237,7 @@ produces that value. If the assertion fails, `++mate` crashes with
------------------------------------------------------------------------
### ++need
<h3 id="++need"><code>++need</code></h3>
Unwrap
@ -262,7 +262,7 @@ Retrieve the value from a unit and crash if the unit is null.
------------------------------------------------------------------------
### ++some
<h3 id="++some"><code>++some</code></h3>
Unify
@ -286,7 +286,7 @@ section 2bB, lists
Reverse
### ++flop
<h3 id="++flop"><code>++flop</code></h3>
++ flop :: reverse
~/ %flop
@ -306,7 +306,7 @@ Produces the list `a` in reverse order.
~zod/try=> (flop a)
~[3 2 1]
### ++homo
<h3 id="++homo"><code>++homo</code></h3>
Homogenize
@ -332,7 +332,7 @@ list `a`.
~zod/try=> (homo a)
~[1 2 3]
### ++limo
<h3 id="++limo"><code>++limo</code></h3>
List Constructor
@ -350,7 +350,7 @@ Turns a null-terminated tuple into a list.
~zod/try=> (limo [1 2 3 ~])
[i=1 t=[i=2 t=[i=3 t=~]]]
### ++lent
<h3 id="++lent"><code>++lent</code></h3>
List length
@ -374,7 +374,7 @@ Produces the length of any list `a` as an atom.
------------------------------------------------------------------------
### ++levy
<h3 id="++levy"><code>++levy</code></h3>
"and" to list
@ -402,7 +402,7 @@ passed to gate `b`.
------------------------------------------------------------------------
### ++lien
<h3 id="++lien"><code>++lien</code></h3>
"or" to list
@ -430,7 +430,7 @@ passed to gate `b`.
------------------------------------------------------------------------
### ++murn
<h3 id="++murn"><code>++murn</code></h3>
Maybe transform
@ -454,7 +454,7 @@ Produces a new list with all the results that do not produce `~`.
~zod/try=> (murn (limo [0 1 2 3 ~]) a)
[i=12 t=[i=13 t=~]]
### ++reap
<h3 id="++reap"><code>++reap</code></h3>
Replicate
@ -479,7 +479,7 @@ Replicate: produces a list containing `a` copies of `b`.
------------------------------------------------------------------------
### ++reel
<h3 id="++reel"><code>++reel</code></h3>
Right fold
@ -511,7 +511,7 @@ the final value of the accumulator.
------------------------------------------------------------------------
### ++roll
<h3 id="++roll"><code>++roll</code></h3>
Left fold
@ -543,7 +543,7 @@ producing the final value of the accumulator.
------------------------------------------------------------------------
### ++skid
<h3 id="++skid"><code>++skid</code></h3>
Separate
@ -567,7 +567,7 @@ true when slammed to gate `b` and those who produce `%.n`.
------------------------------------------------------------------------
### ++skim
<h3 id="++skim"><code>++skim</code></h3>
Suffix
@ -593,7 +593,7 @@ producing a list of all of the members that produce `%.y`. Inverse of
------------------------------------------------------------------------
### ++skip
<h3 id="++skip"><code>++skip</code></h3>
Except
@ -619,7 +619,7 @@ producing a list of all of the members that produce `%.n`. Inverse of
------------------------------------------------------------------------
### ++scag
<h3 id="++scag"><code>++scag</code></h3>
Prefix
@ -644,7 +644,7 @@ the front of the list.
------------------------------------------------------------------------
### ++slag
<h3 id="++slag"><code>++slag</code></h3>
Suffix
@ -670,7 +670,7 @@ Accepts an atom `a` and list `b`, producing the remaining elements from
------------------------------------------------------------------------
### ++snag
<h3 id="++snag"><code>++snag</code></h3>
Index
@ -697,7 +697,7 @@ of `a`and failing if the list is null. Lists are 0-indexed.
------------------------------------------------------------------------
### ++sort
<h3 id="++sort"><code>++sort</code></h3>
Quicksort
@ -726,7 +726,7 @@ sorted according to `b`.
------------------------------------------------------------------------
### ++swag
<h3 id="++swag"><code>++swag</code></h3>
Infix
@ -748,7 +748,7 @@ inclusive index `a`, producing `b` number of characters.
------------------------------------------------------------------------
### ++turn
<h3 id="++turn"><code>++turn</code></h3>
Gate to list
@ -774,7 +774,7 @@ to each element of the original list.
------------------------------------------------------------------------
### ++weld
<h3 id="++weld"><code>++weld</code></h3>
Concatenate
@ -797,7 +797,7 @@ Concatenate two lists `a` and `b`.
------------------------------------------------------------------------
### ++welp
<h3 id="++welp"><code>++welp</code></h3>
Perfect weld
@ -827,7 +827,7 @@ to homogenization.
------------------------------------------------------------------------
### ++wild
<h3 id="++wild"><code>++wild</code></h3>
XXDELETE
@ -873,7 +873,7 @@ individually.
------------------------------------------------------------------------
### ++zing
<h3 id="++zing"><code>++zing</code></h3>
Cons

154
main/pub/doc/hoon/library/2c.md
View File

@ -4,7 +4,7 @@ chapter 2c, simple noun surgery
section 2cA, bit surgery
------------------------
### ++bex
<h3 id="++bex"><code>++bex</code></h3>
Binary exponent
@ -28,7 +28,7 @@ Computes the result of `2^a`, producing an atom.
------------------------------------------------------------------------
### ++xeb
<h3 id="++xeb"><code>++xeb</code></h3>
Binary logarithm
@ -57,7 +57,7 @@ Computes the base-2 logarithm of `a`, producing an atom.
------------------------------------------------------------------------
### ++can
<h3 id="++can"><code>++can</code></h3>
Assemble
@ -91,7 +91,7 @@ value.
------------------------------------------------------------------------
### ++cat
<h3 id="++cat"><code>++cat</code></h3>
Concatenate
@ -130,7 +130,7 @@ atom.
------------------------------------------------------------------------
### ++cut
<h3 id="++cut"><code>++cut</code></h3>
Slice
@ -167,7 +167,7 @@ Produces an atom.
------------------------------------------------------------------------
### ++end
<h3 id="++end"><code>++end</code></h3>
Tail
@ -203,7 +203,7 @@ Produces an atom by taking the last `b` blocks of size `a` from `c`.
------------------------------------------------------------------------
### ++fil
<h3 id="++fil"><code>++fil</code></h3>
Fill bloqstream
@ -235,7 +235,7 @@ Produces an atom by repeating `c` for `b` blocks of size `a`.
------------------------------------------------------------------------
### ++lsh
<h3 id="++lsh"><code>++lsh</code></h3>
Left-shift
@ -267,7 +267,7 @@ Produces an atom by left-shifting `c` by `b` blocks of size `a`.
------------------------------------------------------------------------
### ++met
<h3 id="++met"><code>++met</code></h3>
Measure
@ -299,7 +299,7 @@ Computes the number of blocks of size `a` in `b`, producing an atom.
------------------------------------------------------------------------
### ++rap
<h3 id="++rap"><code>++rap</code></h3>
Assemble non-zero
@ -327,7 +327,7 @@ Concatenate a list of atoms `b` using blocksize `a`, producing an atom.
------------------------------------------------------------------------
### ++rep
<h3 id="++rep"><code>++rep</code></h3>
Assemble single
@ -363,7 +363,7 @@ Produces an atom by assembling a list of atoms `b` using block size `a`.
------------------------------------------------------------------------
### ++rip
<h3 id="++rip"><code>++rip</code></h3>
Disassemble
@ -399,7 +399,7 @@ Produces a list of atoms from the bits of `b` using block size `a`.
------------------------------------------------------------------------
### ++rsh
<h3 id="++rsh"><code>++rsh</code></h3>
Right-shift
@ -441,7 +441,7 @@ Right-shifts `c` by `b` blocks of size `a`, producing an atom.
------------------------------------------------------------------------
### ++swap
<h3 id="++swap"><code>++swap</code></h3>
Reverse block order
@ -470,7 +470,7 @@ reversing the block order of `b` using block size `a`.
section 2cB, bit logic
----------------------
### ++con
<h3 id="++con"><code>++con</code></h3>
Binary OR
@ -513,7 +513,7 @@ atom.
------------------------------------------------------------------------
### ++dis
<h3 id="++dis"><code>++dis</code></h3>
Binary AND
@ -560,7 +560,7 @@ atom.
------------------------------------------------------------------------
### ++mix
<h3 id="++mix"><code>++mix</code></h3>
Binary XOR
@ -599,7 +599,7 @@ Produces the bit-wise logical XOR of `a` and `b`, producing an atom.
------------------------------------------------------------------------
### ++not
<h3 id="++not"><code>++not</code></h3>
Binary NOT
@ -633,7 +633,7 @@ of `c`.
section 2cC, noun orders
------------------------
### ++aor
<h3 id="++aor"><code>++aor</code></h3>
Alphabetic order
@ -680,7 +680,7 @@ loobean.
------------------------------------------------------------------------
### ++dor
<h3 id="++dor"><code>++dor</code></h3>
Numeric order
@ -719,7 +719,7 @@ loobean.
------------------------------------------------------------------------
### ++gor
<h3 id="++gor"><code>++gor</code></h3>
Hash order
@ -758,7 +758,7 @@ XX revisit
------------------------------------------------------------------------
### ++hor
<h3 id="++hor"><code>++hor</code></h3>
Hash order
@ -789,7 +789,7 @@ Recursive hash comparator gate.
------------------------------------------------------------------------
### ++vor
<h3 id="++vor"><code>++vor</code></h3>
++ vor :: v-order
~/ %vor
@ -814,7 +814,7 @@ Double hash comparator gate.
section 2cD, insecure hashing
-----------------------------
### ++fnv
<h3 id="++fnv"><code>++fnv</code></h3>
++ fnv |=(a=@ (end 5 1 (mul 16.777.619 a))) :: FNV scrambler
@ -833,7 +833,7 @@ of size 5 off the product's end, producing atom.
------------------------------------------------------------------------
### ++mum
<h3 id="++mum"><code>++mum</code></h3>
++ mum :: mug with murmur3
~/ %mum
@ -889,7 +889,7 @@ XX document
~zod/try=> (mum ~[1 2 3 4 5])
1.517.902.092
### ++mug
<h3 id="++mug"><code>++mug</code></h3>
++ mug :: 31bit nonzero FNV1a
~/ %mug
@ -929,7 +929,7 @@ algorithm, producing an atom.
section 2cE, phonetic base
--------------------------
### ++po
<h3 id="++po"><code>++po</code></h3>
++ po
~/ %po
@ -975,7 +975,7 @@ contained in this section.
------------------------------------------------------------------------
### ++ind
<h3 id="++ind"><code>++ind</code></h3>
Parse prefix
@ -998,7 +998,7 @@ Produces the byte of the right-hand syllable `a`.
------------------------------------------------------------------------
### ++ins
<h3 id="++ins"><code>++ins</code></h3>
Parse suffix
@ -1023,7 +1023,7 @@ Produces the byte of the left-hand phonetic syllable `b`.
------------------------------------------------------------------------
### ++tod
<h3 id="++tod"><code>++tod</code></h3>
Fetch prefix
@ -1050,7 +1050,7 @@ atom.
------------------------------------------------------------------------
### ++tos
<h3 id="++tos"><code>++tos</code></h3>
Fetch suffix
@ -1074,7 +1074,7 @@ atom.
section 2cF, signed and modular ints
------------------------------------
### ++si
<h3 id="++si"><code>++si</code></h3>
++ si !: :: signed integer
|%
@ -1083,7 +1083,7 @@ Container for the signed integer functions.
------------------------------------------------------------------------
### ++abs
<h3 id="++abs"><code>++abs</code></h3>
++ abs |=(a=@s (add (end 0 1 a) (rsh 0 1 a))) :: absolute value
@ -1100,7 +1100,7 @@ Produces the absolute value of a signed integer.
------------------------------------------------------------------------
### ++dif
<h3 id="++dif"><code>++dif</code></h3>
++ dif |= [a=@s b=@s] :: subtraction
(sum a (new !(syn b) (abs b)))
@ -1122,7 +1122,7 @@ Produces the difference between two signed integers `b` and `c`.
------------------------------------------------------------------------
### ++dul
<h3 id="++dul"><code>++dul</code></h3>
++ dul |= [a=@s b=@] :: modulus
=+(c=(old a) ?:(-.c (mod +.c b) (sub b +.c)))
@ -1146,7 +1146,7 @@ Produces the modulus of two signed integers.
------------------------------------------------------------------------
### ++fra
<h3 id="++fra"><code>++fra</code></h3>
++ fra |= [a=@s b=@s] :: divide
(new =(0 (mix (syn a) (syn b))) (div (abs a) (abs b)))
@ -1164,7 +1164,7 @@ Produces the quotient of two signed integers.
------------------------------------------------------------------------
### ++new
<h3 id="++new"><code>++new</code></h3>
++ new |= [a=? b=@] :: [sign value] to @s
`@s`?:(a (mul 2 b) ?:(=(0 b) 0 +((mul 2 (dec b)))))
@ -1184,7 +1184,7 @@ Produces a signed integer from a loobean sign value `a` and an atom `b`.
------------------------------------------------------------------------
### ++old
<h3 id="++old"><code>++old</code></h3>
++ old |=(a=@s [(syn a) (abs a)]) :: [sign value]
@ -1206,7 +1206,7 @@ Produces the cell `[sign value]` representations of a signed integer.
------------------------------------------------------------------------
### ++pro
<h3 id="++pro"><code>++pro</code></h3>
++ pro |= [a=@s b=@s] :: multiplication
(new =(0 (mix (syn a) (syn b))) (mul (abs a) (abs b)))
@ -1228,7 +1228,7 @@ Produces the product of two signed integers.
------------------------------------------------------------------------
### ++rem
<h3 id="++rem"><code>++rem</code></h3>
++ rem |=([a=@s b=@s] (dif a (pro b (fra a b)))) :: remainder
@ -1251,7 +1251,7 @@ Produces the remainder from a division of two signed integers.
------------------------------------------------------------------------
### ++sum
<h3 id="++sum"><code>++sum</code></h3>
++ sum |= [a=@s b=@s] :: addition
~| %si-sum
@ -1285,7 +1285,7 @@ Sum two signed integers.
------------------------------------------------------------------------
### ++sun
<h3 id="++sun"><code>++sun</code></h3>
++ sun |=(a=@u (mul 2 a)) :: @u to @s
@ -1309,7 +1309,7 @@ inferred as an unsigned integer in the type system.
------------------------------------------------------------------------
### ++syn
<h3 id="++syn"><code>++syn</code></h3>
++ syn |=(a=@s =(0 (end 0 1 a))) :: sign test
@ -1326,7 +1326,7 @@ Produce the sign of a signed integer, `&` being posiitve, `|` negative.
------------------------------------------------------------------------
### ++cmp
<h3 id="++cmp"><code>++cmp</code></h3>
++ cmp |= [a=@s b=@s] :: compare
^- @s
@ -1359,7 +1359,7 @@ Compare two signed integers.
~zod/try=> (cmp:si -10 --7)
-1
### ++dif
<h3 id="++dif"><code>++dif</code></h3>
++ dif |=([b=@ c=@] (sit (sub (add out (sit b)) (sit c))))
@ -1389,7 +1389,7 @@ representation.
------------------------------------------------------------------------
### ++inv
<h3 id="++inv"><code>++inv</code></h3>
++ inv |=(b=@ (sub (dec out) (sit b)))
@ -1412,7 +1412,7 @@ Inverts the order of the modular field.
------------------------------------------------------------------------
### ++net
<h3 id="++net"><code>++net</code></h3>
++ net |= b=@ ^- @
=> .(b (sit b))
@ -1476,7 +1476,7 @@ Reverse bytes within block.
------------------------------------------------------------------------
### ++out
<h3 id="++out"><code>++out</code></h3>
++ out (bex (bex a))
@ -1503,7 +1503,7 @@ The maximum integer value that the current block can store.
------------------------------------------------------------------------
### ++rol
<h3 id="++rol"><code>++rol</code></h3>
++ rol |= [b=bloq c=@ d=@] ^- @ :: roll left
=+ e=(sit d)
@ -1532,7 +1532,7 @@ Roll `d` to the left by `c` `b`-sized blocks.
------------------------------------------------------------------------
### ++ror
<h3 id="++ror"><code>++ror</code></h3>
++ ror |= [b=bloq c=@ d=@] ^- @ :: roll right
=+ e=(sit d)
@ -1563,7 +1563,7 @@ Roll `d` to the right by `c` `b`-sized blocks.
------------------------------------------------------------------------
### ++sum
<h3 id="++sum"><code>++sum</code></h3>
++ sum |=([b=@ c=@] (sit (add b c))) :: wrapping add
@ -1588,7 +1588,7 @@ Sum two numbers in this modular field.
~zod/try=> (~(sum fe 4) 10.000 100.000)
44.464
### ++sit
<h3 id="++sit"><code>++sit</code></h3>
++ sit |=(b=@ (end a 1 b)) :: enforce modulo
@ -1635,7 +1635,7 @@ format. We use this for many of our examples.
~zod/try=> -<-
~2014.8.4..19.39.59..9288
### ++year
<h3 id="++year"><code>++year</code></h3>
++ year :: date to @d
|= det=date
@ -1657,7 +1657,7 @@ its `@d`representation.
------------------------------------------------------------------------
### ++yore
<h3 id="++yore"><code>++yore</code></h3>
++ yore :: @d to date
|= now=@d
@ -1678,7 +1678,7 @@ Produces a `++date` from a `@d`
~zod/try=> (yore -<-)
[[a=%.y y=2.014] m=8 t=[d=4 h=20 m=28 s=53 f=~[0x7b82]]]
### ++yell
<h3 id="++yell"><code>++yell</code></h3>
++ yell :: tarp from @d
|= now=@d
@ -1712,7 +1712,7 @@ Produce a parsed daily time format from an atomic date.
------------------------------------------------------------------------
### ++yule
<h3 id="++yule"><code>++yule</code></h3>
++ yule :: time atom
|= rip=tarp
@ -1734,7 +1734,7 @@ Produce a parsed daily time format from an atomic date.
Accept a [`++tarp`](), a parsed daily time, and produces a time atom,
`@d`.
`rip` is a [`++tarp`]().
`rip` is a [`++tarp`](/doc/hoon/library/1#++tarp).
~zod/try=> =murica (yell ~1776.7.4)
~zod/try=> murica
@ -1752,7 +1752,7 @@ Accept a [`++tarp`](), a parsed daily time, and produces a time atom,
------------------------------------------------------------------------
### ++yall
<h3 id="++yall"><code>++yall</code></h3>
++ yall :: day # to day of year
|= day=@ud
@ -1792,7 +1792,7 @@ day from a number of days from the beginning of time.
------------------------------------------------------------------------
### ++yawn
<h3 id="++yawn"><code>++yawn</code></h3>
++ yawn :: days since Jesus
|= [yer=@ud mot=@ud day=@ud]
@ -1837,7 +1837,7 @@ tuple `[yer=@ud mot=@ud day=@ud]`.
------------------------------------------------------------------------
### ++yelp
<h3 id="++yelp"><code>++yelp</code></h3>
++ yelp :: leap year
|= yer=@ud ^- ?
@ -1859,14 +1859,14 @@ loobean.
------------------------------------------------------------------------
### ++yo
<h3 id="++yo"><code>++yo</code></h3>
++ yo :: time constants
Useful constants for interacting with earth time.
### ++cet
<h3 id="++cet"><code>++cet</code></h3>
|% ++ cet 36.524 :: (add 24 (mul 100 365))
@ -1883,7 +1883,7 @@ days from leap years in a century (24).
------------------------------------------------------------------------
### ++day
<h3 id="++day"><code>++day</code></h3>
++ day 86.400 :: (mul 24 hor)
@ -1896,7 +1896,7 @@ Number of seconds in a day.
------------------------------------------------------------------------
### ++era
<h3 id="++era"><code>++era</code></h3>
++ era 146.097 :: (add 1 (mul 4 cet))
@ -1904,7 +1904,7 @@ XX Revisit
------------------------------------------------------------------------
### ++hor
<h3 id="++hor"><code>++hor</code></h3>
++ hor 3.600 :: (mul 60 mit)
@ -1918,7 +1918,7 @@ seconds in a minute by the minutes in an hour.
------------------------------------------------------------------------
### ++jes
<h3 id="++jes"><code>++jes</code></h3>
++ jes 106.751.991.084.417 :: (mul 730.692.561 era)
@ -1929,7 +1929,7 @@ XX Revisit
------------------------------------------------------------------------
### ++mit
<h3 id="++mit"><code>++mit</code></h3>
++ mit 60
@ -1940,7 +1940,7 @@ The number of seconds in a minute.
------------------------------------------------------------------------
### ++moh
<h3 id="++moh"><code>++moh</code></h3>
++ moh `(list ,@ud)`[31 28 31 30 31 30 31 31 30 31 30 31 ~]
@ -1955,7 +1955,7 @@ month at the year at that index.
------------------------------------------------------------------------
### ++moy
<h3 id="++moy"><code>++moy</code></h3>
++ moy `(list ,@ud)`[31 29 31 30 31 30 31 31 30 31 30 31 ~]
@ -1970,7 +1970,7 @@ month at the leap-year at that index.
------------------------------------------------------------------------
### ++qad
<h3 id="++qad"><code>++qad</code></h3>
++ qad 126.144.001 :: (add 1 (mul 4 yer))
@ -1982,7 +1982,7 @@ number of seconds in four years.
------------------------------------------------------------------------
### ++yer
<h3 id="++yer"><code>++yer</code></h3>
++ yer 31.536.000 :: (mul 365 day)
@ -1997,7 +1997,7 @@ seconds in a day by 365.
section 2cI, almost macros
--------------------------
### ++cury
<h3 id="++cury"><code>++cury</code></h3>
++ cury
|* [a=_|=(^ _*) b=*]
@ -2018,7 +2018,7 @@ Curry a gate, binding the head of its sample
------------------------------------------------------------------------
### ++curr
<h3 id="++curr"><code>++curr</code></h3>
++ curr
|* [a=_|=(^ _*) c=*]
@ -2039,7 +2039,7 @@ Right curry a gate, binding the tail of its sample
------------------------------------------------------------------------
### ++cork
<h3 id="++cork"><code>++cork</code></h3>
++ cork |*([a=_,* b=gate] (corl b a)) :: compose forward
@ -2059,7 +2059,7 @@ Build `f` such that `(f x) .= (b (a x))`.
------------------------------------------------------------------------
### ++corl
<h3 id="++corl"><code>++corl</code></h3>
++ corl :: compose backwards
|* [a=gate b=_,*]
@ -2079,7 +2079,7 @@ XX Revisit
------------------------------------------------------------------------
### ++hard
<h3 id="++hard"><code>++hard</code></h3>
++ hard
|* han=$+(* *)
@ -2103,7 +2103,7 @@ not.
------------------------------------------------------------------------
### ++soft
<h3 id="++soft"><code>++soft</code></h3>
++ soft
|* han=$+(* *)

28
main/pub/doc/hoon/library/2da.md
View File

@ -1,7 +1,7 @@
section 2dA, sets
=================
### ++apt
<h3 id="++apt"><code>++apt</code></h3>
Set verification
@ -29,7 +29,7 @@ Produces a loobean indicating whether `a` is a set or not.
------------------------------------------------------------------------
### ++in
<h3 id="++in"><code>++in</code></h3>
Set operations
@ -44,7 +44,7 @@ Input arm.
`a` is a [set]()
### +-all:in
<h3 id="+-all:in"><code>+-all:in</code></h3>
Logical AND
@ -73,7 +73,7 @@ producing a loobean.
------------------------------------------------------------------------
### +-any:in
<h3 id="+-any:in"><code>+-any:in</code></h3>
Logical OR
@ -101,7 +101,7 @@ Computes the logical OR on every element of `a` slammed with `b`.
------------------------------------------------------------------------
### +-del:in
<h3 id="+-del:in"><code>+-del:in</code></h3>
Remove noun
@ -140,7 +140,7 @@ Removes `b` from the set `a`.
------------------------------------------------------------------------
### +-dig:in
<h3 id="+-dig:in"><code>+-dig:in</code></h3>
Axis a in b
@ -175,7 +175,7 @@ Produce the axis of `b` within `a`.
------------------------------------------------------------------------
### +-gas:in
<h3 id="+-gas:in"><code>+-gas:in</code></h3>
Concatenate
@ -203,7 +203,7 @@ Insert the elements of a list `b` into a set `a`.
------------------------------------------------------------------------
### +-has:in
<h3 id="+-has:in"><code>+-has:in</code></h3>
b in a?
@ -234,7 +234,7 @@ Checks if `b` is an element of `a`, producing a loobean.
------------------------------------------------------------------------
### +-int:in
<h3 id="+-int:in"><code>+-int:in</code></h3>
Intersection
@ -272,7 +272,7 @@ Produces a set of the intersection between two sets of the same type,
------------------------------------------------------------------------
### +-put:in
<h3 id="+-put:in"><code>+-put:in</code></h3>
Put b in a
@ -312,7 +312,7 @@ Add an element `b` to the set `a`.
------------------------------------------------------------------------
### +-rep:in
<h3 id="+-rep:in"><code>+-rep:in</code></h3>
Accumulate
@ -339,7 +339,7 @@ Accumulate the elements of `a` using a gate `c` and an accumulator `b`.
------------------------------------------------------------------------
### +-tap:in
<h3 id="+-tap:in"><code>+-tap:in</code></h3>
Set to list
@ -372,7 +372,7 @@ Flatten the set `a` into a list.
------------------------------------------------------------------------
### +-uni:in
<h3 id="+-uni:in"><code>+-uni:in</code></h3>
Union
@ -414,7 +414,7 @@ Produces a set of the union between two sets of the same type, `a` and
------------------------------------------------------------------------
### +-wyt:in
<h3 id="+-wyt:in"><code>+-wyt:in</code></h3>
Set size

58
main/pub/doc/hoon/library/2db.md
View File

@ -1,7 +1,7 @@
section 2dB, maps
=================
### ++ept
<h3 id="++ept"><code>++ept</code></h3>
Map invariant.
@ -29,7 +29,7 @@ Computes whether `a` is a [map](), producing a loobean.
------------------------------------------------------------------------
### ++ja
<h3 id="++ja"><code>++ja</code></h3>
Jar engine
@ -46,7 +46,7 @@ A container arm for `++jar` operation arms. A `++jar` is a `++map` of
------------------------------------------------------------------------
### +-get:ja
<h3 id="+-get:ja"><code>+-get:ja</code></h3>
Grab value by key
@ -57,7 +57,7 @@ Grab value by key
Produces a list retrieved from jar `a` using the key `b`.
`a` is a [`++jar`]().
`a` is a [`++jar`](/doc/hoon/library/1#++jar).
`b` is a key of the same type as the keys in `a`.
@ -73,7 +73,7 @@ Produces a list retrieved from jar `a` using the key `b`.
------------------------------------------------------------------------
### +-add:ja
<h3 id="+-add:ja"><code>+-add:ja</code></h3>
Prepend to list
@ -106,7 +106,7 @@ Produces jar `a` with value `c` prepended to the list located at key
------------------------------------------------------------------------
### ++ju
<h3 id="++ju"><code>++ju</code></h3>
Jug operations
@ -121,7 +121,7 @@ Container arm for jug operation arms. A `++jug` is a `++map` of
~zod/try=> ~(. ju (mo (limo a/(sa "ho") b/(sa "he") ~)))
<2.dgz [nlr([p={%a %b} q={nlr(^$1{@tD $1}) nlr(^$3{@tD $3})}]) <414.fvk 101.jzo 1.ypj %164>]>
### +-del:ju
<h3 id="+-del:ju"><code>+-del:ju</code></h3>
Remove
@ -152,7 +152,7 @@ removed.
------------------------------------------------------------------------
### +-get:ju
<h3 id="+-get:ju"><code>+-get:ju</code></h3>
Retrieve set
@ -178,7 +178,7 @@ Produces a set retrieved from jar `a` using key `b`.
------------------------------------------------------------------------
### +-has:ju
<h3 id="+-has:ju"><code>+-has:ju</code></h3>
Check contents
@ -213,7 +213,7 @@ with jar `a`. Produces a loobean.
------------------------------------------------------------------------
### +-put:ju
<h3 id="+-put:ju"><code>+-put:ju</code></h3>
Add key-set pair
@ -242,7 +242,7 @@ Produces jar `a` with `c` added to the set value located at key `b`.
------------------------------------------------------------------------
### ++by
<h3 id="++by"><code>++by</code></h3>
Map operations
@ -260,7 +260,7 @@ pairs. The contained arms inherit it's [sample]() [map](), `a`.
------------------------------------------------------------------------
### +-all:by
<h3 id="+-all:by"><code>+-all:by</code></h3>
Logical AND
@ -290,7 +290,7 @@ Computes the logical AND on the results of slamming every element in map
------------------------------------------------------------------------
### +-any:by
<h3 id="+-any:by"><code>+-any:by</code></h3>
Logical OR
@ -318,7 +318,7 @@ gate `b`. Produces a loobean.
------------------------------------------------------------------------
### +-del:by
<h3 id="+-del:by"><code>+-del:by</code></h3>
Delete
@ -351,7 +351,7 @@ Produces map `a` with the element located at key `b` removed.
------------------------------------------------------------------------
### +-dig:by
<h3 id="+-dig:by"><code>+-dig:by</code></h3>
Axis of key
@ -377,7 +377,7 @@ Produce the axis of key `b` within map `a`.
------------------------------------------------------------------------
### +-gas:by
<h3 id="+-gas:by"><code>+-gas:by</code></h3>
Concatenate
@ -403,7 +403,7 @@ Insert a list of key-value pairs `b` into map `a`.
------------------------------------------------------------------------
### +-get:by
<h3 id="+-get:by"><code>+-get:by</code></h3>
Grab unit value
@ -431,7 +431,7 @@ Produce the unit value of the value located at key `b` within map `a`.
------------------------------------------------------------------------
### +-got:by
<h3 id="+-got:by"><code>+-got:by</code></h3>
Assert
@ -459,7 +459,7 @@ does not exist.
------------------------------------------------------------------------
### +-has:by
<h3 id="+-has:by"><code>+-has:by</code></h3>
Key existence check
@ -483,7 +483,7 @@ loobean.
------------------------------------------------------------------------
### +-int:by
<h3 id="+-int:by"><code>+-int:by</code></h3>
Intersection
@ -539,7 +539,7 @@ different values, the element from map `b` is used.
------------------------------------------------------------------------
### +-mar:by
<h3 id="+-mar:by"><code>+-mar:by</code></h3>
Assert and Add
@ -575,7 +575,7 @@ XX This arm is broken, asana task 15186618346453
------------------------------------------------------------------------
### +-put:by
<h3 id="+-put:by"><code>+-put:by</code></h3>
Add key-value pair
@ -621,7 +621,7 @@ Produces `a` with the addition of the key-value pair of `b` and `c`.
------------------------------------------------------------------------
### +-rep:by
<h3 id="+-rep:by"><code>+-rep:by</code></h3>
+- rep :: replace by product
|* [b=* c=_,*]
@ -635,7 +635,7 @@ XX interface changing.
------------------------------------------------------------------------
### +-rib:by
<h3 id="+-rib:by"><code>+-rib:by</code></h3>
+- rib :: transform + product
|* [b=* c=_,*]
@ -653,7 +653,7 @@ XX interface changing, possibly disappearing
------------------------------------------------------------------------
### +-run:by
<h3 id="+-run:by"><code>+-run:by</code></h3>
Transform values
@ -678,7 +678,7 @@ Iterates over every value in set `a` using gate `b`. Produces a map.
------------------------------------------------------------------------
### +-tap:by
<h3 id="+-tap:by"><code>+-tap:by</code></h3>
Listify pairs
@ -707,7 +707,7 @@ Produces the list of all elements in map `a` that is prepended to list
------------------------------------------------------------------------
### +-uni:by
<h3 id="+-uni:by"><code>+-uni:by</code></h3>
Union
@ -758,7 +758,7 @@ shares a key with `a`, the tuple from `a` is preserved.
------------------------------------------------------------------------
### +-urn:by
<h3 id="+-urn:by"><code>+-urn:by</code></h3>
Turn (with key)
@ -787,7 +787,7 @@ produces a noun (the new value).
------------------------------------------------------------------------
### +-wyt:by
<h3 id="+-wyt:by"><code>+-wyt:by</code></h3>
Depth

18
main/pub/doc/hoon/library/2dc.md
View File

@ -1,7 +1,7 @@
section 2dC, queues
===================
### ++to
<h3 id="++to"><code>++to</code></h3>
Queue engine
@ -13,7 +13,7 @@ Container arm for queue operation arms. The contained arms inherit its
`a` is a queue, [++qeu]().
### +-bal:to
<h3 id="+-bal:to"><code>+-bal:to</code></h3>
Balance
@ -42,7 +42,7 @@ Vertically rebalances queue `a`.
------------------------------------------------------------------------
### +-dep:to
<h3 id="+-dep:to"><code>+-dep:to</code></h3>
Maximum Depth
@ -72,7 +72,7 @@ Produces the maximum depth of leaves (r.a and l.a) in queue `a`.
------------------------------------------------------------------------
### +-gas
<h3 id="+-gas"><code>+-gas</code></h3>
Push list
@ -97,7 +97,7 @@ Push all elements of list `b` into the queue.
------------------------------------------------------------------------
### +-get:to
<h3 id="+-get:to"><code>+-get:to</code></h3>
Pop
@ -126,7 +126,7 @@ Produces the head and tail queue of `a`.
------------------------------------------------------------------------
### +-nap:to
<h3 id="+-nap:to"><code>+-nap:to</code></h3>
Remove last in
@ -154,7 +154,7 @@ Removes the head of queue `a`, producing the resulting queue.
------------------------------------------------------------------------
### +-put:to
<h3 id="+-put:to"><code>+-put:to</code></h3>
Insert
@ -179,7 +179,7 @@ resulting queue.
------------------------------------------------------------------------
### +-tap:to
<h3 id="+-tap:to"><code>+-tap:to</code></h3>
Queue to list
@ -203,7 +203,7 @@ Produces queue `a` as a list from front to back.
------------------------------------------------------------------------
### +-top:to
<h3 id="+-top:to"><code>+-top:to</code></h3>
+- top :: produces head
|- ^- (unit ,_?>(?=(^ a) n.a))

6
main/pub/doc/hoon/library/2dd.md
View File

@ -1,7 +1,7 @@
section 2dD, casual containers
==============================
### ++mo
<h3 id="++mo"><code>++mo</code></h3>
Map from list
@ -23,7 +23,7 @@ Produces a map of key-value pairs from the left-right cell pairs of list
------------------------------------------------------------------------
### ++sa
<h3 id="++sa"><code>++sa</code></h3>
Set from list
@ -45,7 +45,7 @@ Produces a set of the elements in list `a`.
------------------------------------------------------------------------
### ++qu
<h3 id="++qu"><code>++qu</code></h3>
Queue from list

8
main/pub/doc/hoon/library/2ea.md
View File

@ -1,7 +1,7 @@
section 2eA, packing
====================
### ++cue
<h3 id="++cue"><code>++cue</code></h3>
Unpack atom to noun
@ -41,7 +41,7 @@ Produces a noun unpacked from atom `a`. The inverse of jam.
------------------------------------------------------------------------
### ++jam
<h3 id="++jam"><code>++jam</code></h3>
++ jam :: pack
~/ %jam
@ -83,7 +83,7 @@ Produces an atom unpacked from noun `a`. The inverse of cue.
------------------------------------------------------------------------
### ++mat
<h3 id="++mat"><code>++mat</code></h3>
Length-encode
@ -123,7 +123,7 @@ is the length of `q` in bits.
------------------------------------------------------------------------
### ++rub
<h3 id="++rub"><code>++rub</code></h3>
Length-decode

4
main/pub/doc/hoon/library/2eb.md
View File

@ -1,7 +1,7 @@
section 2eB, parsing (tracing)
==============================
### ++last
<h3 id="++last"><code>++last</code></h3>
Farther trace
@ -30,7 +30,7 @@ Compares two line-column pairs, `zyc` and `naz`, and produces whichever
------------------------------------------------------------------------
### ++lust
<h3 id="++lust"><code>++lust</code></h3>
Detect newline

42
main/pub/doc/hoon/library/2ec.md
View File

@ -1,7 +1,7 @@
section 2eC, parsing (custom rules)
===================================
### ++cold
<h3 id="++cold"><code>++cold</code></h3>
Replace with constant
@ -30,7 +30,7 @@ produces a constant `cus`, if `sef` is successful.
------------------------------------------------------------------------
### ++cook
<h3 id="++cook"><code>++cook</code></h3>
Apply gate
@ -63,7 +63,7 @@ rule `sef` and slams it through `poq`.
------------------------------------------------------------------------
### ++easy
<h3 id="++easy"><code>++easy</code></h3>
Always parse
@ -88,7 +88,7 @@ without consuming any text.
------------------------------------------------------------------------
### ++fail
<h3 id="++fail"><code>++fail</code></h3>
Never parse
@ -106,7 +106,7 @@ result (`q=~`).
------------------------------------------------------------------------
### ++full
<h3 id="++full"><code>++full</code></h3>
Parse to end
@ -131,7 +131,7 @@ when a `tub` success consumes the remainder of the [tape]().
------------------------------------------------------------------------
### ++funk
<h3 id="++funk"><code>++funk</code></h3>
Add to tape
@ -154,7 +154,7 @@ Parser modifier: prepend text to tape before applying parser.
------------------------------------------------------------------------
### ++here
<h3 id="++here"><code>++here</code></h3>
Place-based apply
@ -186,7 +186,7 @@ Parser modifier. Similar to [`++cook`](), produces a parser that takes a
------------------------------------------------------------------------
### ++inde
<h3 id="++inde"><code>++inde</code></h3>
Indentation block
@ -231,7 +231,7 @@ the leading whitespace.
------------------------------------------------------------------------
### ++jest
<h3 id="++jest"><code>++jest</code></h3>
Match a cord
@ -266,7 +266,7 @@ Match and consume a cord.
------------------------------------------------------------------------
### ++just
<h3 id="++just"><code>++just</code></h3>
Match a char
@ -300,7 +300,7 @@ Match and consume a single character.
------------------------------------------------------------------------
### ++knee
<h3 id="++knee"><code>++knee</code></h3>
Recursive parsers
@ -341,7 +341,7 @@ compiled.
------------------------------------------------------------------------
### ++mask
<h3 id="++mask"><code>++mask</code></h3>
Match char
@ -374,7 +374,7 @@ characters.
------------------------------------------------------------------------
### ++next
<h3 id="++next"><code>++next</code></h3>
Consume char
@ -398,7 +398,7 @@ Consume any character, producing it as a result.
------------------------------------------------------------------------
### ++sear
<h3 id="++sear"><code>++sear</code></h3>
Conditional `++cook`
@ -417,7 +417,7 @@ Conditional `++cook`
Conditional [`++cook`](). Slams the result through a gate that produces
a unit; if that unit is empty, fail.
`tub` is a [`++nail`]()
`tub` is a [`++nail`](/doc/hoon/library/1#++nail)
~zod/try=> ((sear |=(a=* ?@(a (some a) ~)) (just `a`)) [[1 1] "abc"])
[p=[p=1 q=2] q=[~ u=[p=97 q=[p=[p=1 q=2] q="bc"]]]]
@ -426,7 +426,7 @@ a unit; if that unit is empty, fail.
------------------------------------------------------------------------
### ++shim
<h3 id="++shim"><code>++shim</code></h3>
Char in range
@ -456,7 +456,7 @@ Match characters within a range.
------------------------------------------------------------------------
### ++stag
<h3 id="++stag"><code>++stag</code></h3>
Add label
@ -486,7 +486,7 @@ Add a label to an edge parsed by a rule.
------------------------------------------------------------------------
### ++stet
<h3 id="++stet"><code>++stet</code></h3>
Add faces
@ -523,7 +523,7 @@ Add `[p q]` faces to range-parser pairs in a list.
------------------------------------------------------------------------
### ++stew
<h3 id="++stew"><code>++stew</code></h3>
Switch by first
@ -578,7 +578,7 @@ associated with a range the tape's first character falls in.
------------------------------------------------------------------------
### ++stir
<h3 id="++stir"><code>++stir</code></h3>
Parse repeatedly
@ -612,7 +612,7 @@ binary gate.
------------------------------------------------------------------------
### ++stun
<h3 id="++stun"><code>++stun</code></h3>
Parse several times

18
main/pub/doc/hoon/library/2ed.md
View File

@ -1,7 +1,7 @@
section 2eD
===========
### ++bend
<h3 id="++bend"><code>++bend</code></h3>
Conditional composer
@ -50,7 +50,7 @@ group of rules to a specified output.
------------------------------------------------------------------------
### ++comp
<h3 id="++comp"><code>++comp</code></h3>
Arbitrary compose
@ -87,7 +87,7 @@ produces a cell of two nouns.
------------------------------------------------------------------------
### ++glue
<h3 id="++glue"><code>++glue</code></h3>
Skip delimiter
@ -120,7 +120,7 @@ result.
------------------------------------------------------------------------
### ++less
<h3 id="++less"><code>++less</code></h3>
Parse unless
@ -150,7 +150,7 @@ connect `vex` with the following rule.
------------------------------------------------------------------------
### ++pfix
<h3 id="++pfix"><code>++pfix</code></h3>
Discard first rule
@ -171,7 +171,7 @@ ignoring the result of the first and producing the result of the second.
------------------------------------------------------------------------
### ++plug
<h3 id="++plug"><code>++plug</code></h3>
Parse to tuple
@ -204,7 +204,7 @@ more detailed explanation.
------------------------------------------------------------------------
### ++pose
<h3 id="++pose"><code>++pose</code></h3>
Parse options
@ -235,7 +235,7 @@ following rule `sab`. See also: the monad applicator [;\~]()
------------------------------------------------------------------------
### ++simu
<h3 id="++simu"><code>++simu</code></h3>
First and second
@ -266,7 +266,7 @@ connect `vex` with the following rule.
------------------------------------------------------------------------
### ++sfix
<h3 id="++sfix"><code>++sfix</code></h3>
Discard second rule

16
main/pub/doc/hoon/library/2ee.md
View File

@ -1,7 +1,7 @@
section 2eE, parsing (composers)
================================
### ++bass
<h3 id="++bass"><code>++bass</code></h3>
++ bass
|* [wuc=@ tyd=_rule]
@ -30,7 +30,7 @@ as atom of a base.
------------------------------------------------------------------------
### ++boss
<h3 id="++boss"><code>++boss</code></h3>
++ boss
|* [wuc=@ tyd=_rule]
@ -59,7 +59,7 @@ as atom of a base.
------------------------------------------------------------------------
### ++ifix
<h3 id="++ifix"><code>++ifix</code></h3>
++ ifix
|* [fel=[p=_rule q=_rule] hof=_rule]
@ -80,7 +80,7 @@ discarded.
------------------------------------------------------------------------
### ++more
<h3 id="++more"><code>++more</code></h3>
++ more
|* [bus=_rule fel=_rule]
@ -102,7 +102,7 @@ Parser modifier: using a delimiter rule, parse a list of matches.
------------------------------------------------------------------------
### ++most
<h3 id="++most"><code>++most</code></h3>
++ most
|* [bus=_rule fel=_rule]
@ -126,7 +126,7 @@ match.
------------------------------------------------------------------------
### ++plus
<h3 id="++plus"><code>++plus</code></h3>
++ plus |*(fel=_rule ;~(plug fel (star fel)))
@ -145,7 +145,7 @@ Parser modifier: parse list of at least one match
------------------------------------------------------------------------
### ++slug
<h3 id="++slug"><code>++slug</code></h3>
++ slug
|* raq=_|*([a=* b=*] [a b])
@ -167,7 +167,7 @@ matches.
------------------------------------------------------------------------
### ++star
<h3 id="++star"><code>++star</code></h3>
++ star :: 0 or more times
|* fel=_rule

70
main/pub/doc/hoon/library/2ef.md
View File

@ -1,7 +1,7 @@
section 2eF, parsing (ascii)
============================
### ++ace
<h3 id="++ace"><code>++ace</code></h3>
Parse space
@ -20,7 +20,7 @@ Parses ASCII character 32, space.
------------------------------------------------------------------------
### ++bar
<h3 id="++bar"><code>++bar</code></h3>
Parse vertical bar
@ -39,14 +39,14 @@ Parses ASCII character 124, the vertical bar.
------------------------------------------------------------------------
### ++bas
<h3 id="++bas"><code>++bas</code></h3>
Parse backslash
++ bas (just '\\')
Parses ASCII character 92, the backslash. Note the extra `\` in the slam
of `bas` with [`++just`]() is to escape the escape character, `\`.
of `bas` with [`++just`](/doc/hoon/library/2ec#++just) is to escape the escape character, `\`.
~zod/try=> (scan "\\" bas)
~~~5c.
@ -61,7 +61,7 @@ of `bas` with [`++just`]() is to escape the escape character, `\`.
------------------------------------------------------------------------
### ++buc
<h3 id="++buc"><code>++buc</code></h3>
Parse dollar sign
@ -80,7 +80,7 @@ Parses ASCII character 36, the dollar sign.
------------------------------------------------------------------------
### ++cab
<h3 id="++cab"><code>++cab</code></h3>
Parse underscore
@ -99,7 +99,7 @@ Parses ASCII character 95, the underscore.
------------------------------------------------------------------------
### ++cen
<h3 id="++cen"><code>++cen</code></h3>
Parses percent sign
@ -118,7 +118,7 @@ Parses ASCII character 37, the percent sign.
------------------------------------------------------------------------
### ++col
<h3 id="++col"><code>++col</code></h3>
Parse colon
@ -137,7 +137,7 @@ Parses ASCII character 58, the colon
------------------------------------------------------------------------
### ++com
<h3 id="++com"><code>++com</code></h3>
Parse comma
@ -156,7 +156,7 @@ Parses ASCII character 44, the comma.
------------------------------------------------------------------------
### ++doq
<h3 id="++doq"><code>++doq</code></h3>
Parse double quote
@ -179,7 +179,7 @@ Parses ASCII character 34, the double quote.
------------------------------------------------------------------------
### ++dot
<h3 id="++dot"><code>++dot</code></h3>
Parse period
@ -198,7 +198,7 @@ Parses ASCII character 46, the period.
------------------------------------------------------------------------
### ++fas
<h3 id="++fas"><code>++fas</code></h3>
Parse forward slash
@ -217,7 +217,7 @@ Parses ASCII character 47, the forward slash.
------------------------------------------------------------------------
### ++gal
<h3 id="++gal"><code>++gal</code></h3>
Parse less-than sign
@ -238,7 +238,7 @@ Parses ASCII character 60, the less-than sign.
------------------------------------------------------------------------
### ++gar
<h3 id="++gar"><code>++gar</code></h3>
Parse greater-than sign
@ -257,7 +257,7 @@ Parses ASCII character 62, the greater-than sign.
------------------------------------------------------------------------
### ++hax
<h3 id="++hax"><code>++hax</code></h3>
Parse number sign
@ -276,7 +276,7 @@ Parses ASCII character 35, the number sign.
------------------------------------------------------------------------
### ++kel
<h3 id="++kel"><code>++kel</code></h3>
Parse left curley bracket
@ -297,7 +297,7 @@ interpolation. To parse either of them, they must be escaped.
------------------------------------------------------------------------
### ++ker
<h3 id="++ker"><code>++ker</code></h3>
Parse right curley bracket
@ -318,7 +318,7 @@ interpolation. To parse either of them, they must be escaped.
------------------------------------------------------------------------
### ++ket
<h3 id="++ket"><code>++ket</code></h3>
Parse caret
@ -337,7 +337,7 @@ Parses ASCII character 94, the caret.
------------------------------------------------------------------------
### ++lus
<h3 id="++lus"><code>++lus</code></h3>
Parse plus sign
@ -356,7 +356,7 @@ Parses ASCII character 43, the plus sign.
------------------------------------------------------------------------
### ++hep
<h3 id="++hep"><code>++hep</code></h3>
Parse hyphen
@ -375,7 +375,7 @@ Parses ASCII character 45, the hyphen.
------------------------------------------------------------------------
### ++pel
<h3 id="++pel"><code>++pel</code></h3>
Parse left parenthesis
@ -394,7 +394,7 @@ Parses ASCII character 40, the left parenthesis.
------------------------------------------------------------------------
### ++pam
<h3 id="++pam"><code>++pam</code></h3>
Parse ampersand
@ -413,7 +413,7 @@ Parses ASCII character 38, the ampersand.
------------------------------------------------------------------------
### ++per
<h3 id="++per"><code>++per</code></h3>
Parse right parenthesis
@ -432,7 +432,7 @@ Parses ASCII character 41, the right parenthesis.
------------------------------------------------------------------------
### ++pat
<h3 id="++pat"><code>++pat</code></h3>
Parse "at" sign
@ -451,7 +451,7 @@ Parses ASCII character 64, the "at" sign.
------------------------------------------------------------------------
### ++sel
<h3 id="++sel"><code>++sel</code></h3>
Parse left square bracket
@ -472,7 +472,7 @@ Parses ASCII character 91, the left square bracket.
------------------------------------------------------------------------
### ++sem
<h3 id="++sem"><code>++sem</code></h3>
Parse semicolon
@ -480,7 +480,7 @@ Parse semicolon
Parses ASCII character 59, the semicolon.
### Examples
<h3 id="Examples"><code>Examples</code></h3>
~zod/try=> (scan ";" sem)
~~~3b.
@ -493,7 +493,7 @@ Parses ASCII character 59, the semicolon.
------------------------------------------------------------------------
### ++ser
<h3 id="++ser"><code>++ser</code></h3>
Parse right square bracket
@ -512,7 +512,7 @@ Parses ASCII character 93, the right square bracket.
------------------------------------------------------------------------
### ++sig
<h3 id="++sig"><code>++sig</code></h3>
Parse tilde
@ -531,7 +531,7 @@ Parses ASCII character 126, the tilde.
------------------------------------------------------------------------
### ++soq
<h3 id="++soq"><code>++soq</code></h3>
Parse single quote
@ -551,7 +551,7 @@ Parses ASCII character 39, soq. Note the extra '' is to escape the first
------------------------------------------------------------------------
### ++tar
<h3 id="++tar"><code>++tar</code></h3>
Parse asterisk
@ -570,7 +570,7 @@ Parses ASCII character 42, the asterisk.
------------------------------------------------------------------------
### ++tec
<h3 id="++tec"><code>++tec</code></h3>
Parse backtick
@ -590,7 +590,7 @@ accent".
------------------------------------------------------------------------
### ++tis
<h3 id="++tis"><code>++tis</code></h3>
Parse equals sign
@ -609,7 +609,7 @@ Parses ASCII character 61, the equals sign.
------------------------------------------------------------------------
### ++wut
<h3 id="++wut"><code>++wut</code></h3>
Parses question mark
@ -628,7 +628,7 @@ Parses ASCII character 63, wut.
------------------------------------------------------------------------
### ++zap
<h3 id="++zap"><code>++zap</code></h3>
Exclamation point

20
main/pub/doc/hoon/library/2eg.md
View File

@ -1,7 +1,7 @@
section 2eG, parsing (whitespace)
=================================
### ++dog
<h3 id="++dog"><code>++dog</code></h3>
`.` optional gap
@ -17,7 +17,7 @@ Dot followed by an optional gap, used in numbers.
------------------------------------------------------------------------
### ++doh
<h3 id="++doh"><code>++doh</code></h3>
`@p` separator
@ -37,7 +37,7 @@ Phonetic base phrase separator
------------------------------------------------------------------------
### ++dun
<h3 id="++dun"><code>++dun</code></h3>
`--` to `~`
@ -52,7 +52,7 @@ Parse phep, `--`, to null, `~`.
------------------------------------------------------------------------
### ++duz
<h3 id="++duz"><code>++duz</code></h3>
`==` to `~`
@ -67,7 +67,7 @@ Parse stet, `==`, to null `~`.
------------------------------------------------------------------------
### ++gah
<h3 id="++gah"><code>++gah</code></h3>
Newline or ' '
@ -96,7 +96,7 @@ Whitespace component, either newline or space.
------------------------------------------------------------------------
### ++gap
<h3 id="++gap"><code>++gap</code></h3>
Plural whitespace
@ -106,7 +106,7 @@ Separates tall runes
------------------------------------------------------------------------
### ++gaq
<h3 id="++gaq"><code>++gaq</code></h3>
End of line
@ -120,7 +120,7 @@ Two spaces, a newline, or comment.
------------------------------------------------------------------------
### ++gaw
<h3 id="++gaw"><code>++gaw</code></h3>
Classic whitespace
@ -130,7 +130,7 @@ Terran whitespace
------------------------------------------------------------------------
### ++gay
<h3 id="++gay"><code>++gay</code></h3>
Optional gap.
@ -140,7 +140,7 @@ Optional gap.
------------------------------------------------------------------------
### ++vul
<h3 id="++vul"><code>++vul</code></h3>
++ vul %- cold :- ~ :: comments
;~ plug col col

52
main/pub/doc/hoon/library/2eh.md
View File

@ -1,7 +1,7 @@
section 2eH, parsing (idioms)
=============================
### ++alf
<h3 id="++alf"><code>++alf</code></h3>
Alphabetic characters
@ -18,7 +18,7 @@ Parse alphabetic characters, both upper and lowercase.
------------------------------------------------------------------------
### ++aln
<h3 id="++aln"><code>++aln</code></h3>
Alphanumeric characters
@ -35,7 +35,7 @@ Parse alphanumeric characters - both alphabetic characters and numbers.
------------------------------------------------------------------------
### ++alp
<h3 id="++alp"><code>++alp</code></h3>
Alphanumeric and `-`
@ -52,7 +52,7 @@ Parse alphanumeric strings and hep, "-".
------------------------------------------------------------------------
### ++bet
<h3 id="++bet"><code>++bet</code></h3>
Axis syntax `-`, `+`
@ -67,7 +67,7 @@ Parse the hep and lus axis syntax.
------------------------------------------------------------------------
### ++bin
<h3 id="++bin"><code>++bin</code></h3>
Binary to atom
@ -87,7 +87,7 @@ representation.
------------------------------------------------------------------------
### ++but
<h3 id="++but"><code>++but</code></h3>
Binary digit
@ -108,7 +108,7 @@ Parse a single binary digit.
------------------------------------------------------------------------
### ++cit
<h3 id="++cit"><code>++cit</code></h3>
Octal digit
@ -129,7 +129,7 @@ Parse a single octal digit.
------------------------------------------------------------------------
### ++dem
<h3 id="++dem"><code>++dem</code></h3>
Decimal to atom
@ -148,7 +148,7 @@ Parse a decimal number to an atom.
------------------------------------------------------------------------
### ++dit
<h3 id="++dit"><code>++dit</code></h3>
Decimal digit
@ -165,7 +165,7 @@ Parse a single decimal digit.
------------------------------------------------------------------------
### ++gul
<h3 id="++gul"><code>++gul</code></h3>
Axis syntax `<` or `>`
@ -180,7 +180,7 @@ Parse the axis gal and gar axis syntax.
------------------------------------------------------------------------
### ++gon
<h3 id="++gon"><code>++gon</code></h3>
Long numbers
@ -196,7 +196,7 @@ break characters bas and fas.
------------------------------------------------------------------------
### ++hex
<h3 id="++hex"><code>++hex</code></h3>
Hex to atom
@ -221,7 +221,7 @@ Parse any hexadecimal number to an atom.
------------------------------------------------------------------------
### ++hig
<h3 id="++hig"><code>++hig</code></h3>
Uppercase
@ -240,7 +240,7 @@ Parse a single uppercase letter.
------------------------------------------------------------------------
### ++hit
<h3 id="++hit"><code>++hit</code></h3>
Hex digits
@ -263,7 +263,7 @@ Parse a single hexadecimal digit.
------------------------------------------------------------------------
### ++low
<h3 id="++low"><code>++low</code></h3>
Lowercase
@ -282,7 +282,7 @@ Parse a single lowercase letter.
------------------------------------------------------------------------
### ++mes
<h3 id="++mes"><code>++mes</code></h3>
Hexbyte
@ -301,7 +301,7 @@ Parse a hexbyte.
------------------------------------------------------------------------
### ++nix
<h3 id="++nix"><code>++nix</code></h3>
Letters, `-`, and `_`
@ -316,7 +316,7 @@ Letters, `-`, and `_`
------------------------------------------------------------------------
### ++nud
<h3 id="++nud"><code>++nud</code></h3>
Numeric
@ -335,7 +335,7 @@ Parse a numeric character - A number.
------------------------------------------------------------------------
### ++prn
<h3 id="++prn"><code>++prn</code></h3>
Printable character
@ -353,7 +353,7 @@ Parse any printable character
------------------------------------------------------------------------
### ++qat
<h3 id="++qat"><code>++qat</code></h3>
Chars in blockcord
@ -376,7 +376,7 @@ Parse character in cord block.
------------------------------------------------------------------------
### ++qit
<h3 id="++qit"><code>++qit</code></h3>
Chars in cord
@ -406,7 +406,7 @@ Parse an individual character to its cord atom representation.
------------------------------------------------------------------------
### ++qut
<h3 id="++qut"><code>++qut</code></h3>
Cord
@ -439,7 +439,7 @@ triple-soq cord which must be in an indented block.
------------------------------------------------------------------------
### ++soqs
<h3 id="++soqs"><code>++soqs</code></h3>
Delimiting `'''`
@ -455,7 +455,7 @@ Triple single quote
------------------------------------------------------------------------
### ++sym
<h3 id="++sym"><code>++sym</code></h3>
Term
@ -476,7 +476,7 @@ A term: a letter(lowercase), followed by letters, numbers, or `-`.
------------------------------------------------------------------------
### ++ven
<h3 id="++ven"><code>++ven</code></h3>
`+>-` axis syntax
@ -506,7 +506,7 @@ Axis syntax parser
------------------------------------------------------------------------
### ++vit
<h3 id="++vit"><code>++vit</code></h3>
Base64 digit

8
main/pub/doc/hoon/library/2ei.md
View File

@ -1,7 +1,7 @@
section 2eI, parsing (external)
===============================
### ++rash
<h3 id="++rash"><code>++rash</code></h3>
Parse or crash
@ -29,7 +29,7 @@ parsed.
------------------------------------------------------------------------
### ++rush
<h3 id="++rush"><code>++rush</code></h3>
Parse or null
@ -55,7 +55,7 @@ entirely parsed.
------------------------------------------------------------------------
### ++rust
<h3 id="++rust"><code>++rust</code></h3>
Parse tape or null
@ -79,7 +79,7 @@ entirely parsed.
------------------------------------------------------------------------
### ++scan
<h3 id="++scan"><code>++scan</code></h3>
Parse tape or crash

38
main/pub/doc/hoon/library/2ej.md
View File

@ -1,7 +1,7 @@
section 2eJ, formatting (basic text)
====================================
### ++cass
<h3 id="++cass"><code>++cass</code></h3>
To lowercase
@ -26,7 +26,7 @@ Produce the case insensitive (all lowercase) cord of a tape.
------------------------------------------------------------------------
### ++cuss
<h3 id="++cuss"><code>++cuss</code></h3>
To uppercase
@ -53,7 +53,7 @@ letters, as a cord.
------------------------------------------------------------------------
### ++crip
<h3 id="++crip"><code>++crip</code></h3>
Tape to cord
@ -72,7 +72,7 @@ Produce cord from a tape.
------------------------------------------------------------------------
### ++mesc
<h3 id="++mesc"><code>++mesc</code></h3>
Escape special chars
@ -88,7 +88,7 @@ Escape special chars
[i.vib $(vib t.vib)]
::
Escape special characters, used in [`++show`]()
Escape special characters, used in [`++show`](/doc/hoon/library/2ez#++show)
`vib` is a [tape]().
@ -101,7 +101,7 @@ Escape special characters, used in [`++show`]()
------------------------------------------------------------------------
### ++runt
<h3 id="++runt"><code>++runt</code></h3>
Prepend `n` times
@ -126,7 +126,7 @@ Add `a` repetitions of character `b` to the head of `c`
------------------------------------------------------------------------
### ++sand
<h3 id="++sand"><code>++sand</code></h3>
Soft-cast by odor
@ -149,7 +149,7 @@ Soft-cast validity by odor.
------------------------------------------------------------------------
### ++sane
<h3 id="++sane"><code>++sane</code></h3>
Check odor validity
@ -204,7 +204,7 @@ Check validity by odor. Produces a gate.
------------------------------------------------------------------------
### ++trim
<h3 id="++trim"><code>++trim</code></h3>
Tape split
@ -232,7 +232,7 @@ Split first `a` characters off tape.
------------------------------------------------------------------------
### ++trip
<h3 id="++trip"><code>++trip</code></h3>
Cord to tape
@ -257,7 +257,7 @@ Produce tape from cord.
------------------------------------------------------------------------
### ++teff
<h3 id="++teff"><code>++teff</code></h3>
UTF8 Length
@ -281,7 +281,7 @@ Number of utf8 bytes.
------------------------------------------------------------------------
### ++turf
<h3 id="++turf"><code>++turf</code></h3>
UTF8 to UTF32 cord
@ -322,7 +322,7 @@ Convert utf8 ([cord]()) to utf32 codepoints.
------------------------------------------------------------------------
### ++tuba
<h3 id="++tuba"><code>++tuba</code></h3>
UTF8 to UTF32 tape
@ -343,7 +343,7 @@ Convert tape to list of codepoints.
------------------------------------------------------------------------
### ++tufa
<h3 id="++tufa"><code>++tufa</code></h3>
UTF32 to UTF8 tape
@ -365,7 +365,7 @@ Wrap list of utf32 codepoints to utf8 [tape]().
------------------------------------------------------------------------
### ++tuft
<h3 id="++tuft"><code>++tuft</code></h3>
UTF32 to UTF8 text
@ -411,7 +411,7 @@ Convert utf32 glyph to
------------------------------------------------------------------------
### ++wack
<h3 id="++wack"><code>++wack</code></h3>
Coin format encode
@ -443,7 +443,7 @@ Escape span `~` as `~~` and `_` as `~-`. Used for printing.
------------------------------------------------------------------------
### ++wick
<h3 id="++wick"><code>++wick</code></h3>
Coin format decode
@ -472,7 +472,7 @@ Unescape span `~~` as `~` and `~-` as `_`.
------------------------------------------------------------------------
### ++woad
<h3 id="++woad"><code>++woad</code></h3>
Unescape cord
@ -519,7 +519,7 @@ Unescape cord codepoints.
------------------------------------------------------------------------
### ++wood
<h3 id="++wood"><code>++wood</code></h3>
Escape cord

16
main/pub/doc/hoon/library/2ek.md
View File

@ -1,7 +1,7 @@
section 2eK, formatting (layout)
================================
### ++re
<h3 id="++re"><code>++re</code></h3>
Pretty-printing engine
@ -10,12 +10,12 @@ Pretty-printing engine
Pretty-printing engine.
`tac` is a [`++tank`]().
`tac` is a [`++tank`](/doc/hoon/library/1#++tank).
/~zod/try=> ~(. re leaf/"ham")
<2.ghl [[%leaf ""] <414.gly 100.xkc 1.ypj %164>]>
### ++ram
<h3 id="++ram"><code>++ram</code></h3>
Flatten to tape
@ -42,7 +42,7 @@ Flatten tank out into a tape.
/~zod/try=> ~(ram re rose/["." "(" ")"]^~[leaf/"bar" leaf/"baz" leaf/"bam"])
"(bar.baz.bam)"
### ++win
<h3 id="++win"><code>++win</code></h3>
Render at indent
@ -99,13 +99,13 @@ Render at indent level `tab` and width `edg`.
/~zod/try=> (~(win re rose/["--" "[" "]"]^~[leaf/"1423" leaf/"2316"]) 0 10)
<<"[ 1423" " 2316" "]">>
### ++din
<h3 id="++din"><code>++din</code></h3>
++ din (mod (add 2 tab) (mul 2 (div edg 3)))
XX document
### ++fit
<h3 id="++fit"><code>++fit</code></h3>
Fit on one line test
@ -113,7 +113,7 @@ Fit on one line test
Determine whether `tac` fits on one line. Internal to `++win`
### ++rig
<h3 id="++rig"><code>++rig</code></h3>
Wrap in `\/`
@ -139,7 +139,7 @@ Wrap in `\/`
Wrap tape in `\/` if it doesn't fit at current indentation. Internal to
`++win`
### ++wig
<h3 id="++wig"><code>++wig</code></h3>
`++win` render tape

164
main/pub/doc/hoon/library/2el.md
View File

@ -1,7 +1,7 @@
section 2eL, formatting (path)
==============================
### ++ab
<h3 id="++ab"><code>++ab</code></h3>
Primitive parser engine
@ -15,7 +15,7 @@ A core containing numeric parser primitives.
------------------------------------------------------------------------
### ++bix
<h3 id="++bix"><code>++bix</code></h3>
Parse hex pair
@ -32,7 +32,7 @@ Parsing rule. Parses a pair of base-16 digits. Used in escapes.
------------------------------------------------------------------------
### ++hif
<h3 id="++hif"><code>++hif</code></h3>
Parse phonetic pair
@ -48,7 +48,7 @@ encoded phonetically.
------------------------------------------------------------------------
### ++huf
<h3 id="++huf"><code>++huf</code></h3>
Parse two phonetic pairs
@ -68,7 +68,7 @@ of two two-byte pairs that are encoded (and scrambled) phonetically.
------------------------------------------------------------------------
### ++hyf
<h3 id="++hyf"><code>++hyf</code></h3>
Parse 8 phonetic bytes
@ -84,7 +84,7 @@ phonetic bytes.
------------------------------------------------------------------------
### ++pev
<h3 id="++pev"><code>++pev</code></h3>
Parse \<= 5 base-32
@ -104,7 +104,7 @@ Parsing rule. Parses up to five base-32 digits without a leading zero.
------------------------------------------------------------------------
### ++pew
<h3 id="++pew"><code>++pew</code></h3>
Parse \<= 5 base-64
@ -127,7 +127,7 @@ Parsing rule. Parses up to five base-64 digits without a leading zero.
------------------------------------------------------------------------
### ++piv
<h3 id="++piv"><code>++piv</code></h3>
Parse 5 base-32
@ -143,7 +143,7 @@ Parsing rule. Parses exactly five base-32 digits.
------------------------------------------------------------------------
### ++piw
<h3 id="++piw"><code>++piw</code></h3>
Parse 5 base-64
@ -159,7 +159,7 @@ Parsing rule. Parses exactly five base-64 digits.
------------------------------------------------------------------------
### ++qeb
<h3 id="++qeb"><code>++qeb</code></h3>
Parse \<= 4 binary
@ -183,7 +183,7 @@ a leading zero.
------------------------------------------------------------------------
### ++qex
<h3 id="++qex"><code>++qex</code></h3>
Parse \<= 4 hex
@ -205,7 +205,7 @@ without a leading zero.
------------------------------------------------------------------------
### ++qib
<h3 id="++qib"><code>++qib</code></h3>
Parse 4 binary
@ -223,7 +223,7 @@ Parsing rule. Parses exactly four binary digits.
------------------------------------------------------------------------
### ++qix
<h3 id="++qix"><code>++qix</code></h3>
Parse 4 hex
@ -241,7 +241,7 @@ Parsing rule. Parses exactly four hexadecimal digits.
------------------------------------------------------------------------
### ++seb
<h3 id="++seb"><code>++seb</code></h3>
Parse 1
@ -260,7 +260,7 @@ Parsing rule. Parses the number 1.
------------------------------------------------------------------------
### ++sed
<h3 id="++sed"><code>++sed</code></h3>
Parse decimal
@ -276,7 +276,7 @@ Parsing rule. Parses a nonzero decimal digit.
------------------------------------------------------------------------
### ++sev
<h3 id="++sev"><code>++sev</code></h3>
Parse base-32
@ -292,7 +292,7 @@ Parsing rule. Parses a nonzero base-32 digit
------------------------------------------------------------------------
### ++sew
<h3 id="++sew"><code>++sew</code></h3>
Parse base-64
@ -308,7 +308,7 @@ Parsing rule. Parses a nonzero base-64 digit
------------------------------------------------------------------------
### ++sex
<h3 id="++sex"><code>++sex</code></h3>
Parse hex
@ -324,7 +324,7 @@ Parsing rule. Parses a nonzero hexadecimal digit.
------------------------------------------------------------------------
### ++sib
<h3 id="++sib"><code>++sib</code></h3>
Parse binary
@ -339,7 +339,7 @@ Parsing rule. Parses a binary digit.
------------------------------------------------------------------------
### ++sid
<h3 id="++sid"><code>++sid</code></h3>
Parse decimal
@ -352,7 +352,7 @@ Parsing rule. Parses a decimal digit.
------------------------------------------------------------------------
### ++siv
<h3 id="++siv"><code>++siv</code></h3>
Parse base-32
@ -365,7 +365,7 @@ Parsing rule. Parses a base-32 digit.
------------------------------------------------------------------------
### ++siw
<h3 id="++siw"><code>++siw</code></h3>
Parse base-64
@ -378,7 +378,7 @@ Parsing rule. Parses a base-64 digit.
------------------------------------------------------------------------
### ++six
<h3 id="++six"><code>++six</code></h3>
Parse hex
@ -391,7 +391,7 @@ Parsing rule. Parses a hexadecimal digit.
------------------------------------------------------------------------
### ++sov
<h3 id="++sov"><code>++sov</code></h3>
Parse base-32
@ -404,7 +404,7 @@ Parsing rule. Parses a base-32 letter.
------------------------------------------------------------------------
### ++sow
<h3 id="++sow"><code>++sow</code></h3>
Parse base-64
@ -422,7 +422,7 @@ Parsing rule. Parses a base-64 letter/symbol.
------------------------------------------------------------------------
### ++sox
<h3 id="++sox"><code>++sox</code></h3>
Parse hex letter
@ -435,7 +435,7 @@ Parsing rule. Parses a hexadecimal letter.
------------------------------------------------------------------------
### ++ted
<h3 id="++ted"><code>++ted</code></h3>
Parse \<= 3 decimal
@ -456,7 +456,7 @@ leading zero.
------------------------------------------------------------------------
### ++tip
<h3 id="++tip"><code>++tip</code></h3>
Leading phonetic byte
@ -472,7 +472,7 @@ syllable.
------------------------------------------------------------------------
### ++tiq
<h3 id="++tiq"><code>++tiq</code></h3>
Trailing phonetic syllable
@ -488,7 +488,7 @@ syllable.
------------------------------------------------------------------------
### ++tid
<h3 id="++tid"><code>++tid</code></h3>
Parse 3 decimal digits
@ -504,7 +504,7 @@ Parsing rule. Parses exactly three decimal digits.
------------------------------------------------------------------------
### ++til
<h3 id="++til"><code>++til</code></h3>
Parse 3 lowercase
@ -522,7 +522,7 @@ Parsing rule. Parses exactly three lowercase letters.
------------------------------------------------------------------------
### ++urs
<h3 id="++urs"><code>++urs</code></h3>
Parse span characters
@ -539,7 +539,7 @@ Parsing rule. Parses characters from an atom of the span odor [`@ta`]().
------------------------------------------------------------------------
### ++urt
<h3 id="++urt"><code>++urt</code></h3>
Parse non-`_` span
@ -555,7 +555,7 @@ for cab, `_`.
------------------------------------------------------------------------
### ++voy
<h3 id="++voy"><code>++voy</code></h3>
Parse bas, soq, or bix
@ -571,7 +571,7 @@ byte.
------------------------------------------------------------------------
### ++ag
<h3 id="++ag"><code>++ag</code></h3>
Top-level atom parser engine
@ -585,7 +585,7 @@ A core containing top-level atom parsers.
------------------------------------------------------------------------
### ++ape
<h3 id="++ape"><code>++ape</code></h3>
Parse 0 or rule
@ -600,7 +600,7 @@ Parser modifier. Parses 0 or the sample rule `fel`.
------------------------------------------------------------------------
### ++bay
<h3 id="++bay"><code>++bay</code></h3>
Parses binary number
@ -613,7 +613,7 @@ Parsing rule. Parses a binary number without a leading zero.
------------------------------------------------------------------------
### ++bip
<h3 id="++bip"><code>++bip</code></h3>
Parse IPv6
@ -629,7 +629,7 @@ Parsing rule. Parses a [`@is`](), an IPv6 address.
------------------------------------------------------------------------
### ++dem
<h3 id="++dem"><code>++dem</code></h3>
Parse decimal with dots
@ -644,7 +644,7 @@ Parsing rule. Parses a decimal number that includes dot separators.
------------------------------------------------------------------------
### ++dim
<h3 id="++dim"><code>++dim</code></h3>
Parse decimal number
@ -660,7 +660,7 @@ Parsing rule. Parses a decimal number without a leading zero.
------------------------------------------------------------------------
### ++dum
<h3 id="++dum"><code>++dum</code></h3>
Parse decimal with leading `0`
@ -677,7 +677,7 @@ Parsing rule. Parses a decmial number with leading zeroes.
------------------------------------------------------------------------
### ++fed
<h3 id="++fed"><code>++fed</code></h3>
Parse phonetic base
@ -707,7 +707,7 @@ Parsing rule. Parses an atom of odor [`@p`](), the phonetic base.
------------------------------------------------------------------------
### ++hex
<h3 id="++hex"><code>++hex</code></h3>
Parse hex
@ -726,7 +726,7 @@ Parsing rule. Parses a hexadecimal number
------------------------------------------------------------------------
### ++lip
<h3 id="++lip"><code>++lip</code></h3>
Parse IPv4 address
@ -744,7 +744,7 @@ Parsing rule. Parses an IPv4 address.
------------------------------------------------------------------------
### ++viz
<h3 id="++viz"><code>++viz</code></h3>
Parse Base-32 with dots
@ -757,7 +757,7 @@ Parsing rule. Parses a Base-32 number with dot separators.
------------------------------------------------------------------------
### ++vum
<h3 id="++vum"><code>++vum</code></h3>
Parse base-32 string
@ -770,7 +770,7 @@ Parsing rule. Parses a raw base-32 string.
------------------------------------------------------------------------
### ++wiz
<h3 id="++wiz"><code>++wiz</code></h3>
Parse base-64
@ -785,7 +785,7 @@ Parsing rule. Parses a base-64 number.
------------------------------------------------------------------------
### ++co
<h3 id="++co"><code>++co</code></h3>
Literal rendering engine
@ -809,7 +809,7 @@ A [door]() that contains arms that operate on the sample coin `lot`.
------------------------------------------------------------------------
### ++rear
<h3 id="++rear"><code>++rear</code></h3>
Prepend & render as tape
@ -826,7 +826,7 @@ Renders a coin `lot` as a [tape]() prepended to the sample tape `rom`.
------------------------------------------------------------------------
### ++rent
<h3 id="++rent"><code>++rent</code></h3>
Render as span
@ -843,7 +843,7 @@ Renders a coin `lot` as a span.
------------------------------------------------------------------------
### ++rend
<h3 id="++rend"><code>++rend</code></h3>
Render as tape
@ -1073,7 +1073,7 @@ Renders a coin `lot` as a tape.
------------------------------------------------------------------------
### ++ne
<h3 id="++ne"><code>++ne</code></h3>
Digit rendering engine
@ -1090,7 +1090,7 @@ A [door]() containing arms that render digits at bases 10, 16, 32, and
------------------------------------------------------------------------
### ++d
<h3 id="++d"><code>++d</code></h3>
Render decimal
@ -1105,7 +1105,7 @@ Renders a decimal digit as an atom of an ACII byte value.
------------------------------------------------------------------------
### ++x
<h3 id="++x"><code>++x</code></h3>
Render hex
@ -1122,7 +1122,7 @@ Renders a hexadecimal digit as an atom of an ASCII byte value.
------------------------------------------------------------------------
### ++v
<h3 id="++v"><code>++v</code></h3>
Render base-32
@ -1139,7 +1139,7 @@ Renders a base-32 digit as an atom of an ASCII byte value.
------------------------------------------------------------------------
### ++w
<h3 id="++w"><code>++w</code></h3>
Render base-64
@ -1168,7 +1168,7 @@ Renders a base-64 digit as an atom of an ASCII byte value.
------------------------------------------------------------------------
### ++mu
<h3 id="++mu"><code>++mu</code></h3>
Core used to scramble 16-bit atoms
@ -1188,7 +1188,7 @@ relationship between a destroyer and its cruiser.
------------------------------------------------------------------------
### ++zag
<h3 id="++zag"><code>++zag</code></h3>
Add bottom into top
@ -1207,7 +1207,7 @@ destroyer.
------------------------------------------------------------------------
### ++zig
<h3 id="++zig"><code>++zig</code></h3>
Subtract bottom from top
@ -1227,7 +1227,7 @@ destroyer.
------------------------------------------------------------------------
### ++zug
<h3 id="++zug"><code>++zug</code></h3>
Concatenate into atom
@ -1245,7 +1245,7 @@ destroyer name.
------------------------------------------------------------------------
### ++so
<h3 id="++so"><code>++so</code></h3>
Coin parser engine
@ -1259,7 +1259,7 @@ Core containing arms that parse [`++coin`]s.
------------------------------------------------------------------------
### ++bisk
<h3 id="++bisk"><code>++bisk</code></h3>
Parse odor-atom pair
@ -1287,7 +1287,7 @@ producing a [`++dime`]().
------------------------------------------------------------------------
### ++crub
<h3 id="++crub"><code>++crub</code></h3>
Parse `@da`, `@dr`, `@p`, `@t`
@ -1364,7 +1364,7 @@ and [`@t`](), producing a [`++dime`]().
------------------------------------------------------------------------
### ++nuck
<h3 id="++nuck"><code>++nuck</code></h3>
Top-level coin parser
@ -1406,7 +1406,7 @@ corresponding [`++coin`]() parser.
------------------------------------------------------------------------
### ++nusk
<h3 id="++nusk"><code>++nusk</code></h3>
Parse coin literal with escapes
@ -1427,7 +1427,7 @@ formatting).
------------------------------------------------------------------------
### ++perd
<h3 id="++perd"><code>++perd</code></h3>
Parsing rule.
@ -1451,7 +1451,7 @@ prefixes.
------------------------------------------------------------------------
### ++royl
<h3 id="++royl"><code>++royl</code></h3>
Parse dime float
@ -1487,7 +1487,7 @@ Parsing rule. Parses a number into a [`++dime`]() float.
------------------------------------------------------------------------
### ++royl-cell
<h3 id="++royl-cell"><code>++royl-cell</code></h3>
XX still not fully functional
@ -1504,7 +1504,7 @@ Intermediate parsed float convereter
------------------------------------------------------------------------
### ++tash
<h3 id="++tash"><code>++tash</code></h3>
Parse signed dime
@ -1533,7 +1533,7 @@ Parsing rule. Parses a signed number into a [`++dime`]().
------------------------------------------------------------------------
### ++twid
<h3 id="++twid"><code>++twid</code></h3>
Parse coins without `~` prefix
@ -1559,7 +1559,7 @@ Parsing rule. Parses coins after a leading sig, `~`.
------------------------------------------------------------------------
### ++zust
<h3 id="++zust"><code>++zust</code></h3>
Parse prefixed dimes from `@if`, `@f`, `@rd`
@ -1590,7 +1590,7 @@ Parsing rule. Parses an atom of either [`@if`]() (IP address), [`@f`]()
------------------------------------------------------------------------
### ++scot
<h3 id="++scot"><code>++scot</code></h3>
Render dime as cord
@ -1619,7 +1619,7 @@ Renders a dime `mol` as a cord.
------------------------------------------------------------------------
### ++scow
<h3 id="++scow"><code>++scow</code></h3>
Render dime as tape
@ -1640,7 +1640,7 @@ Renders `mol` as a tape.
------------------------------------------------------------------------
### ++slat
<h3 id="++slat"><code>++slat</code></h3>
Curried slaw
@ -1664,7 +1664,7 @@ odor specified by `mod`.
------------------------------------------------------------------------
### ++slav
<h3 id="++slav"><code>++slav</code></h3>
Demand: parse span with input odor
@ -1696,7 +1696,7 @@ if it failes to parse.
------------------------------------------------------------------------
### ++slaw
<h3 id="++slaw"><code>++slaw</code></h3>
Parse span to input odor
@ -1732,7 +1732,7 @@ Parses a span `txt` to an atom of the odor specified by `mod`.
------------------------------------------------------------------------
### ++slay
<h3 id="++slay"><code>++slay</code></h3>
Parse span to coin
@ -1777,7 +1777,7 @@ Parses a span `txt` to the unit of a [`++coin`]().
------------------------------------------------------------------------
### ++smyt
<h3 id="++smyt"><code>++smyt</code></h3>
Render path as tank
@ -1809,7 +1809,7 @@ pretty-printing.
------------------------------------------------------------------------
### ++spat
<h3 id="++spat"><code>++spat</code></h3>
Render path as cord
@ -1828,7 +1828,7 @@ Renders a path `pax` as cord.
------------------------------------------------------------------------
### ++spud
<h3 id="++spud"><code>++spud</code></h3>
Render path as tape
@ -1847,7 +1847,7 @@ Renders a path `pax` as [tape]().
------------------------------------------------------------------------
### ++stab
<h3 id="++stab"><code>++stab</code></h3>
Parse span to path
@ -1855,7 +1855,7 @@ Parse span to path
|= zep=@ta ^- path
(rash zep ;~(pfix fas ;~(sfix (more fas urs:ab) fas)))
Parsing rule. Parses a span `zep` to a static [`++path`]().
Parsing rule. Parses a span `zep` to a static [`++path`](/doc/hoon/library/1#++path).
~zod/try=> (stab '/as/lek/tor')
/as/lek/tor

94
main/pub/doc/hoon/library/2em.md
View File

@ -1,7 +1,7 @@
section 2eM, regular-expressions
================================
### ++pars
<h3 id="++pars"><code>++pars</code></h3>
++ pars
|= [a=tape] :: parse tape to rege
@ -66,44 +66,44 @@ Parse regular expression
~zod/try=> (pars "a\{1,20}")
[~ [%betw p=[%lite p=~~a] q=1 r=20]]
### ++rags
<h3 id="++rags"><code>++rags</code></h3>
++ rags :: rege parsers
=> |%
Regex parser arms
### ++nor
<h3 id="++nor"><code>++nor</code></h3>
++ nor ;~(less (mask "^$()|*?+.[\\") (shim 1 127)) :: non-control char
XX document
### ++les
<h3 id="++les"><code>++les</code></h3>
++ les ;~(less bas asp) :: not backslash
XX document
### ++lep
<h3 id="++lep"><code>++lep</code></h3>
++ lep ;~(less (mask "^[]\\") asp) :: charset non-control
XX document
### ++asp
<h3 id="++asp"><code>++asp</code></h3>
++ asp (shim 32 126) :: printable ascii
XX document
### ++alb
<h3 id="++alb"><code>++alb</code></h3>
++ alb ;~(less ser asp) :: charset literal char
XX document
### ++mis
<h3 id="++mis"><code>++mis</code></h3>
++ mis ;~(less aln asp) :: non alphanumeric
--
@ -111,7 +111,7 @@ XX document
XX document
### ++apex
<h3 id="++apex"><code>++apex</code></h3>
++ apex :: top level
%+ knee *rege |. ~+
@ -124,7 +124,7 @@ XX document
XX document
### ++mall
<h3 id="++mall"><code>++mall</code></h3>
++ mall
%+ knee *rege |. ~+
@ -133,7 +133,7 @@ XX document
XX document
### ++bets
<h3 id="++bets"><code>++bets</code></h3>
++ bets
%+ knee *rege |. ~+
@ -162,7 +162,7 @@ XX document
XX document
### ++ranc
<h3 id="++ranc"><code>++ranc</code></h3>
++ ranc
|= [a=@ b=@]
@ -172,14 +172,14 @@ XX document
XX document
### ++flap
<h3 id="++flap"><code>++flap</code></h3>
++ flap |=(a=@ (mix a (dec (bex 256))))
::
XX document
### ++rang
<h3 id="++rang"><code>++rang</code></h3>
++ rang
%+ sear |=([a=@ b=@] ?:((lte a b) (some [a b]) ~))
@ -188,7 +188,7 @@ XX document
XX document
### ++chun
<h3 id="++chun"><code>++chun</code></h3>
++ chun
%+ knee *rege |. ~+
@ -212,7 +212,7 @@ XX document
XX document
### ++seac
<h3 id="++seac"><code>++seac</code></h3>
++ seac
|= tub=nail
@ -225,7 +225,7 @@ XX document
XX document
### ++sead
<h3 id="++sead"><code>++sead</code></h3>
++ sead
%+ knee *@ |. ~+
@ -264,7 +264,7 @@ XX document
XX document
### ++sade
<h3 id="++sade"><code>++sade</code></h3>
++ sade
%+ knee *@ |. ~+
@ -277,7 +277,7 @@ XX document
XX document
### ++seap
<h3 id="++seap"><code>++seap</code></h3>
++ seap
%+ knee *@ |. ~+
@ -305,7 +305,7 @@ XX document
XX document
### ++cape
<h3 id="++cape"><code>++cape</code></h3>
++ cape
%+ knee *tape |. ~+
@ -318,7 +318,7 @@ XX document
XX document
### ++chas
<h3 id="++chas"><code>++chas</code></h3>
++ chas :: ascii character set
=- (sear ~(get by -) sym)
@ -350,37 +350,37 @@ XX document
XX document
### ++cntrl
<h3 id="++cntrl"><code>++cntrl</code></h3>
++ cntrl :(con (ranc 0 31) (bex 127))
XX document
### ++digit
<h3 id="++digit"><code>++digit</code></h3>
++ digit (ranc '0' '9')
XX document
### ++graph
<h3 id="++graph"><code>++graph</code></h3>
++ graph (ranc 33 126)
XX document
### ++lower
<h3 id="++lower"><code>++lower</code></h3>
++ lower (ranc 'a' 'z')
XX document
### ++print
<h3 id="++print"><code>++print</code></h3>
++ print (ranc 32 126)
XX document
### ++punct
<h3 id="++punct"><code>++punct</code></h3>
++ punct ;: con
(ranc '!' '/')
@ -391,38 +391,38 @@ XX document
XX document
### ++space
<h3 id="++space"><code>++space</code></h3>
++ space :(con (ranc 9 13) (bex ' '))
XX document
### ++upper
<h3 id="++upper"><code>++upper</code></h3>
++ upper (ranc 'A' 'Z')
XX document
### ++white
<h3 id="++white"><code>++white</code></h3>
++ white :(con (bex ' ') (ranc 9 10) (ranc 12 13))
XX document
### ++wordc
<h3 id="++wordc"><code>++wordc</code></h3>
++ wordc :(con digit lower upper (bex '_'))
XX document
### ++xdigit
<h3 id="++xdigit"><code>++xdigit</code></h3>
++ xdigit :(con (ranc 'a' 'f') (ranc 'A' 'F') digit)
::
XX document
### ++chad
<h3 id="++chad"><code>++chad</code></h3>
++ chad
%+ knee *rege |. ~+
@ -431,7 +431,7 @@ XX document
XX document
### ++escd
<h3 id="++escd"><code>++escd</code></h3>
++ escd
%+ knee *@ |. ~+
@ -452,7 +452,7 @@ XX document
XX document
### ++escp
<h3 id="++escp"><code>++escp</code></h3>
++ escp
%+ knee *rege |. ~+
@ -481,7 +481,7 @@ XX document
XX document
### ++unid
<h3 id="++unid"><code>++unid</code></h3>
++ unid
%+ knee *@ |. ~+
@ -498,14 +498,14 @@ XX document
XX document
### ++ra
<h3 id="++ra"><code>++ra</code></h3>
++ ra :: regex engine
|_ a=rege
XX document
### ++proc
<h3 id="++proc"><code>++proc</code></h3>
++ proc :: capture numbering
|= b=@
@ -544,7 +544,7 @@ XX document
XX document
### ++cont
<h3 id="++cont"><code>++cont</code></h3>
++ cont
|= [a=(map ,@u tape) b=(map ,@u tape)]
@ -553,7 +553,7 @@ XX document
XX document
### ++abor
<h3 id="++abor"><code>++abor</code></h3>
++ abor
|= [a=char b=(unit ,[tape (map ,@u tape)])]
@ -565,7 +565,7 @@ XX document
XX document
### ++matc
<h3 id="++matc"><code>++matc</code></h3>
++ matc
|= [b=tape c=tape]
@ -576,7 +576,7 @@ XX document
XX document
### ++chet
<h3 id="++chet"><code>++chet</code></h3>
++ chet
|= [b=(unit ,[tape (map ,@u tape)]) c=tape d=tape]
@ -592,19 +592,19 @@ XX document
XX document
### ++blak
<h3 id="++blak"><code>++blak</code></h3>
++ blak (some ["" _(map ,@u tape)])
XX document
### ++word
<h3 id="++word"><code>++word</code></h3>
++ word |=(a=char =((dis wordc:rags (bex a)) 0))
XX document
### ++deep
<h3 id="++deep"><code>++deep</code></h3>
++ deep
|= [b=tape c=rege d=tape]
@ -704,7 +704,7 @@ XX document
XX document
### ++rexp
<h3 id="++rexp"><code>++rexp</code></h3>
++ rexp :: Regex match
~/ %rexp
@ -733,7 +733,7 @@ XX document
XX document
### ++repg
<h3 id="++repg"><code>++repg</code></h3>
++ repg :: Global regex replace
~/ %repg

22
main/pub/doc/hoon/library/2en.md
View File

@ -1,7 +1,7 @@
section 2eN, pseudo-cryptography
================================
### ++un
<h3 id="++un"><code>++un</code></h3>
Reversible scrambling core
@ -13,7 +13,7 @@ Used in the `@p` phonetic base.
------------------------------------------------------------------------
### ++wren
<h3 id="++wren"><code>++wren</code></h3>
Conceal structure
@ -50,7 +50,7 @@ on the result, pushing it forward. Produces an atom.
------------------------------------------------------------------------
### ++wred
<h3 id="++wred"><code>++wred</code></h3>
Restore structure
@ -87,7 +87,7 @@ on the result, pushing it forward. Produces an atom.
------------------------------------------------------------------------
### ++xafo
<h3 id="++xafo"><code>++xafo</code></h3>
Add modulo 255
@ -102,7 +102,7 @@ Produces the sum of two atoms modulo 255, encoded as a nonzero byte.
------------------------------------------------------------------------
### ++xaro
<h3 id="++xaro"><code>++xaro</code></h3>
Subtract modulo 255
@ -118,7 +118,7 @@ nonzero byte.
------------------------------------------------------------------------
### ++zaft
<h3 id="++zaft"><code>++zaft</code></h3>
Look up in 255 sub box
@ -139,7 +139,7 @@ Look up in 255 sub box
(cut 3 [(dec a) 1] b)
::
The inverse of [`++zaft](). Looks up a nonzero byte`a\` in a substiution
The inverse of [`++zart`](). Looks up a nonzero byte`a\` in a substiution
box with 255 values, producing a unique nonzero byte.
`a` is an [atom]() of one byte in length.
@ -154,7 +154,7 @@ box with 255 values, producing a unique nonzero byte.
------------------------------------------------------------------------
### ++zart
<h3 id="++zart"><code>++zart</code></h3>
Reverse look up in 255 sub box
@ -187,7 +187,7 @@ the substitution box with 255 values, producing a unique nonzero byte.
------------------------------------------------------------------------
### ++zyft
<h3 id="++zyft"><code>++zyft</code></h3>
Lookup byte in 256 sub box
@ -223,7 +223,7 @@ with 256 values, producing a byte.
------------------------------------------------------------------------
### ++zyrt
<h3 id="++zyrt"><code>++zyrt</code></h3>
Reverse lookup byte in 256 sub box
@ -244,7 +244,7 @@ Reverse lookup byte in 256 sub box
df4d.225e.2d56.7fd6.1395.a3f8.c582
(cut 3 [a 1] b)
The inverse of [`++zyft`](). Looks up a byte `a` in a substituion box
The inverse of [`++zyft`](/doc/hoon/library/2en#++zyft). Looks up a byte `a` in a substituion box
with 256 values, producing a byte.
`a` is an [atom]() of one byte in length.

20
main/pub/doc/hoon/library/2eo.md
View File

@ -1,7 +1,7 @@
section 2eO, virtualization
===========================
### ++mack
<h3 id="++mack"><code>++mack</code></h3>
Nock subject to unit
@ -33,7 +33,7 @@ producing a `~`.
------------------------------------------------------------------------
### ++mink
<h3 id="++mink"><code>++mink</code></h3>
Mock interpreter
@ -143,7 +143,7 @@ result becomes a `%1` `++tone`, indicating a block.
------------------------------------------------------------------------
### ++mock
<h3 id="++mock"><code>++mock</code></h3>
Compute formula on subject with hint
@ -180,7 +180,7 @@ indicating a block.
------------------------------------------------------------------------
### ++mook
<h3 id="++mook"><code>++mook</code></h3>
Intelligently render crash annotation
@ -250,7 +250,7 @@ Each may be a tank, cord, [`++spot`](), or trapped tank. Produces a
------------------------------------------------------------------------
### ++mang
<h3 id="++mang"><code>++mang</code></h3>
Unit: Slam gate with sample
@ -292,7 +292,7 @@ Similar to [`++mong`]().
------------------------------------------------------------------------
### ++mong
<h3 id="++mong"><code>++mong</code></h3>
Slam gate with sample
@ -334,7 +334,7 @@ Produces a [`++toon`]() computation result from slamming `gat` with
------------------------------------------------------------------------
### ++mung
<h3 id="++mung"><code>++mung</code></h3>
Virtualize slamming gate
@ -376,7 +376,7 @@ Produces a [`++tone`]() computation result from slamming `gat` with
------------------------------------------------------------------------
### ++mule
<h3 id="++mule"><code>++mule</code></h3>
Typed virtual
@ -415,7 +415,7 @@ the way. Used to lazily compute stack traces.
------------------------------------------------------------------------
### ++mute
<h3 id="++mute"><code>++mute</code></h3>
Untyped virtual
@ -433,7 +433,7 @@ Kicks a `++trap`, producing its result as a noun or the tanks of any
error that occurs. Similar to [`++mule`](), but preserves no type
information.
`taq` is a [`++trap`]().
`taq` is a [`++trap`](/doc/hoon/library/1#++trap).
~zod/try=> (mute |.(leaf/"hello"))
[%.y p=[1.717.658.988 104 101 108 108 111 0]]

30
main/pub/doc/hoon/library/2ep.md
View File

@ -8,7 +8,7 @@ anyway.
------------------------------------------------------------------------
### ++berk
<h3 id="++berk"><code>++berk</code></h3>
Invert diff patches
@ -39,7 +39,7 @@ swapped. Produces a `bur`.
------------------------------------------------------------------------
### ++diff
<h3 id="++diff"><code>++diff</code></h3>
Generate patch
@ -84,7 +84,7 @@ Produces a patch between two nouns, by change type
------------------------------------------------------------------------
### ++loss
<h3 id="++loss"><code>++loss</code></h3>
Longest subsequence
@ -173,7 +173,7 @@ several internal helper arms. Produces a [`++tape`]().
------------------------------------------------------------------------
### ++locz
<h3 id="++locz"><code>++locz</code></h3>
Find common
@ -194,7 +194,7 @@ Find common
?:((gth p.lef p.rig) lef rig)
::
Finds a subsequence of repeated elements within two [`++list`]()s,
Finds a subsequence of repeated elements within two [`++list`](/doc/hoon/library/1#++list)s,
producing a [\`++tape]().
~zod/try=> (locz "samukot" "semelkot")
@ -204,7 +204,7 @@ producing a [\`++tape]().
------------------------------------------------------------------------
### ++lore
<h3 id="++lore"><code>++lore</code></h3>
Split on `\n`
@ -240,7 +240,7 @@ Split on newlines, ascii `10`
------------------------------------------------------------------------
### ++role
<h3 id="++role"><code>++role</code></h3>
Join with `\n`
@ -262,7 +262,7 @@ Join line list with newlines.
------------------------------------------------------------------------
### ++lump
<h3 id="++lump"><code>++lump</code></h3>
Change with `++udon`
@ -309,7 +309,7 @@ Use udon to change noun
------------------------------------------------------------------------
### ++lure
<h3 id="++lure"><code>++lure</code></h3>
Patch `a`
@ -332,7 +332,7 @@ Patch a by references to axis and literal.
------------------------------------------------------------------------
### ++limp
<h3 id="++limp"><code>++limp</code></h3>
Reverse patch
@ -357,7 +357,7 @@ Reverse a patch (preprocessor unchanged)
------------------------------------------------------------------------
### ++hump
<h3 id="++hump"><code>++hump</code></h3>
Prep for diff
@ -387,7 +387,7 @@ Prep atom for diff: leave alone, cue, or split by newlines.
------------------------------------------------------------------------
### ++husk
<h3 id="++husk"><code>++husk</code></h3>
Atomize post diff
@ -434,7 +434,7 @@ Re-atomize after diff: leave alone, jam, or join with newlines.
------------------------------------------------------------------------
### ++lurk
<h3 id="++lurk"><code>++lurk</code></h3>
Apply list patch
@ -474,7 +474,7 @@ Amend list using an urge: list of `[%& {number skipped}]` and
------------------------------------------------------------------------
### ++lusk
<h3 id="++lusk"><code>++lusk</code></h3>
`lcs` to list patch
@ -535,7 +535,7 @@ Using a common sequence, generate urge from two lists
------------------------------------------------------------------------
### ++nude
<h3 id="++nude"><code>++nude</code></h3>
Tree change

42
main/pub/doc/hoon/library/2ew.md
View File

@ -1,7 +1,7 @@
section 2eW, lite number theory
===============================
### ++egcd
<h3 id="++egcd"><code>++egcd</code></h3>
GCD
@ -41,7 +41,7 @@ Greatest common denominator
------------------------------------------------------------------------
### ++pram
<h3 id="++pram"><code>++pram</code></h3>
Probable prime
@ -97,7 +97,7 @@ Probable prime test
------------------------------------------------------------------------
### ++ramp
<h3 id="++ramp"><code>++ramp</code></h3>
`r-m` prime
@ -132,7 +132,7 @@ using salt `c`.
------------------------------------------------------------------------
### ++fo
<h3 id="++fo"><code>++fo</code></h3>
Prime engine
@ -148,7 +148,7 @@ Core for performing arithmetic modulo a prime number
------------------------------------------------------------------------
### ++dif
<h3 id="++dif"><code>++dif</code></h3>
Difference
@ -166,7 +166,7 @@ Subtract
------------------------------------------------------------------------
### ++exp
<h3 id="++exp"><code>++exp</code></h3>
Exponent
@ -186,7 +186,7 @@ Exponent
------------------------------------------------------------------------
### ++fra
<h3 id="++fra"><code>++fra</code></h3>
Divide
@ -204,7 +204,7 @@ Divide
------------------------------------------------------------------------
### ++inv
<h3 id="++inv"><code>++inv</code></h3>
Inverse
@ -225,7 +225,7 @@ Multiplicative inverse
------------------------------------------------------------------------
### ++pro
<h3 id="++pro"><code>++pro</code></h3>
Product
@ -243,7 +243,7 @@ Product
------------------------------------------------------------------------
### ++sit
<h3 id="++sit"><code>++sit</code></h3>
Bounds
@ -261,7 +261,7 @@ Bounds check
------------------------------------------------------------------------
### ++sum
<h3 id="++sum"><code>++sum</code></h3>
Sum
@ -279,7 +279,7 @@ Add
------------------------------------------------------------------------
### ++ga
<h3 id="++ga"><code>++ga</code></h3>
++ ga :: GF (bex p.a)
|= a=[p=@ q=@ r=@] :: dim poly gen
@ -293,7 +293,7 @@ XX document
------------------------------------------------------------------------
### ++dif
<h3 id="++dif"><code>++dif</code></h3>
++ dif :: add and sub
|= [b=@ c=@]
@ -306,7 +306,7 @@ XX document
------------------------------------------------------------------------
### ++dub
<h3 id="++dub"><code>++dub</code></h3>
++ dub :: mul by x
|= b=@
@ -321,7 +321,7 @@ XX document
------------------------------------------------------------------------
### ++pro
<h3 id="++pro"><code>++pro</code></h3>
++ pro :: slow multiply
|= [b=@ c=@]
@ -336,7 +336,7 @@ XX document
------------------------------------------------------------------------
### ++toe
<h3 id="++toe"><code>++toe</code></h3>
++ toe :: exp/log tables
=+ ^= nu
@ -367,7 +367,7 @@ XX document
------------------------------------------------------------------------
### ++sit
<h3 id="++sit"><code>++sit</code></h3>
++ sit :: reduce
|= b=@
@ -378,7 +378,7 @@ XX document
------------------------------------------------------------------------
### ++fra
<h3 id="++fra"><code>++fra</code></h3>
++ fra :: divide
|= [b=@ c=@]
@ -389,7 +389,7 @@ XX document
------------------------------------------------------------------------
### ++inv
<h3 id="++inv"><code>++inv</code></h3>
++ inv :: invert
|= b=@
@ -404,7 +404,7 @@ XX document
------------------------------------------------------------------------
### ++pow
<h3 id="++pow"><code>++pow</code></h3>
++ pow :: exponent
|= [b=@ c=@]
@ -421,7 +421,7 @@ XX document
------------------------------------------------------------------------
### ++pro
<h3 id="++pro"><code>++pro</code></h3>
++ pro :: multiply
|= [b=@ c=@]

96
main/pub/doc/hoon/library/2ex.md
View File

@ -3,7 +3,7 @@ section 2eX, jetted crypto
------------------------------------------------------------------------
### ++aesc
<h3 id="++aesc"><code>++aesc</code></h3>
++ aesc :: AES-256
~% %aesc + ~
@ -11,7 +11,7 @@ section 2eX, jetted crypto
XX document
### ++en
<h3 id="++en"><code>++en</code></h3>
++ en :: ECB enc
~/ %en
@ -21,7 +21,7 @@ XX document
XX document
### ++de
<h3 id="++de"><code>++de</code></h3>
++ de :: ECB dec
~/ %de
@ -32,7 +32,7 @@ XX document
XX document
### ++ahem
<h3 id="++ahem"><code>++ahem</code></h3>
++ ahem :: AES helpers
:: XX should be in aesc, isn't for performance reasons
@ -44,20 +44,20 @@ XX document
XX document
### ++cipa
<h3 id="++cipa"><code>++cipa</code></h3>
++ cipa :: AES params
$_ ^? |%
XX document
### ++co
<h3 id="++co"><code>++co</code></h3>
++ co [0xe 0xb 0xd 0x9]
XX document
### ++ix
<h3 id="++ix"><code>++ix</code></h3>
++ ix :: key expand, inv
|= a=@ ^- @
@ -82,13 +82,13 @@ XX document
XX document
### ++ro
<h3 id="++ro"><code>++ro</code></h3>
++ ro [0 3 2 1]
XX document
### ++su
<h3 id="++su"><code>++su</code></h3>
++ su 0x7d0c.2155.6314.69e1.26d6.77ba.7e04.2b17.
6199.5383.3cbb.ebc8.b0f5.2aae.4d3b.e0a0.
@ -111,7 +111,7 @@ XX document
XX document
### ++pen
<h3 id="++pen"><code>++pen</code></h3>
++ pen :: encrypt
^- cipa
@ -119,13 +119,13 @@ XX document
XX document
### ++co
<h3 id="++co"><code>++co</code></h3>
++ co [0xe 0xb 0xd 0x9]
XX document
### ++ix
<h3 id="++ix"><code>++ix</code></h3>
++ ix :: key expand, inv
|= a=@ ^- @
@ -150,13 +150,13 @@ XX document
XX document
### ++ro
<h3 id="++ro"><code>++ro</code></h3>
++ ro [0 3 2 1]
XX document
### ++su
<h3 id="++su"><code>++su</code></h3>
++ su 0x7d0c.2155.6314.69e1.26d6.77ba.7e04.2b17.
6199.5383.3cbb.ebc8.b0f5.2aae.4d3b.e0a0.
@ -179,7 +179,7 @@ XX document
XX document
### ++pin
<h3 id="++pin"><code>++pin</code></h3>
++ pin :: decrypt
^- cipa
@ -187,13 +187,13 @@ XX document
XX document
### ++co
<h3 id="++co"><code>++co</code></h3>
++ co [0xe 0xb 0xd 0x9]
XX document
### ++ix
<h3 id="++ix"><code>++ix</code></h3>
++ ix :: key expand, inv
|= a=@ ^- @
@ -218,13 +218,13 @@ XX document
XX document
### ++ro
<h3 id="++ro"><code>++ro</code></h3>
++ ro [0 3 2 1]
XX document
### ++su
<h3 id="++su"><code>++su</code></h3>
++ su 0x7d0c.2155.6314.69e1.26d6.77ba.7e04.2b17.
6199.5383.3cbb.ebc8.b0f5.2aae.4d3b.e0a0.
@ -247,7 +247,7 @@ XX document
XX document
### ++mcol
<h3 id="++mcol"><code>++mcol</code></h3>
++ mcol
|= [a=(list ,@) b=[p=@ q=@ r=@ s=@]] ^- (list ,@)
@ -273,7 +273,7 @@ XX document
XX document
### ++pode
<h3 id="++pode"><code>++pode</code></h3>
++ pode :: explode to block
|= [a=bloq b=@ c=@] ^- (list ,@)
@ -286,7 +286,7 @@ XX document
XX document
### ++sube
<h3 id="++sube"><code>++sube</code></h3>
++ sube :: s-box word
|= [a=@ b=@] ^- @
@ -296,7 +296,7 @@ XX document
XX document
### ++be
<h3 id="++be"><code>++be</code></h3>
++ be :: block cipher
|= [a=? b=@ c=@H] ^- @uxH
@ -308,7 +308,7 @@ XX document
XX document
### ++ankh
<h3 id="++ankh"><code>++ankh</code></h3>
++ ankh
|= [a=cipa b=@ c=@]
@ -316,7 +316,7 @@ XX document
XX document
### ++sark
<h3 id="++sark"><code>++sark</code></h3>
++ sark
|= [c=(list ,@) d=(list ,@)] ^- (list ,@)
@ -326,7 +326,7 @@ XX document
XX document
### ++srow
<h3 id="++srow"><code>++srow</code></h3>
++ srow
|= [a=cipa b=(list ,@)] ^- (list ,@)
@ -343,7 +343,7 @@ XX document
XX document
### ++subs
<h3 id="++subs"><code>++subs</code></h3>
++ subs
|= [a=cipa b=(list ,@)] ^- (list ,@)
@ -367,7 +367,7 @@ XX document
XX document
### ++ex
<h3 id="++ex"><code>++ex</code></h3>
++ ex :: key expand
|= a=@I ^- @
@ -389,7 +389,7 @@ XX document
XX document
### ++ix
<h3 id="++ix"><code>++ix</code></h3>
++ ix :: key expand, inv
|= a=@ ^- @
@ -414,7 +414,7 @@ XX document
XX document
### ++curt
<h3 id="++curt"><code>++curt</code></h3>
++ curt :: curve25519
|= [a=@ b=@]
@ -428,7 +428,7 @@ XX document
XX document
### ++cla
<h3 id="++cla"><code>++cla</code></h3>
++ cla
|= raw=@
@ -439,19 +439,19 @@ XX document
XX document
### ++sqr
<h3 id="++sqr"><code>++sqr</code></h3>
++ sqr |=(a=@ (mul a a))
XX document
### ++inv
<h3 id="++inv"><code>++inv</code></h3>
++ inv |=(a=@ (~(exp fo q) (sub q 2) a))
XX document
### ++cad
<h3 id="++cad"><code>++cad</code></h3>
++ cad
|= [n=[x=@ z=@] m=[x=@ z=@] d=[x=@ z=@]]
@ -473,7 +473,7 @@ XX document
XX document
### ++cub
<h3 id="++cub"><code>++cub</code></h3>
++ cub
|= [x=@ z=@]
@ -505,7 +505,7 @@ XX document
XX document
### ++ed
<h3 id="++ed"><code>++ed</code></h3>
++ ed :: ed25519
=>
@ -521,14 +521,14 @@ XX document
~% %coed +> ~
|%
### ++norm
<h3 id="++norm"><code>++norm</code></h3>
++ norm |=(x=@ ?:(=(0 (mod x 2)) x (sub q x)))
::
XX document
### ++xrec
<h3 id="++xrec"><code>++xrec</code></h3>
++ xrec :: recover x-coord
|= y=@ ^- @
@ -543,7 +543,7 @@ XX document
XX document
### ++ward
<h3 id="++ward"><code>++ward</code></h3>
++ ward :: edwards multiply
|= [pp=[@ @] qq=[@ @]] ^- [@ @]
@ -565,7 +565,7 @@ XX document
XX document
### ++scam
<h3 id="++scam"><code>++scam</code></h3>
++ scam :: scalar multiply
|= [pp=[@ @] e=@] ^- [@ @]
@ -580,7 +580,7 @@ XX document
XX document
### ++etch
<h3 id="++etch"><code>++etch</code></h3>
++ etch :: encode point
|= pp=[@ @] ^- @
@ -589,7 +589,7 @@ XX document
XX document
### ++curv
<h3 id="++curv"><code>++curv</code></h3>
++ curv :: point on curve?
|= [x=@ y=@] ^- ?
@ -603,7 +603,7 @@ XX document
XX document
### ++deco
<h3 id="++deco"><code>++deco</code></h3>
++ deco :: decode point
|= s=@ ^- (unit ,[@ @])
@ -619,7 +619,7 @@ XX document
XX document
### ++bb
<h3 id="++bb"><code>++bb</code></h3>
++ bb
=+ bby=(pro.fq 4 (inv.fq 5))
@ -631,7 +631,7 @@ XX document
XX document
### ++puck
<h3 id="++puck"><code>++puck</code></h3>
++ puck :: public key
~/ %puck
@ -647,7 +647,7 @@ XX document
XX document
### ++suck
<h3 id="++suck"><code>++suck</code></h3>
++ suck :: keypair from seed
|= se=@I ^- @uJ
@ -657,7 +657,7 @@ XX document
XX document
### ++sign
<h3 id="++sign"><code>++sign</code></h3>
++ sign :: certify
~/ %sign
@ -692,7 +692,7 @@ XX document
XX document
### ++veri
<h3 id="++veri"><code>++veri</code></h3>
++ veri :: validate
~/ %veri

30
main/pub/doc/hoon/library/2ey.md
View File

@ -1,13 +1,13 @@
section 2eY, SHA-256
====================
### ++shad
<h3 id="++shad"><code>++shad</code></h3>
++ shad |=(ruz=@ (shax (shax ruz))) :: double sha-256
XX document
### ++shaf
<h3 id="++shaf"><code>++shaf</code></h3>
++ shaf :: half sha-256
|= [sal=@ ruz=@]
@ -17,7 +17,7 @@ XX document
XX document
### ++shak
<h3 id="++shak"><code>++shak</code></h3>
++ shak :: XX shd be PBKDF
|= [who=@p wud=@]
@ -26,7 +26,7 @@ XX document
XX document
### ++sham
<h3 id="++sham"><code>++sham</code></h3>
++ sham :: noun hash
|= yux=* ^- @uvH ^- @
@ -37,7 +37,7 @@ XX document
XX document
### ++shas
<h3 id="++shas"><code>++shas</code></h3>
++ shas :: salted hash
|= [sal=@ ruz=@]
@ -46,7 +46,7 @@ XX document
XX document
### ++shax
<h3 id="++shax"><code>++shax</code></h3>
++ shax :: sha-256
~/ %shax
@ -137,7 +137,7 @@ XX document
XX document
### ++shaw
<h3 id="++shaw"><code>++shaw</code></h3>
++ shaw :: hash to nbits
|= [sal=@ len=@ ruz=@]
@ -146,7 +146,7 @@ XX document
XX document
### ++og
<h3 id="++og"><code>++og</code></h3>
++ og :: shax-powered rng
~/ %og
@ -154,7 +154,7 @@ XX document
XX document
### ++rad
<h3 id="++rad"><code>++rad</code></h3>
++ rad :: random in range
|= b=@ ^- @
@ -164,7 +164,7 @@ XX document
XX document
### ++rads
<h3 id="++rads"><code>++rads</code></h3>
++ rads :: random continuation
|= b=@
@ -173,7 +173,7 @@ XX document
XX document
### ++raw
<h3 id="++raw"><code>++raw</code></h3>
++ raw :: random bits
~/ %raw
@ -191,7 +191,7 @@ XX document
XX document
### ++raws
<h3 id="++raws"><code>++raws</code></h3>
++ raws :: random bits continuation
|= b=@
@ -201,7 +201,7 @@ XX document
XX document
### ++shaz
<h3 id="++shaz"><code>++shaz</code></h3>
++ shaz :: sha-512
|= ruz=@ ^- @
@ -209,7 +209,7 @@ XX document
XX document
### ++shal
<h3 id="++shal"><code>++shal</code></h3>
++ shal :: sha-512 with length
~/ %shal
@ -326,7 +326,7 @@ XX document
XX document
### ++shan
<h3 id="++shan"><code>++shan</code></h3>
++ shan :: sha-1 (deprecated)
|= ruz=@

36
main/pub/doc/hoon/library/2ez.md
View File

@ -1,9 +1,7 @@
section 2eZ, OLD rendering
--------------------------
==========================
------------------------------------------------------------------------
### ++show
<h3 id="++show"><code>++show</code></h3>
++ show :: XX deprecated, use type
|= vem=*
@ -65,7 +63,7 @@ section 2eZ, OLD rendering
XX document
### ++shep
<h3 id="++shep"><code>++shep</code></h3>
++ shep
|= [fom=@ gar=*]
@ -87,7 +85,7 @@ XX document
XX document
### ++shop
<h3 id="++shop"><code>++shop</code></h3>
++ shop
|= [aug=* vel=$+(a=@ tape)]
@ -105,14 +103,14 @@ XX document
XX document
### ++at
<h3 id="++at"><code>++at</code></h3>
++ at
|_ a=@
XX document
### ++r
<h3 id="++r"><code>++r</code></h3>
++ r
?: ?& (gte (met 3 a) 2)
@ -132,49 +130,49 @@ XX document
XX document
### ++rf
<h3 id="++rf"><code>++rf</code></h3>
++ rf `tape`[?-(a & '&', | '|', * !!) ~]
XX document
### ++rn
<h3 id="++rn"><code>++rn</code></h3>
++ rn `tape`[?>(=(0 a) '~') ~]
XX document
### ++rt
<h3 id="++rt"><code>++rt</code></h3>
++ rt `tape`['\'' (weld (mesc (trip a)) `tape`['\'' ~])]
XX document
### ++rta
<h3 id="++rta"><code>++rta</code></h3>
++ rta rt
XX document
### ++rtam
<h3 id="++rtam"><code>++rtam</code></h3>
++ rtam `tape`['%' (trip a)]
XX document
### ++rub
<h3 id="++rub"><code>++rub</code></h3>
++ rub `tape`['0' 'b' (rum 2 ~ |=(b=@ (add '0' b)))]
XX document
### ++rud
<h3 id="++rud"><code>++rud</code></h3>
++ rud (rum 10 ~ |=(b=@ (add '0' b)))
XX document
### ++rum
<h3 id="++rum"><code>++rum</code></h3>
++ rum
|= [b=@ c=tape d=$+(@ @)]
@ -195,7 +193,7 @@ XX document
XX document
### ++rup
<h3 id="++rup"><code>++rup</code></h3>
++ rup
=+ b=(met 3 a)
@ -222,7 +220,7 @@ XX document
XX document
### ++ruv
<h3 id="++ruv"><code>++ruv</code></h3>
++ ruv
^- tape
@ -241,7 +239,7 @@ XX document
XX document
### ++rux
<h3 id="++rux"><code>++rux</code></h3>
++ rux `tape`['0' 'x' (rum 16 ~ |=(b=@ (add b ?:((lth b 10) 48 87))))]
--

14
main/pub/doc/hoon/library/3ba.md
View File

@ -1,7 +1,7 @@
section 3bA, lite number theory
===============================
### ++fu
<h3 id="++fu"><code>++fu</code></h3>
++ fu :: modulo (mul p q)
|= a=[p=@ q=@]
@ -10,7 +10,7 @@ section 3bA, lite number theory
XX document
### ++dif
<h3 id="++dif"><code>++dif</code></h3>
++ dif
|= [c=[@ @] d=[@ @]]
@ -19,7 +19,7 @@ XX document
XX document
### ++exp
<h3 id="++exp"><code>++exp</code></h3>
++ exp
|= [c=@ d=[@ @]]
@ -29,7 +29,7 @@ XX document
XX document
### ++out
<h3 id="++out"><code>++out</code></h3>
++ out :: garner's formula
|= c=[@ @]
@ -40,7 +40,7 @@ XX document
XX document
### ++pro
<h3 id="++pro"><code>++pro</code></h3>
++ pro
|= [c=[@ @] d=[@ @]]
@ -49,7 +49,7 @@ XX document
XX document
### ++sum
<h3 id="++sum"><code>++sum</code></h3>
++ sum
|= [c=[@ @] d=[@ @]]
@ -58,7 +58,7 @@ XX document
XX document
### ++sit
<h3 id="++sit"><code>++sit</code></h3>
++ sit
|= c=@

68
main/pub/doc/hoon/library/3bb.md
View File

@ -1,7 +1,7 @@
section 3bB, cryptosuites
=========================
### ++crua
<h3 id="++crua"><code>++crua</code></h3>
++ crua !: :: cryptosuite A (RSA)
^- acru
@ -10,13 +10,13 @@ section 3bB, cryptosuites
XX document
### ++mx
<h3 id="++mx"><code>++mx</code></h3>
++ mx (dec (met 0 mos)) :: bit length
XX document
### ++dap
<h3 id="++dap"><code>++dap</code></h3>
++ dap :: OEAP decode
|= [wid=@ xar=@ dog=@] ^- [p=@ q=@]
@ -28,7 +28,7 @@ XX document
XX document
### ++pad
<h3 id="++pad"><code>++pad</code></h3>
++ pad :: OEAP encode
|= [wid=@ rax=[p=@ q=@] meg=@] ^- @
@ -42,19 +42,19 @@ XX document
XX document
### ++pull
<h3 id="++pull"><code>++pull</code></h3>
++ pull |=(a=@ (~(exp fo mos) 3 a))
XX document
### ++push
<h3 id="++push"><code>++push</code></h3>
++ push |=(a=@ (~(exp fo mos) 5 a))
XX document
### ++pump
<h3 id="++pump"><code>++pump</code></h3>
++ pump
|= a=@ ^- @
@ -64,7 +64,7 @@ XX document
XX document
### ++punt
<h3 id="++punt"><code>++punt</code></h3>
++ punt
|= a=@ ^- @
@ -74,14 +74,14 @@ XX document
XX document
### ++as
<h3 id="++as"><code>++as</code></h3>
++ as
=> |%
XX document
### ++haul
<h3 id="++haul"><code>++haul</code></h3>
++ haul :: revealing haul
|= a=pass
@ -94,7 +94,7 @@ XX document
XX document
### ++seal
<h3 id="++seal"><code>++seal</code></h3>
XX document
@ -177,26 +177,26 @@ XX document
XX document
### ++pac
<h3 id="++pac"><code>++pac</code></h3>
++ pac ^- @uvG (end 6 1 (shaf %acod sec))
XX document
### ++pub
<h3 id="++pub"><code>++pub</code></h3>
++ pub ^- pass (cat 3 'b' puc)
XX document
### ++sec
<h3 id="++sec"><code>++sec</code></h3>
++ sec ^- ring sed
::
XX document
### ++nu
<h3 id="++nu"><code>++nu</code></h3>
++ nu
^?
@ -208,7 +208,7 @@ XX document
XX document
### ++elcm
<h3 id="++elcm"><code>++elcm</code></h3>
++ elcm
|= [a=@ b=@]
@ -217,7 +217,7 @@ XX document
XX document
### ++eldm
<h3 id="++eldm"><code>++eldm</code></h3>
++ eldm
|= [a=@ b=@ c=@]
@ -226,7 +226,7 @@ XX document
XX document
### ++ersa
<h3 id="++ersa"><code>++ersa</code></h3>
++ ersa
|= [a=@ b=@]
@ -240,7 +240,7 @@ XX document
XX document
### ++com
<h3 id="++com"><code>++com</code></h3>
XX document
@ -401,7 +401,7 @@ XX document
XX document
### ++sign
<h3 id="++sign"><code>++sign</code></h3>
++ sign
|= [a=@ b=@] ^- @
@ -409,7 +409,7 @@ XX document
XX document
### ++sure
<h3 id="++sure"><code>++sure</code></h3>
++ sure
|= [a=@ b=@]
@ -418,7 +418,7 @@ XX document
XX document
### ++tear
<h3 id="++tear"><code>++tear</code></h3>
++ tear
|= [a=pass b=@]
@ -428,7 +428,7 @@ XX document
XX document
### ++de
<h3 id="++de"><code>++de</code></h3>
++ de
|+ [key=@ cep=@] ^- (unit ,@)
@ -437,7 +437,7 @@ XX document
XX document
### ++dy
<h3 id="++dy"><code>++dy</code></h3>
++ dy
|+ [a=@ b=@] ^- @
@ -445,7 +445,7 @@ XX document
XX document
### ++en
<h3 id="++en"><code>++en</code></h3>
++ en
|+ [key=@ msg=@] ^- @ux
@ -454,14 +454,14 @@ XX document
XX document
### ++ex
<h3 id="++ex"><code>++ex</code></h3>
++ ex ^?
|% ++ fig ^- @uvH (shaf %bfig puc)
XX document
### ++fig
<h3 id="++fig"><code>++fig</code></h3>
XX document
@ -509,7 +509,7 @@ XX document
XX document
### ++pit
<h3 id="++pit"><code>++pit</code></h3>
++ pit
|= [a=@ b=@]
@ -519,7 +519,7 @@ XX document
XX document
### ++nol
<h3 id="++nol"><code>++nol</code></h3>
++ nol
|= a=@
@ -528,7 +528,7 @@ XX document
XX document
### ++brew
<h3 id="++brew"><code>++brew</code></h3>
++ brew :: create keypair
|= [a=@ b=@] :: width seed
@ -538,7 +538,7 @@ XX document
XX document
### ++hail
<h3 id="++hail"><code>++hail</code></h3>
++ hail :: activate public key
|= a=pass
@ -550,7 +550,7 @@ XX document
XX document
### ++wear
<h3 id="++wear"><code>++wear</code></h3>
++ wear :: activate secret key
|= a=ring
@ -562,7 +562,7 @@ XX document
XX document
### ++trub
<h3 id="++trub"><code>++trub</code></h3>
++ trub :: test ed
|= msg=@tas
@ -583,7 +583,7 @@ XX document
XX document
### ++hmac
<h3 id="++hmac"><code>++hmac</code></h3>
++ hmac :: HMAC-SHA1
|= [key=@ mes=@]

26
main/pub/doc/hoon/library/3bc.md
View File

@ -1,7 +1,7 @@
section 3bC, Gregorian UTC
==========================
### ++dawn
<h3 id="++dawn"><code>++dawn</code></h3>
Weekday of Jan 1
@ -27,7 +27,7 @@ producing an atom. Weeks are zero-indexed beginning on Sunday.
------------------------------------------------------------------------
### ++daws
<h3 id="++daws"><code>++daws</code></h3>
Weekday of date
@ -51,7 +51,7 @@ zero-indexed beginning on Sunday.
------------------------------------------------------------------------
### ++deal
<h3 id="++deal"><code>++deal</code></h3>
Add leap seconds
@ -82,7 +82,7 @@ Produces a [`date`]() with the 25 leap seconds added.
------------------------------------------------------------------------
### ++lead
<h3 id="++lead"><code>++lead</code></h3>
Subtract leap seconds
@ -117,7 +117,7 @@ subtracted.
------------------------------------------------------------------------
### ++dust
<h3 id="++dust"><code>++dust</code></h3>
Print UTC format
@ -146,7 +146,7 @@ Produces a [tape]() of the date in UTC format.
------------------------------------------------------------------------
### ++stud
<h3 id="++stud"><code>++stud</code></h3>
Parse UTC format
@ -189,7 +189,7 @@ Accepts a [tape]() containing a date in UTC format and produces the
------------------------------------------------------------------------
### ++unt
<h3 id="++unt"><code>++unt</code></h3>
UGT to UTC time
@ -211,7 +211,7 @@ Transforms Urbit Galactic Time to UTC time, producing an atom.
------------------------------------------------------------------------
### ++yu
<h3 id="++yu"><code>++yu</code></h3>
UTC format constants
@ -223,7 +223,7 @@ UTC format constants
------------------------------------------------------------------------
### ++mon
<h3 id="++mon"><code>++mon</code></h3>
Months
@ -255,7 +255,7 @@ Produces a list of [tapes]() containing the 12 months of the year.
------------------------------------------------------------------------
### ++wik
<h3 id="++wik"><code>++wik</code></h3>
Weeks
@ -277,7 +277,7 @@ beginning with Sunday.
------------------------------------------------------------------------
### ++les
<h3 id="++les"><code>++les</code></h3>
Leap second dates
@ -324,7 +324,7 @@ Produces a list of the (absolute) dates ([`@da`]) of the 25 leap seconds
------------------------------------------------------------------------
### ++lef
<h3 id="++lef"><code>++lef</code></h3>
Back-shifted leap second dates
@ -346,7 +346,7 @@ Back-shifted leap second dates
::
Produces a list of absolute dates ([`@da`]()) that represent the Urbit
Galactc Time equivalents of the UTC leap second dates in [`++les`]().
Galactc Time equivalents of the UTC leap second dates in [`++les`](/doc/hoon/library/3bc#++les).
~zod/try=/hom> lef:yu
~[

168
main/pub/doc/hoon/library/3bd.md
View File

@ -1,7 +1,7 @@
section 3bD, JSON and XML
=========================
### ++moon
<h3 id="++moon"><code>++moon</code></h3>
Mime type to `++cord`
@ -27,7 +27,7 @@ Renders a [mime](http://en.wikipedia.org/wiki/MIME) type path with infix
~zod/try=> `@t`(moon /application/x-pnacl)
'application/x-pnacl'
### ++perk
<h3 id="++perk"><code>++perk</code></h3>
Parse cube with fork
@ -61,7 +61,7 @@ needlessly unwieldy.
! {1 1}
! exit
### ++poja
<h3 id="++poja"><code>++poja</code></h3>
JSON parser core
@ -81,7 +81,7 @@ a [`++json`]().
~zod/try=> (poja 'invalid{json')
~
### ++apex
<h3 id="++apex"><code>++apex</code></h3>
Parse object
@ -103,7 +103,7 @@ with current test:urbit.git
! {1 1}
! exit
### ++valu
<h3 id="++valu"><code>++valu</code></h3>
Parse value
@ -135,7 +135,7 @@ Parsing rule. Parses JSON values to [`++json`]().
~zod/try=> (rash 'true' valu:poja)
[%b p=%.y]
### ++abox
<h3 id="++abox"><code>++abox</code></h3>
Parse array
@ -150,7 +150,7 @@ delimited by a `,`.
JSON Objects
------------
### ++pair
<h3 id="++pair"><code>++pair</code></h3>
Parse key value pair
@ -162,7 +162,7 @@ string and value delimited by `:`.
~zod/try=> (rash '"ham": 2' pair:poja)
['ham' [%n p=~.2]]
### ++obje
<h3 id="++obje"><code>++obje</code></h3>
Parse array of objects
@ -174,7 +174,7 @@ key-value pairs that are enclosed within `{}` and separated by `,`.
~zod/try=> (rash '{"ham": 2, "lam":true}' obje:poja)
[['ham' [%n p=~.2]] ~[['lam' [%b p=%.y]]]]
### ++obox
<h3 id="++obox"><code>++obox</code></h3>
Parse boxed object
@ -189,7 +189,7 @@ a tag of `%o`. See also: [`++json`]().
JSON Booleans
-------------
### ++bool
<h3 id="++bool"><code>++bool</code></h3>
Parse boolean
@ -209,7 +209,7 @@ Parsing rule. Parses a string of either `true` or `false` to a
JSON strings
------------
### ++stri
<h3 id="++stri"><code>++stri</code></h3>
Parse string
@ -228,7 +228,7 @@ of characters enclosed in double quotes along with escaping `\`s, to a
~zod/try=> (rash '"This be \\"quoted\\""' stri:poja)
'This be "quoted"'
### ++jcha
<h3 id="++jcha"><code>++jcha</code></h3>
Parse char from string
@ -249,7 +249,7 @@ string to a [`++cord`]().
'
'
### ++esca
<h3 id="++esca"><code>++esca</code></h3>
Parse escaped char
@ -286,7 +286,7 @@ A- JSON numbers are stored as cords internally in lieu of full float
support, so ++numb and subarms are really more *validators* than parsers
per se.
### ++numb
<h3 id="++numb"><code>++numb</code></h3>
Parse number
@ -318,7 +318,7 @@ part, or exponent part, to a [`++cord`]().
! {1 2}
! exit
### ++digs
<h3 id="++digs"><code>++digs</code></h3>
Parse 1-9
@ -335,7 +335,7 @@ Parsing rule. Parses digits `0` through `9` to a [`++tape`]().
~zod/try=> (rash '7' digs:poja)
"7"
### ++expo
<h3 id="++expo"><code>++expo</code></h3>
Parse exponent part
@ -356,7 +356,7 @@ Parsing rule. Parses an exponent to a [`++cord`](). An exponent is an
~zod/try=> `tape`(rash 'E-4' expo:poja)
"E-4"
### ++frac
<h3 id="++frac"><code>++frac</code></h3>
Fractional part
@ -374,7 +374,7 @@ Parsing rule. Parses a dot followed by digits to a [`++cord`]().
whitespace
----------
### ++spac
<h3 id="++spac"><code>++spac</code></h3>
Parse whitespace
@ -392,7 +392,7 @@ Parsing rule. Parses a whitespace to a [`++tape`]().
! {1 4}
! exit
### ++ws
<h3 id="++ws"><code>++ws</code></h3>
Allow prefix whitespace
@ -417,7 +417,7 @@ applying `sef`.
Plumbing
--------
### ++mayb
<h3 id="++mayb"><code>++mayb</code></h3>
Maybe parse
@ -430,7 +430,7 @@ Parser modifier. Need to document, an example showing failure.
~zod/try=> ((mayb abox):poja 1^1 "not-an-array")
[p=[p=1 q=1] q=[~ [p="" q=[p=[p=1 q=1] q="not-an-array"]]]]
### ++twel
<h3 id="++twel"><code>++twel</code></h3>
Weld two tapes
@ -438,16 +438,16 @@ Weld two tapes
Concatenates two tapes, `a` and `b`, producing a `++tape`.
`a` is a [++tape]().
`a` is a [`++tape`]().
`b` is a [++tape]().
`b` is a [`++tape`]().
~zod/try=> (twel "sam" "hok"):poja
~[~~s ~~a ~~m ~~h ~~o ~~k]
~zod/try=> (twel "kre" ""):poja
~[~~k ~~r ~~e]
### ++piec
<h3 id="++piec"><code>++piec</code></h3>
Parse char to list
@ -464,7 +464,7 @@ Parser modifer. Parses an atom with `bus` and then wraps it in a
~zod/try=> (scan "4" (piec:poja dem:ag))
[4 ~]
### ++pojo
<h3 id="++pojo"><code>++pojo</code></h3>
Print JSON
@ -510,7 +510,7 @@ Print JSON
==
::
Renders a `++json` `val` as a [++tape]().
Renders a `++json` `val` as a [`++tape`]().
`val` is a [`json`]().
@ -527,7 +527,7 @@ Renders a `++json` `val` as a [++tape]().
~zod/try=> (crip (pojo %o (mo sale/(jone 12) same/b/| ~)))
'{"same":false,"sale":12}'
### ++poxo
<h3 id="++poxo"><code>++poxo</code></h3>
Print XML
@ -546,7 +546,7 @@ Renders a `++manx` `a` as a [`++tape`]().
~zod/try=> (poxo ;div:(p:"tree > text" a))
"<div><p>tree &gt; text</p><a></a></div>"
### ++apex
<h3 id="++apex"><code>++apex</code></h3>
Inner XML printer
@ -566,7 +566,7 @@ Inner XML printer
?~(att rez [' ' (attr att rez)])
::
Renders a `++manx` as a [`++tape](), appending a suffix`rez\`.
Renders a `++manx` as a [`++tape`](), appending a suffix `rez\`.
`rez` is a [`++tape`]().
@ -581,7 +581,7 @@ Renders a `++manx` as a [`++tape](), appending a suffix`rez\`.
~zod/try=> (~(apex poxo &) ;div:(p:"tree > text" a) "")
"<div><p>tree > text</p><a></a></div>"
### ++attr
<h3 id="++attr"><code>++attr</code></h3>
Print attributes
@ -609,7 +609,7 @@ Render XML attributes as a [`++tape`]().
~zod/try=> (crip (attr:poxo ~[sam/"hem" [%tok %ns]^"reptor"] "|appen"))
'sam="hem" tok:ns="reptor"|appen'
### ++escp
<h3 id="++escp"><code>++escp</code></h3>
Escape XML
@ -648,7 +648,7 @@ Escapes the XML special characters `"`, `&`, `'`, `<`, `>`.
~zod/try=> `tape`(~(escp poxo &) "x > y" ~)
"x > y"
### ++name
<h3 id="++name"><code>++name</code></h3>
Print name
@ -669,7 +669,7 @@ Renders a `++mane` as a `++tape`.
~zod/try=> (name:poxo %ham^%tor)
"ham:tor"
### ++many
<h3 id="++many"><code>++many</code></h3>
Print node list
@ -697,7 +697,7 @@ Renders multiple XML nodes as a [`++tape`]()
------------------------------------------------------------------------
### ++poxa
<h3 id="++poxa"><code>++poxa</code></h3>
Parse XML
@ -718,7 +718,7 @@ Parses an XML node from a [`++cord`](), producing a unit [`++manx`]().
~zod/try=> (poxa '<<<<')
~
### ++apex
<h3 id="++apex"><code>++apex</code></h3>
Top level parser
@ -745,7 +745,7 @@ Parses a node of XML, type [`++manx`]().
! {1 2}
! exit
### ++attr
<h3 id="++attr"><code>++attr</code></h3>
Parse XML attributes
@ -781,7 +781,7 @@ or more space-prefixed name to string values. Result type [`++mart`]()
! {1 23}
! exit
### ++chrd
<h3 id="++chrd"><code>++chrd</code></h3>
Parse character data
@ -800,7 +800,7 @@ Parsing rule. Parses XML character data. Result type [`++mars`]()
! {1 6}
! exit
### ++comt
<h3 id="++comt"><code>++comt</code></h3>
Parses comments
@ -823,7 +823,7 @@ Parsing rule. Parses XML comment blocks.
! {1 18}
! exit
### ++escp
<h3 id="++escp"><code>++escp</code></h3>
Parse (possibly) escaped char
@ -857,7 +857,7 @@ Parsing rule. Parses a nonspecial or escaped character. Result type
~zod/try=> (rash '&quot;' escp:xmlp)
'"'
### ++empt
<h3 id="++empt"><code>++empt</code></h3>
Parse self-closing tag
@ -876,7 +876,7 @@ Parsing rule. Parses self-closing XML tags that end in `/>`.
! {1 21}
! exit
### ++head
<h3 id="++head"><code>++head</code></h3>
Parse opening tag
@ -895,7 +895,7 @@ Parsing rule. Parses the opening tag of an XML node. Result type
! {1 16}
! exit
### ++name
<h3 id="++name"><code>++name</code></h3>
Parse tag name
@ -922,7 +922,7 @@ Parsing rule. Parses the name of an XML tag. Result type [`++mane`]()
! {1 4}
! exit
### ++tail
<h3 id="++tail"><code>++tail</code></h3>
Parse closing tag
@ -938,7 +938,7 @@ Parsing rule. Parses an XML closing tag.
! {1 3}
! exit
### ++whit
<h3 id="++whit"><code>++whit</code></h3>
Parse whitespace, etc.
@ -960,7 +960,7 @@ Parsing rule. Parses newlines, tabs, and spaces.
! {1 1}
! exit
### ++jo
<h3 id="++jo"><code>++jo</code></h3>
JSON reparsing core
@ -975,7 +975,7 @@ A `fist` is a gate that produces a `grub`.
A `grub` is a unit of some JSON value.
### ++ar
<h3 id="++ar"><code>++ar</code></h3>
Parse array to list
@ -998,7 +998,7 @@ Reparser modifier. Reparses an array to the [`++unit`]() of a homogenous
[~ u=~[1 2]]
{[%~ u=it(@)] %~}
### ++at
<h3 id="++at"><code>++at</code></h3>
Reparse array as tuple
@ -1023,7 +1023,7 @@ Reparser generator. Reparses an array as a fixed-length tuple of
~zod/try=> ((at ni so ni ~):jo a/~[n/'3' s/'to' n/''])
~
### ++at-raw
<h3 id="++at-raw"><code>++at-raw</code></h3>
Reparse array to tuple
@ -1043,7 +1043,7 @@ Reparser generator. Reparses a list of [`++json`]() to a tuple of
~zod/try=> ((at-raw ni ni bo ~):jo ~[s/'hi' n/'1' b/&])
[~ [~ 1] [~ u=%.y] ~]
### ++bo
<h3 id="++bo"><code>++bo</code></h3>
Reparse boolean
@ -1061,7 +1061,7 @@ Reparser modifier. Reparses a boolean to the [`++unit`]() of a
~zod/try=> (bo:jo [%s 'hi'])
~
### ++bu
<h3 id="++bu"><code>++bu</code></h3>
Reparse boolean not
@ -1079,7 +1079,7 @@ of a loobean.
~zod/try=> (bu:jo [%s 'hi'])
~
### ++cu
<h3 id="++cu"><code>++cu</code></h3>
Reparse and transform
@ -1101,7 +1101,7 @@ producing a [`++unit`]().
~zod/try=> ((cu dec ni):jo [%b &])
~
### ++da
<h3 id="++da"><code>++da</code></h3>
Reparse UTC date
@ -1120,7 +1120,7 @@ Reparser modifier. Reparses a UTC date string to a [`++unit`]().
~zod/try=> (da:jo [%n '20'])
~
### ++di
<h3 id="++di"><code>++di</code></h3>
Reparse millisecond date
@ -1143,7 +1143,7 @@ Reparser modifier. Reparses the javascript millisecond date integer to a
~zod/try=> (di:jo [%n '25000'])
[~ ~1970.1.1..00.00.25]
### ++mu
<h3 id="++mu"><code>++mu</code></h3>
Reparse unit
@ -1169,7 +1169,7 @@ value, and are reparsed to results of \~ or (some {value}) respectively
~zod/try=> ((mu ni):jo [%s 'ma'])
~
### ++ne
<h3 id="++ne"><code>++ne</code></h3>
Reparse number as real
@ -1184,7 +1184,7 @@ XX Currently unimplemented
A- yup, this will eventually reparse a floating point atom, but
interfaces for the latter are not currently stable.
### ++ni
<h3 id="++ni"><code>++ni</code></h3>
Reparse number as integer
@ -1211,7 +1211,7 @@ Reparser modifier. Reparses an integer representation to a [\`++unit]().
~zod/try=> (ni:jo [%a ~[b/& b/& b/& b/&]])
~
### ++no
<h3 id="++no"><code>++no</code></h3>
Reparse number as text
@ -1238,7 +1238,7 @@ Reparser modifier. Reparses a numeric representation to a [++cord]().
~zod/try=> (no:jo [%a ~[b/& b/& b/& b/&]])
~
### ++of
<h3 id="++of"><code>++of</code></h3>
Reparse object to frond
@ -1278,7 +1278,7 @@ one of the key-value pairs in `wer`.
~zod/try=> ((of sem/sa som/ni ~):jo %o [%sem s/'hey'] ~ [%sam s/'other value'] ~ ~)
~
### ++ot
<h3 id="++ot"><code>++ot</code></h3>
Reparse object as tuple
@ -1301,7 +1301,7 @@ the [`++edge`](), the results of which are produced in a tuple.
~zod/try=> ((ot sem/sa som/ni sem/sa ~):jo (jobe [%sem s/'ha'] [%som n/'20'] ~))
[~ u=["ha" q=20 "ha"]]
### ++ot-raw
<h3 id="++ot-raw"><code>++ot-raw</code></h3>
++ ot-raw :: object as tuple
|* wer=(pole ,[cord fist])
@ -1321,7 +1321,7 @@ in a tuple.
~zod/try=> ((ot-raw sem/sa som/ni sem/sa ~):jo (mo [%sem s/'ha'] [%som b/|] ~))
[[~ u="ha"] ~ [~ u="ha"] ~]
### ++om
<h3 id="++om"><code>++om</code></h3>
Parse object to map
@ -1342,7 +1342,7 @@ using `wit`.
~zod/try=> ((om ni):jo (jobe [%sap n/'20'] [%sup n/'0x5'] [%sop n/'177'] ~))
~
### ++pe
<h3 id="++pe"><code>++pe</code></h3>
Add prefix
@ -1365,7 +1365,7 @@ Reparser modifier. Adds a static prefix `pre` to the parse result of
~zod/try=> ((pe %hi ni):jo b/|)
~
### ++sa
<h3 id="++sa"><code>++sa</code></h3>
Reparse string to tape
@ -1383,7 +1383,7 @@ Reparser modifier. Reparses a [`++json`]() string to a [`++tape`]().
~zod/try=> (sa:jo a/~[s/'val 2'])
~
### ++so
<h3 id="++so"><code>++so</code></h3>
Reparse string to cord
@ -1401,7 +1401,7 @@ Reparser modifier. Reparses a string to a [`++cord`]().
~zod/try=> (so:jo a/~[s/'val 2'])
~
### ++su
<h3 id="++su"><code>++su</code></h3>
Reparse string
@ -1425,7 +1425,7 @@ Reparser generator. Produces a reparser that applies `sab` to a string.
~zod/try=> ((su:jo fed:ag) n/'20')
~
### ++ul
<h3 id="++ul"><code>++ul</code></h3>
Reparse null
@ -1442,7 +1442,7 @@ Reparser modifier. Reparses a null value.
~zod/try=> (ul:jo b/&)
~
### ++za
<h3 id="++za"><code>++za</code></h3>
Pole of nonempty units
@ -1456,14 +1456,14 @@ Pole of nonempty units
Determines if `pod` contains no empty units, producing a loobean. Used
internally.
`pod` is a [`++pole`]() of [`++units`]().
`pod` is a [`++pole`]() of [`++unit`]().
~zod/try=> (za:jo ~[`1 `2 `3])
%.y
~zod/try=> (za:jo ~[`1 ~ `3])
%.n
### ++zl
<h3 id="++zl"><code>++zl</code></h3>
Collapse unit list
@ -1491,7 +1491,7 @@ empty, produces null.
~zod/try=> (zl:jo `(list (unit))`~[`1 ~ `3])
~
### ++zp
<h3 id="++zp"><code>++zp</code></h3>
Parses a
@ -1514,7 +1514,7 @@ Collapses a `++pole` of `++unit`s `but`, producing a tuple.
~zod/try=> (zp:jo `(pole (unit))`~[`1 ~ `3])
! exit
### ++zm
<h3 id="++zm"><code>++zm</code></h3>
Collapse unit map
@ -1545,7 +1545,7 @@ See also: [`++zp`](), [`++zl`]().
~zod/try=> (~(run by `(map ,@t ,@u)`(mo a/1 b/7 c/3 ~)) (flit |=(a=@ (lth a 5))))
{[p='a' q=[~ u=1]] [p='c' q=[~ u=3]] [p='b' q=~]}
### ++joba
<h3 id="++joba"><code>++joba</code></h3>
`++json` from key-value pair
@ -1570,7 +1570,7 @@ Produces a ++json object with one key.
~zod/try=> (crip (pojo (joba %hi (jone 2.130))))
'{"hi":2130}'
### ++jobe
<h3 id="++jobe"><code>++jobe</code></h3>
Object from key-value list
@ -1589,7 +1589,7 @@ Produces a `++json` object from a list `a` of key to `++json` values.
~zod/try=> (crip (pojo (jobe a/n/'20' b/~ c/a/~[s/'mol'] ~)))
'{"b":null,"c":["mol"],"a":20}'
### ++jape
<h3 id="++jape"><code>++jape</code></h3>
`++json` string from tape
@ -1610,7 +1610,7 @@ Produces a [`++json`]() string from a [`++tape`]().
~zod/try=> (crip (pojo (jape "semtek som? zeplo!")))
'"semtek som? zeplo!"'
### ++jone
<h3 id="++jone"><code>++jone</code></h3>
`++json` number from unigned
@ -1635,7 +1635,7 @@ Produces a `++json` number from an unsigned atom.
~zod/try=> (pojo (jone 1.203.196))
"1203196"
### ++jesc
<h3 id="++jesc"><code>++jesc</code></h3>
Escape JSON character
@ -1648,9 +1648,9 @@ Escape JSON character
==
::
Produces a `++tape` of an escaped [`++json`]() character `a`.
Produces a `++tape` of an escaped [`++json`](/doc/hoon/library/3bi#++json) character `a`.
`a` is an [`++atom`]()
`a` is an atom
~zod/try=> (jesc 'a')
"a"
@ -1661,7 +1661,7 @@ Produces a `++tape` of an escaped [`++json`]() character `a`.
~zod/try=> (jesc '"')
"\""
### ++scanf
<h3 id="++scanf"><code>++scanf</code></h3>
Formatted scan
@ -1693,7 +1693,7 @@ collapses the result list to a tuple, such that (scanf "foo 1 2 bar"
~zod/try=> `@da`(year `date`dat(- [%& -.dat], |6 ~[(div (mul |6.dat (bex 16)) 1.000)]))
~2014.8.12..23.10.58..ee56
### ++parsf
<h3 id="++parsf"><code>++parsf</code></h3>
++ parsf :: make parser from:
|^ |* a=(pole ,_:/(*$&(_rule tape))) :: ;"chars{rule}chars"
@ -1745,7 +1745,7 @@ more convenient list of discriminated tapes and rules.
`bill` builds a parser out of rules and tapes, ignoring the literal
sections and producing a list of the rules' results.
### ++taco
<h3 id="++taco"><code>++taco</code></h3>
++ taco :: atom to octstream
|= tam=@ ^- octs
@ -1759,7 +1759,7 @@ An [octs] contains a length, to encode trailing zeroes.
~zod/try=> `@t`6.513.249
'abc'
### ++tact
<h3 id="++tact"><code>++tact</code></h3>
++ tact :: tape to octstream
|= tep=tape ^- octs
@ -1773,7 +1773,7 @@ octs from tape
~zod/try=> `@t`6.513.249
'abc'
### ++tell
<h3 id="++tell"><code>++tell</code></h3>
++ tell :: wall to octstream
|= wol=wall ^- octs
@ -1792,7 +1792,7 @@ octs from wall
3
'''
### ++txml
<h3 id="++txml"><code>++txml</code></h3>
++ txml :: string to xml
|= tep=tape ^- manx

138
main/pub/doc/hoon/library/3be.md
View File

@ -1,7 +1,7 @@
section 3bE, tree sync
======================
### ++invert-miso
<h3 id="++invert-miso"><code>++invert-miso</code></h3>
++ invert-miso :: invert miso
|= mis=miso
@ -14,7 +14,7 @@ section 3bE, tree sync
XX document
### ++cosh
<h3 id="++cosh"><code>++cosh</code></h3>
++ cosh :: locally rehash
|= ank=ankh :: NB v/unix.c
@ -23,7 +23,7 @@ XX document
XX document
### ++cost
<h3 id="++cost"><code>++cost</code></h3>
++ cost :: new external patch
|= [bus=ankh ank=ankh] :: NB v/unix.c
@ -35,7 +35,7 @@ XX document
XX document
### ++loth
<h3 id="++loth"><code>++loth</code></h3>
++ loth
|= pat=(map path ,*)
@ -47,7 +47,7 @@ XX document
XX document
### ++luth
<h3 id="++luth"><code>++luth</code></h3>
++ luth
|= [p=(map path ,*) q=(map path ,*)] :: merge keysets
@ -57,7 +57,7 @@ XX document
XX document
### ++blob-to-lobe
<h3 id="++blob-to-lobe"><code>++blob-to-lobe</code></h3>
++ blob-to-lobe :: p.blob
|= p=blob
@ -71,20 +71,20 @@ XX document
XX document
### ++ze
<h3 id="++ze"><code>++ze</code></h3>
++ ze
|_ [lim=@da dome rang]
XX document
### ++aeon-to-tako
<h3 id="++aeon-to-tako"><code>++aeon-to-tako</code></h3>
++ aeon-to-tako ~(got by hit)
XX document
### ++make-yaki
<h3 id="++make-yaki"><code>++make-yaki</code></h3>
++ make-yaki :: make yaki
|= [p=(list tako) q=(map path lobe) t=@da]
@ -97,19 +97,19 @@ XX document
XX document
### ++tako-to-yaki
<h3 id="++tako-to-yaki"><code>++tako-to-yaki</code></h3>
++ tako-to-yaki ~(got by hut) :: grab yaki
XX document
### ++lobe-to-blob
<h3 id="++lobe-to-blob"><code>++lobe-to-blob</code></h3>
++ lobe-to-blob ~(got by lat) :: grab blob
XX document
### ++lobe-to-noun
<h3 id="++lobe-to-noun"><code>++lobe-to-noun</code></h3>
++ lobe-to-noun :: grab blob
|= p=lobe :: ^- *
@ -119,7 +119,7 @@ XX document
XX document
### ++make-direct
<h3 id="++make-direct"><code>++make-direct</code></h3>
++ make-direct :: make blob
|= [p=* q=umph]
@ -129,7 +129,7 @@ XX document
XX document
### ++make-delta
<h3 id="++make-delta"><code>++make-delta</code></h3>
++ make-delta :: make blob delta
|= [p=lobe q=udon]
@ -144,7 +144,7 @@ XX document
XX document
### ++blob-to-umph
<h3 id="++blob-to-umph"><code>++blob-to-umph</code></h3>
++ blob-to-umph :: blob umph [prep]
|= p=blob :: used in merge
@ -158,7 +158,7 @@ XX document
XX document
### ++blob-to-noun
<h3 id="++blob-to-noun"><code>++blob-to-noun</code></h3>
++ blob-to-noun :: grab blob
|= p=blob
@ -173,7 +173,7 @@ XX document
XX document
### ++diff-yakis
<h3 id="++diff-yakis"><code>++diff-yakis</code></h3>
++ diff-yakis :: fundamental diff
|= [p=yaki q=yaki]
@ -198,7 +198,7 @@ XX document
XX document
### ++lobes-at-path
<h3 id="++lobes-at-path"><code>++lobes-at-path</code></h3>
++ lobes-at-path :: lobes-at-path:ze
|= [oan=aeon pax=path] :: data at path
@ -222,7 +222,7 @@ XX document
XX document
### ++case-to-aeon
<h3 id="++case-to-aeon"><code>++case-to-aeon</code></h3>
++ case-to-aeon :: case-to-aeon:ze
|= lok=case :: act count through
@ -247,7 +247,7 @@ XX document
XX document
### ++as-arch
<h3 id="++as-arch"><code>++as-arch</code></h3>
++ as-arch :: as-arch:ze
^- arch :: arch report
@ -260,7 +260,7 @@ XX document
XX document
### ++reachable-takos
<h3 id="++reachable-takos"><code>++reachable-takos</code></h3>
++ reachable-takos :: reachable
|= p=tako :: XX slow
@ -276,7 +276,7 @@ XX document
XX document
### ++new-lobes
<h3 id="++new-lobes"><code>++new-lobes</code></h3>
++ new-lobes :: object hash set
|= [b=(set lobe) a=(set tako)] :: that aren't in b
@ -300,7 +300,7 @@ XX document
XX document
### ++new-lobes-takos
<h3 id="++new-lobes-takos"><code>++new-lobes-takos</code></h3>
++ new-lobes-takos :: garg & repack
|= [b=(set lobe) a=(set tako)]
@ -310,7 +310,7 @@ XX document
XX document
### ++reachable-between-takos
<h3 id="++reachable-between-takos"><code>++reachable-between-takos</code></h3>
++ reachable-between-takos
|= [a=(unit tako) b=tako] :: pack a through b
@ -337,7 +337,7 @@ XX document
XX document
### ++takos-to-yakis
<h3 id="++takos-to-yakis"><code>++takos-to-yakis</code></h3>
++ takos-to-yakis :: trivial
|= a=(set tako)
@ -347,7 +347,7 @@ XX document
XX document
### ++lobes-to-blobs
<h3 id="++lobes-to-blobs"><code>++lobes-to-blobs</code></h3>
++ lobes-to-blobs :: trivial
|= a=(set lobe)
@ -357,7 +357,7 @@ XX document
XX document
### ++make-nako
<h3 id="++make-nako"><code>++make-nako</code></h3>
++ make-nako :: gack a through b
|= [a=aeon b=aeon]
@ -376,7 +376,7 @@ XX document
XX document
### ++query
<h3 id="++query"><code>++query</code></h3>
++ query :: query:ze
|= ren=?(%u %v %x %y %z) :: endpoint query
@ -392,7 +392,7 @@ XX document
XX document
### ++rewind
<h3 id="++rewind"><code>++rewind</code></h3>
++ rewind :: rewind:ze
|= oan=aeon :: rewind to aeon
@ -405,7 +405,7 @@ XX document
XX document
### ++update-lat
<h3 id="++update-lat"><code>++update-lat</code></h3>
++ update-lat :: update-lat:ze
|= [lag=(map path blob) sta=(map lobe blob)] :: fix lat
@ -420,7 +420,7 @@ XX document
XX document
### ++apply-changes
<h3 id="++apply-changes"><code>++apply-changes</code></h3>
++ apply-changes :: apply-changes:ze
|= lar=(list ,[p=path q=miso]) :: store changes
@ -463,7 +463,7 @@ XX document
XX document
### ++checkout-ankh
<h3 id="++checkout-ankh"><code>++checkout-ankh</code></h3>
++ checkout-ankh :: checkout-ankh:ze
|= hat=(map path lobe) :: checkout commit
@ -485,7 +485,7 @@ XX document
XX document
### ++forge-yaki
<h3 id="++forge-yaki"><code>++forge-yaki</code></h3>
++ forge-yaki :: forge-yaki:ze
|= [wen=@da par=(unit tako) lem=soba] :: forge yaki
@ -499,7 +499,7 @@ XX document
XX document
### ++forge-nori
<h3 id="++forge-nori"><code>++forge-nori</code></h3>
++ forge-nori :: forge-nori:ze
|= yak=yaki :: forge nori (ugly op)
@ -513,7 +513,7 @@ XX document
XX document
### ++reduce-merge-points
<h3 id="++reduce-merge-points"><code>++reduce-merge-points</code></h3>
++ reduce-merge-points :: reduce merge points
|= unk=(set yaki) :: maybe need jet
@ -539,7 +539,7 @@ XX document
XX document
### ++future-find-merge-points
<h3 id="++future-find-merge-points"><code>++future-find-merge-points</code></h3>
++ future-find-merge-points :: merge points fast
|= [p=yaki q=yaki] :: (future zeal)
@ -566,7 +566,7 @@ XX document
XX document
### ++add-parents
<h3 id="++add-parents"><code>++add-parents</code></h3>
++ add-parents :: expand set
|= qez=(set tako)
@ -579,7 +579,7 @@ XX document
XX document
### ++find-merge-points
<h3 id="++find-merge-points"><code>++find-merge-points</code></h3>
++ find-merge-points :: merge points
|= [p=yaki q=yaki] :: maybe need jet
@ -599,7 +599,7 @@ XX document
XX document
### ++clean
<h3 id="++clean"><code>++clean</code></h3>
++ clean :: clean
|= wig=(urge)
@ -617,7 +617,7 @@ XX document
XX document
### ++match-conflict
<h3 id="++match-conflict"><code>++match-conflict</code></h3>
++ match-conflict :: match conflict
|= [us=[ship desk] th=[ship desk] p=(urge) q=(urge) r=(list)]
@ -634,7 +634,7 @@ XX document
XX document
### ++annotate
<h3 id="++annotate"><code>++annotate</code></h3>
++ annotate :: annotate conflict
|= [us=[ship desk] th=[ship desk] p=(list ,@t) q=(list ,@t) r=(list ,@t)]
@ -665,7 +665,7 @@ XX document
XX document
### ++match-merge
<h3 id="++match-merge"><code>++match-merge</code></h3>
++ match-merge :: match merge
|= [p=(urge ,@t) q=(urge ,@t) r=(list ,@t)] :: resolve conflict
@ -734,7 +734,7 @@ XX document
XX document
### ++qeal
<h3 id="++qeal"><code>++qeal</code></h3>
++ qeal :: merge p,q
|* [us=[ship desk] th=[ship desk] pat=path p=miso q=miso r=(list) con=?]
@ -798,7 +798,7 @@ XX document
XX document
### ++quil
<h3 id="++quil"><code>++quil</code></h3>
++ quil :: merge p,q
|= $: us=[ship desk]
@ -836,7 +836,7 @@ XX document
XX document
### ++meld
<h3 id="++meld"><code>++meld</code></h3>
++ meld :: merge p,q from r
|= [p=yaki q=yaki r=yaki con=? us=[ship desk] th=[ship desk]]
@ -887,7 +887,7 @@ XX document
XX document
### ++mate
<h3 id="++mate"><code>++mate</code></h3>
++ mate :: merge p,q
|= con=? :: %mate, %meld
@ -903,7 +903,7 @@ XX document
XX document
### ++keep
<h3 id="++keep"><code>++keep</code></h3>
++ keep :: %this
|= [p=yaki q=yaki [ship desk] [ship desk]]
@ -916,7 +916,7 @@ XX document
XX document
### ++drop
<h3 id="++drop"><code>++drop</code></h3>
++ drop :: %that
|= [p=yaki q=yaki r=[ship desk] s=[ship desk]]
@ -926,7 +926,7 @@ XX document
XX document
### ++forge
<h3 id="++forge"><code>++forge</code></h3>
++ forge :: %forge
|= [p=yaki q=yaki s=[ship desk] t=[ship desk]]
@ -960,7 +960,7 @@ XX document
XX document
### ++merge
<h3 id="++merge"><code>++merge</code></h3>
++ merge
|= [us=[ship desk] th=[ship desk]]
@ -978,7 +978,7 @@ XX document
XX document
### ++strategy
<h3 id="++strategy"><code>++strategy</code></h3>
++ strategy :: merge strategy
|= gem=?(%meld %mate %that %this)
@ -992,7 +992,7 @@ XX document
XX document
### ++construct-merge
<h3 id="++construct-merge"><code>++construct-merge</code></h3>
++ construct-merge :: construct-merge:ze
|= [gem=germ who=ship des=desk sab=saba now=@da] :: construct merge
@ -1040,7 +1040,7 @@ XX document
XX document
### ++read
<h3 id="++read"><code>++read</code></h3>
++ read :: read:ze
|= mun=mood :: read at point
@ -1061,7 +1061,7 @@ XX document
XX document
### ++read-at-aeon
<h3 id="++read-at-aeon"><code>++read-at-aeon</code></h3>
++ read-at-aeon :: read-at-aeon:ze
|= [oan=aeon mun=mood] :: seek and read
@ -1073,7 +1073,7 @@ XX document
XX document
### ++equiv
<h3 id="++equiv"><code>++equiv</code></h3>
++ equiv :: test paths
|= [p=(map path lobe) q=(map path lobe)]
@ -1096,7 +1096,7 @@ XX document
XX document
### ++edit
<h3 id="++edit"><code>++edit</code></h3>
++ edit :: edit:ze
|= [wen=@da lem=nori] :: edit
@ -1126,7 +1126,7 @@ XX document
XX document
### ++zu
<h3 id="++zu"><code>++zu</code></h3>
++ zu :: filesystem
|= ank=ankh :: filesystem state
@ -1136,7 +1136,7 @@ XX document
XX document
### ++rehash
<h3 id="++rehash"><code>++rehash</code></h3>
++ rehash :: local rehash
^- cash
@ -1153,13 +1153,13 @@ XX document
XX document
### ++update-hash
<h3 id="++update-hash"><code>++update-hash</code></h3>
++ update-hash %_(. p.ank rehash) :: rehash and save
XX document
### ++ascend
<h3 id="++ascend"><code>++ascend</code></h3>
++ ascend :: ascend
|= [lol=@ta kan=ankh]
@ -1177,7 +1177,7 @@ XX document
XX document
### ++push-change
<h3 id="++push-change"><code>++push-change</code></h3>
++ push-change :: add change
|= mis=miso
@ -1187,7 +1187,7 @@ XX document
XX document
### ++descend
<h3 id="++descend"><code>++descend</code></h3>
++ descend :: descend
|= lol=@ta
@ -1198,7 +1198,7 @@ XX document
XX document
### ++descend-path
<h3 id="++descend-path"><code>++descend-path</code></h3>
++ descend-path :: descend recursively
|= way=path
@ -1208,7 +1208,7 @@ XX document
XX document
### ++overwrite
<h3 id="++overwrite"><code>++overwrite</code></h3>
++ overwrite :: write over
|= [pum=umph val=(unit ,[p=cash q=*])]
@ -1224,7 +1224,7 @@ XX document
XX document
### ++change-tree
<h3 id="++change-tree"><code>++change-tree</code></h3>
++ change-tree :: modify tree
|= [pum=umph bus=ankh]
@ -1243,7 +1243,7 @@ XX document
XX document
### ++rm-r
<h3 id="++rm-r"><code>++rm-r</code></h3>
++ rm-r :: rm -r
|- ^+ +
@ -1257,7 +1257,7 @@ XX document
XX document
### ++drum
<h3 id="++drum"><code>++drum</code></h3>
++ drum :: apply effect
|= [pax=path mis=miso] :: XX unused (++dune)
@ -1285,7 +1285,7 @@ XX document
XX document
### ++dune
<h3 id="++dune"><code>++dune</code></h3>
++ dune :: apply
|- ^+ + :: XX unused (++durn)
@ -1296,7 +1296,7 @@ XX document
XX document
### ++durn
<h3 id="++durn"><code>++durn</code></h3>
++ durn :: apply forward
|= nyp=soba :: XX unused

22
main/pub/doc/hoon/library/3bf.md
View File

@ -1,7 +1,7 @@
section 3bF, filesystem interface
=================================
### ++feel
<h3 id="++feel"><code>++feel</code></h3>
Generate file diff
@ -33,7 +33,7 @@ Generates a diff between a file located at `pax` and an input value
~zod/try=> `@t`272.335.332.724
'tesh?'
### ++file
<h3 id="++file"><code>++file</code></h3>
Simple file load
@ -62,7 +62,7 @@ Reads the value of a file located at `pax` and renders it as a
~zod/try=/zak> (file /==2%/mop)
~
### ++foal
<h3 id="++foal"><code>++foal</code></h3>
Write high-level change
@ -90,7 +90,7 @@ at `pax`. Handled by `%clay`.
~zod/try=> (feel %/mek 'b')
[%mut p=[p=%a q=[%a p=97 q=98]]]
### ++fray
<h3 id="++fray"><code>++fray</code></h3>
High-level delete
@ -113,7 +113,7 @@ Handled by `%clay`.
~zod/try=> `@t`97
'a'
### ++furl
<h3 id="++furl"><code>++furl</code></h3>
Unify changes
@ -148,7 +148,7 @@ and pointed at the same [`++path`]().
]
]
### ++meat
<h3 id="++meat"><code>++meat</code></h3>
Kite to .\^ path
@ -181,7 +181,7 @@ Converts a type request name to a [`++path`]().
'''
### ++tame
<h3 id="++tame"><code>++tame</code></h3>
Parse kite path
@ -209,7 +209,7 @@ Parse kite path
::
Parses a clay [.\^]()
[`++path]()to request details. Produces the [`++unit`]() of a [`++kite\`]().
[`++path` ]()to request details. Produces the [`++unit`]() of a [`++kite`]().
`hap` is a [`++path`]().
@ -220,7 +220,7 @@ Parses a clay [.\^]()
~zod/try=/zop> (tame /~zod/main/0x12/sur/down/gate/hook)
~
### ++tome
<h3 id="++tome"><code>++tome</code></h3>
Parse path to beam
@ -249,7 +249,7 @@ Parses a [`++path`]() `pax` to a [\`++beam](), a well-typed location.
~zod/try=/zop> (tome /~zod/main/0x12)
~
### ++tope :: beam to path
<h3 id="++tope :: beam to path"><code>++tope :: beam to path</code></h3>
Parse beam to path
@ -257,7 +257,7 @@ Parse beam to path
^- path
[(scot %p p.bem) q.bem (scot r.bem) (flop s.bem)]
Parses a [`++beam`]() to a [`++path`]().
Parses a [`++beam`]() to a [`++path`](/doc/hoon/library/1#++path).
~zod/try=/zop> (tope [~zod %main ud/1] /hook/down/sur)
/~zod/main/1/sur/down/hook

78
main/pub/doc/hoon/library/3bg.md
View File

@ -1,7 +1,7 @@
section 3bG, URL handling
=========================
### ++deft
<h3 id="++deft"><code>++deft</code></h3>
Import URL path
@ -34,7 +34,7 @@ either by a `.` or a `/`.
~zod/try=> (deft /foo/bar/baz)
[p=~ q=<|foo bar baz|>]
### ++fain
<h3 id="++fain"><code>++fain</code></h3>
Restructure path
@ -50,7 +50,7 @@ Restructure path
::
Splits a concrete
[`++spur]() out of a full`++path`, producing a location [`++beam`]() and a remainder [`++path\`]().
[`++spur`]() out of a full `++path`, producing a location [`++beam`]() and a remainder [`++path`]().
`hom` is a [`++path`]()
@ -73,7 +73,7 @@ Splits a concrete
q=/._req_1234__
]
### ++fuel
<h3 id="++fuel"><code>++fuel</code></h3>
Parse fcgi
@ -135,7 +135,7 @@ Retrieieves the %eyre FCGI, producing a [`++epic`](). Used primarily in
nyp=/gen
]
### ++sifo
<h3 id="++sifo"><code>++sifo</code></h3>
64-bit encode
@ -164,7 +164,7 @@ Encodes an atom to MIME base64, producing a [`++tape`]().
~zod/main=> (sifo (shax %hi))
"j0NDRmSPa5bfid2pAcUXaxCm2Dlh3TwayItZstwyeqQ="
### ++urle
<h3 id="++urle"><code>++urle</code></h3>
Encode URL
@ -198,7 +198,7 @@ escape sequences.
~zod/main=> (urle "hello-my?=me !")
"hello-my%3F%3Dme%20%20%21"
### ++urld
<h3 id="++urld"><code>++urld</code></h3>
Decode URL
@ -231,7 +231,7 @@ The inverse of [`++urle`](). Parses a URL escaped tape to the
~zod/main=> (urld "hello-my%3F%3Dme%20%2%21")
~
### ++earl
<h3 id="++earl"><code>++earl</code></h3>
Localize purl
@ -256,7 +256,7 @@ Prepends a ship name to the spur of a [`++purl`]().
~zod/main=> (earn (earl ~pittyp (need (epur 'http://123.1.1.1/me.ham'))))
"http://123.1.1.1/pittyp/me"
### ++earn
<h3 id="++earn"><code>++earn</code></h3>
Purl to tape
@ -287,7 +287,7 @@ Parses a `++purl` `pul` to a [`++tape`]().
~zod/main=> (earn [& ~ `/com/google/www] [~ /search] [%q 'urbit escaping?'] ~)
"https://www.google.com/search?q=urbit%20escaping%3F"
### ++body
<h3 id="++body"><code>++body</code></h3>
Render URL path
@ -311,7 +311,7 @@ Renders URL path `pok` as a [`++tape`]().
~zod/main=> (body:earn `%htm /)
""
### ++head
<h3 id="++head"><code>++head</code></h3>
Render URL beginning
@ -344,7 +344,7 @@ of a traditional URL.
~zod/main=> (head:earn & [~ 8.080] %& /com/google/www)
"https://www.google.com:8080"
### ++tail
<h3 id="++tail"><code>++tail</code></h3>
Render query string
@ -376,7 +376,7 @@ traditional query string.
~zod/main=> (tail:earn [%ask 'bid'] [%make 'well'] ~)
"?ask=bid&make=well"
### ++epur
<h3 id="++epur"><code>++epur</code></h3>
Top-level URL parser
@ -386,7 +386,7 @@ Top-level URL parser
Toplevel URL parser.
`a` is a [`++cord`]().
`a` is a [`++cord`](/doc/hoon/library/1#++cord).
~zod/main=> (epur 'http://127.0.0.1/')
[~ [p=[p=%.n q=~ r=[%.n p=.127.0.0.1]] q=[p=~ q=<||>] r=~]]
@ -428,7 +428,7 @@ Toplevel URL parser.
]
]
### ++apat
<h3 id="++apat"><code>++apat</code></h3>
++ apat :: 2396 abs_path
%+ cook deft
@ -441,7 +441,7 @@ URL path as ++pork
~zod/try=> (scan "/foo/mol/lok.htm" apat:epur)
[p=[~ ~.htm] q=<|foo mol lok|>]
### ++auri
<h3 id="++auri"><code>++auri</code></h3>
++ auri
%+ cook
@ -546,7 +546,7 @@ URL parsing rule
]
]
### ++cock
<h3 id="++cock"><code>++cock</code></h3>
++ cock :: cookie
(most ;~(plug sem ace) ;~(plug toke ;~(pfix tis tosk)))
@ -561,7 +561,7 @@ HTTP cookies, results in associative list of cord to cord.
! {1 34}
! exit
### ++dlab
<h3 id="++dlab"><code>++dlab</code></h3>
++ dlab :: 2396 domainlabel
%+ sear
@ -583,7 +583,7 @@ Domain label: alphanumeric, with `-` allowed in middle.
! {1 8}
! exit
### ++fque
<h3 id="++fque"><code>++fque</code></h3>
++ fque (cook crip (plus pquo)) :: normal query field
@ -601,7 +601,7 @@ One or more query string characters
! {1 1}
! exit
### ++fquu
<h3 id="++fquu"><code>++fquu</code></h3>
++ fquu (cook crip (star pquo)) :: optional field
@ -618,7 +618,7 @@ Zero or more query string characters
~zod/try=> (scan "" fquu:epur)
''
### ++pcar
<h3 id="++pcar"><code>++pcar</code></h3>
++ pcar ;~(pose pure pesc psub col pat) :: 2396 path char
@ -639,7 +639,7 @@ or `@`
~zod/try=> (scan "!" pcar:epur)
~~~21.
### ++pcok
<h3 id="++pcok"><code>++pcok</code></h3>
++ pcok ;~(less bas sem com doq prn) :: cookie char
@ -656,7 +656,7 @@ Cookie character
! {1 2}
! exit
### ++pesc
<h3 id="++pesc"><code>++pesc</code></h3>
++ pesc ;~(pfix cen mes) :: 2396 escaped
@ -667,7 +667,7 @@ URL `%` escape, by two hex characters.
~zod/try=> `@t`(scan "%20" pesc:epur)
' '
### ++pold
<h3 id="++pold"><code>++pold</code></h3>
++ pold (cold ' ' (just '+')) :: old space code
@ -679,7 +679,7 @@ Old URL `' '` escape
! {1 1}
! exit
### ++pque
<h3 id="++pque"><code>++pque</code></h3>
++ pque ;~(pose pcar fas wut) :: 3986 query char
@ -694,7 +694,7 @@ Irregular query string character.
~zod/try=> `@t`(scan "+" pque:epur)
'+'
### ++pquo
<h3 id="++pquo"><code>++pquo</code></h3>
++ pquo ;~(pose pure pesc pold) :: normal query char
@ -712,7 +712,7 @@ Character in query string key/value
~zod/try=> (scan "+" pquo:epur)
' '
### ++pure
<h3 id="++pure"><code>++pure</code></h3>
++ pure ;~(pose aln hep dot cab sig) :: 2396 unreserved
@ -728,7 +728,7 @@ URL-safe character
~zod/try=> (scan "-" pure:epur)
~~-
### ++psub
<h3 id="++psub"><code>++psub</code></h3>
++ psub ;~ pose :: 3986 sub-delims
zap buc pam soq pel per
@ -747,7 +747,7 @@ URL path subdelimeter
! {1 1}
! exit
### ++ptok
<h3 id="++ptok"><code>++ptok</code></h3>
++ ptok ;~ pose :: 2616 token
aln zap hax buc cen pam soq tar lus
@ -761,7 +761,7 @@ Character valid in HTTP token
~zod/try=> `tape`(skim =+(a=' ' |-(`tape`?:(=(0x7f a) ~ [a $(a +(a))]))) |=(a=char ?=(~ (rush a ptok:epur))))
" "(),/:;<=>?@[\]{}"
### ++scem
<h3 id="++scem"><code>++scem</code></h3>
++ scem :: 2396 scheme
%+ cook cass
@ -778,7 +778,7 @@ alphanumeric, `+` `-` or `.`
~zod/try=> `@t`(scan "chrome-extension" scem:epur)
'chrome-extension'
### ++smeg
<h3 id="++smeg"><code>++smeg</code></h3>
++ smeg (cook crip (plus pcar)) :: 2396 segment
@ -789,7 +789,7 @@ URL path segment
~zod/try=> (scan "bar%20baz-bam" smeg:epur)
'bar baz-bam'
### ++tock
<h3 id="++tock"><code>++tock</code></h3>
++ tock (cook crip (plus pcok)) :: 6265 cookie-value
@ -804,7 +804,7 @@ HTTP cookie value
~zod/try=> (rush '"zemug"' tock:epur)
~
### ++tosk
<h3 id="++tosk"><code>++tosk</code></h3>
++ tosk ;~(pose tock (ifix [doq doq] tock)) :: 6265 cookie-value
@ -819,7 +819,7 @@ Possibly quoted HTTP cookie value
~zod/try=> (rush '"zemug"' tosk:epur)
[~ 'zemug']
### ++toke
<h3 id="++toke"><code>++toke</code></h3>
++ toke (cook crip (plus ptok)) :: 2616 token
@ -834,7 +834,7 @@ HTTP cookie name
~zod/try=> (rush '"zemug"' toke:epur)
~
### ++thor
<h3 id="++thor"><code>++thor</code></h3>
++ thor :: 2396 host/port
%+ cook |*(a=[* *] [+.a -.a])
@ -854,7 +854,7 @@ Parse ++host and unit `@ui` port.
~zod/try=> (scan "www.google.com" thor:epur)
[~ [%.y i='com' t=~['google' 'www']]]
### ++thos
<h3 id="++thos"><code>++thos</code></h3>
++ thos :: 2396 host, no local
;~ plug
@ -887,7 +887,7 @@ URI host: dot-separated segments, or IP address.
~zod/try=> (scan "www.google.com" thos:epur)
[%.y i='com' t=~['google' 'www']]
### ++yque
<h3 id="++yque"><code>++yque</code></h3>
++ yque :: query ending
;~ pose
@ -904,7 +904,7 @@ Parses query string, or lack thereof. Result type ++quay
~zod/try=> (scan "" yque:epur)
~
### ++yquy
<h3 id="++yquy"><code>++yquy</code></h3>
++ yquy :: query
;~ pose :: proper query
@ -926,7 +926,7 @@ Parse query string after `?`
~zod/try=> (scan "" yquy:epur)
~
### ++zest
<h3 id="++zest"><code>++zest</code></h3>
++ zest :: 2616 request-uri
;~ pose

24
main/pub/doc/hoon/library/3bh.md
View File

@ -1,7 +1,7 @@
section 3bH, names etc
======================
### ++clan
<h3 id="++clan"><code>++clan</code></h3>
++ clan :: ship to rank
|= who=ship ^- rank
@ -24,7 +24,7 @@ Ship class
~zod/main=> (clan ~tasfyn-partyv)
%duke
### ++glam
<h3 id="++glam"><code>++glam</code></h3>
++ glam
|= zar=@pD ^- tape
@ -94,7 +94,7 @@ Retrieve carrier name.
~zod/main=> (glam ~fyr)
"Bolivar"
### ++glon
<h3 id="++glon"><code>++glon</code></h3>
++ glon
|= lag=lang
@ -296,7 +296,7 @@ ISO language code
~zod/main=> (glon %mz)
~
### ++gnom
<h3 id="++gnom"><code>++gnom</code></h3>
++ gnom :: ship display name
|= [[our=@p now=@da] him=@p] ^- @t
@ -316,7 +316,7 @@ Fetch display name from %ames
~zod/main=> (gnom [->-< -<-] ~tug)
'~tug |Go-Daigo|'
### ++gnow
<h3 id="++gnow"><code>++gnow</code></h3>
++ gnow
|= [who=@p gos=gcos] ^- @t
@ -348,7 +348,7 @@ Fetch display name from %ames
XX Document
### ++hunt
<h3 id="++hunt"><code>++hunt</code></h3>
++ hunt :: first of unit dates
|= [one=(unit ,@da) two=(unit ,@da)]
@ -360,7 +360,7 @@ XX Document
XX Document
### ++mojo
<h3 id="++mojo"><code>++mojo</code></h3>
++ mojo :: compiling load
|= [pax=path src=*]
@ -381,7 +381,7 @@ XX Document
XX Document
### ++mole
<h3 id="++mole"><code>++mole</code></h3>
++ mole :: new to old sky
|= ska=$+(* (unit (unit)))
@ -395,7 +395,7 @@ XX Document
XX Document
### ++much
<h3 id="++much"><code>++much</code></h3>
++ much :: constructing load
|= [pax=path src=*]
@ -407,7 +407,7 @@ XX Document
XX Document
### ++musk
<h3 id="++musk"><code>++musk</code></h3>
++ musk :: compiling apply
|= [pax=path src=* sam=vase]
@ -419,7 +419,7 @@ XX Document
XX Document
### ++saxo
<h3 id="++saxo"><code>++saxo</code></h3>
++ saxo :: autocanon
|= who=ship
@ -437,7 +437,7 @@ Compute list of ancestors
~zod/main=> (saxo ~ractul-fodsug-sibryg-modsyl--difrun-mirfun-filrec-patmet)
~[~ractul-fodsug-sibryg-modsyl--difrun-mirfun-filrec-patmet ~zod]
### ++sein
<h3 id="++sein"><code>++sein</code></h3>
++ sein :: autoboss
|= who=ship ^- ship

366
main/pub/doc/hoon/library/3bi.md
View File

File diff suppressed because it is too large Load Diff

134
main/pub/sole/fab/hymn.hook
View File

@ -32,134 +32,8 @@
;body
;div#err;
;div#term:""
;script(type "text/coffeescript") ;- %- trip
'''
[DOM,recl,rend] = [React.DOM, React.createClass, React.renderComponent]
[div, pre] = [DOM.div, DOM.pre]
Matr = recl render: ->
[pro,cur] = [@props.prompt + " ", @props.cursor + 1]
prompt = "#{pro.slice(0,cur)}\u0332#{pro.slice(cur)}"
lines = [prompt, @props.rows...]
div {}, lines.slice().reverse().map (lin)->
pre {}, lin
$ ->
termRev = 0
pressed = []
deltim = null
met = $('<pre>').text('m').css(display: 'none').appendTo(term).width()
subs = ""
# $(window).resize ->
# window.termWif = ($(term).width() / met).toFixed()
# path = "/new/#{termWif}"
# if path is subs
# return
# if subs
# urb.unsubscribe {path:subs}
# subs = path
# urb.subscribe {path}, (err,dat)->
# if err or dat.data.ok
# return;
# syncRev = dat.data.rev
# unless termRev > syncRev
# termRev = syncRev
# matr.setProps rows: dat.data.stak
# document.title = "Matrix" # XX debug
# $(window).resize()
matr = rend (Matr rows:[], prompt:"", cursor:1), term
flash = ($el, background)->
$el.css {background}
if background
setTimeout (()-> flash $el,''), 50
peer = (ruh) ->
switch false
when !ruh.map then ruh.map peer
# when !ruh.pro then matr.setProps prompt: ruh.pro
# when !ruh.hop then matr.setProps cursor: ruh.hop
# when !ruh.out
# matr.setProps rows: [ruh.out, matr.props.rows...]
# when !ruh.act then switch ruh.act
# when 'clr' then matr.setProps rows:[]
# when 'bel' then flash ($ 'body'), 'black'
# else throw "Unknown "+(JSON.stringify ruh)
else console.log ruh
urb.bind "/sole", {wire:"/"}, (err,d)->
if d.data then peer d.data
#later = (data)->
# if data
# pressed.push data
# clearTimeout deltim
# setTimeout (->
# if urb.reqq.length > 0
# return deltim = later()
# urb.send data: pressed
# pressed = []
# ), 500
Mousetrap.handleKey = (char, mod, e)->
norm = {
capslock: 'caps'
pageup: 'pgup'
pagedown: 'pgdn'
backspace: 'baxp'
enter: 'entr'
}
key =
if char.length is 1
if e.type is 'keypress'
str: char
else if e.type is 'keydown'
if char isnt 'space'
act: norm[char] ? char
else if e.type is 'keyup' and norm[key] is 'caps'
act: 'uncap'
if key
e.preventDefault()
urb.send mark: 'dill-belt', data: {mod,key}
# amod = (arr)->
# for i in arr
# unless mod.indexOf(i) < 0
# return yes
# no
# if key.str or key.act is 'baxp' or key.act is 'entr'
# termRev++
# [bot, rest...] = old = matr.props.rows
# matr.setProps rows:(
# switch key.act
# when 'baxp'
# if amod ['ctrl', 'meta']
# ['', rest...]
# else if amod ['alt']
# [(bot.replace /\ *[^ ]*$/, ''), rest...]
# else if bot and bot.length
# [bot.slice(0, -1), rest...]
# else if rest[0] and rest[0].length
# res = rest.slice()
# res[0] = res[0].slice(0, -1)
# res
# else rest
# when 'entr'
# ['', old...]
# when undefined
# if mod.length > 1 or (mod.length and !amod ['shift'])
# old
# else unless old and bot isnt null
# [key.str]
# #else if bot.length is termWif
# # [key.str, old...]
# else [bot + key.str, rest...]
# )
# document.title = "Matri" # XX debug
# later {mod, key}
'''
==
;script@"src/share.coffee"(type "text/coffeescript");
;script@"src/main.coffee"(type "text/coffeescript");
;+ (cdnj "coffee-script/1.7.1/coffee-script.min.js")
== ==
==
==

252
main/pub/sole/src/main.coffee Normal file
View File

@ -0,0 +1,252 @@
[DOM,recl,rend] = [React.DOM, React.createClass, React.renderComponent]
[div, pre, span] = [DOM.div, DOM.pre, DOM.span]
str = JSON.stringify
Prompt = recl render: ->
[pro,cur,buf] = [@props.prompt, @props.cursor, @props.input + " "]
pre {}, pro,
span {style: background: 'lightgray'}, buf.slice(0,cur), "\u0332", buf.slice(cur)
Matr = recl render: ->
lines = @props.rows.map (lin)-> pre {}, lin, " "
lines.push Prompt {prompt:@props.prompt, input:@props.input, cursor:@props.cursor}
div {}, lines
$ ->
met = $('<pre>').text('m').css(display: 'none').appendTo(term).width()
subs = ""
# $(window).resize ->
# window.termWif = ($(term).width() / met).toFixed()
# path = "/new/#{termWif}"
# if path is subs
# return
# if subs
# urb.unsubscribe path: subs
# subs = path
# urb.subscribe {path}, (err,dat)->
# if err or dat.data.ok
# return;
# syncRev = dat.data.rev
# unless termRev > syncRev
# termRev = syncRev
# matr.setProps rows: dat.data.stak
# document.title = "Matrix" # XX debug
# $(window).resize()
flash = ($el, background)->
$el.css {background}
if background
setTimeout (-> flash $el,''), 50
bell = -> flash ($ 'body'), 'black'
matr = rend (Matr
rows:[]
prompt:""
input:""
cursor:0
history:[]
offset:0 ), term
window.matr = matr
update = (a) -> matr.setProps a
buffer = new Share ""
window.buffer = buffer
sync = (ted)->
update input: buffer.buf, cursor: buffer.transpose ted, matr.props.cursor
peer = (ruh) ->
if ruh.map then return ruh.map peer
mapr = matr.props
switch Object.keys(ruh)[0]
when 'txt' then update rows: [mapr.rows..., ruh.txt]
when 'tan' then ruh.tan.split("\n").reverse().map (txt)-> peer {txt}
when 'hop' then update cursor: ruh.hop; bell() # XX buffer.transpose?
when 'pro' then update prompt: ruh.pro.cad
when 'blk' then console.log "Stub #{str ruh}"
when 'det' then buffer.receive ruh.det; sync ruh.det.ted
when 'act' then switch ruh.act
when 'clr' then update rows:[]
when 'bel' then bell()
when 'nex' then update
input: ""
cursor: 0
history:
if !mapr.input then mapr.history
else [mapr.input, mapr.history...]
offset: 0
# else throw "Unknown "+(JSON.stringify ruh)
else v = Object.keys(ruh); console.log v, ruh[v[0]]
urb.bind "/sole", {wire:"/"}, (err,d)->
if err then console.log err
else if d.data then peer d.data
pressed = []
deltim = null
#later = (data)->
# if data
# pressed.push data
# clearTimeout deltim
# setTimeout (->
# if urb.reqq.length > 0
# return deltim = later()
# urb.send data: pressed
# pressed = []
# ), 500
sendAction = (data)->
urb.send {mark: 'sole-action', data}, (e,res)->
if res.status isnt 200 then $('#err')[0].innerText = res.data.mess
doEdit = (ted)->
det = buffer.transmit ted
sync ted
sendAction {det}
yank = ''
eatKyev= (mod, key)->
mapr = matr.props
switch mod.sort().join '-'
when '', 'shift'
if key.str
doEdit ins: cha: key.str, at: mapr.cursor
update cursor: mapr.cursor+1
switch key.act
when 'entr' then sendAction 'ret'
when 'up'
history = mapr.history.slice(); offset = mapr.offset
if history[offset] == undefined
return
[input, history[offset]] = [history[offset], mapr.input]
offset++
doEdit set: input
update {offset, history, cursor: input.length}
when 'down'
history = mapr.history.slice(); offset = mapr.offset
offset--
if history[offset] == undefined
return
[input, history[offset]] = [history[offset], mapr.input]
doEdit set: input
update {offset, history, cursor: input.length}
when 'left' then if mapr.cursor > 0
update cursor: mapr.cursor-1
when 'right' then if mapr.cursor < mapr.input.length
update cursor: mapr.cursor+1
when 'baxp' then if mapr.cursor > 0
doEdit del: mapr.cursor-1
#else (if key.act then console.log key.act)
when 'ctrl' then switch key.str || key.act
when 'a','left' then update cursor: 0
when 'e','right' then update cursor: mapr.input.length
when 'l' then update rows: []
when 'entr' then peer act: 'bel'
when 'w' then eatKyev ['alt'], act:'baxp'
when 'p' then eatKyev [], act: 'up'
when 'n' then eatKyev [], act: 'down'
when 'b' then eatKyev [], act: 'left'
when 'f' then eatKyev [], act: 'right'
when 'g' then bell()
when 't'
if mapr.cursor is 0 or mapr.input.length < 2
return bell()
cursor = mapr.cursor
if cursor < mapr.input.length
cursor++
doEdit [{del:cursor-1},ins:{at:cursor-2,cha:mapr.input[cursor-1]}]
update {cursor}
when 'u'
yank = mapr.input.slice(0,mapr.cursor)
doEdit (del:mapr.cursor - n for n in [1..mapr.cursor])
when 'k'
yank = mapr.input.slice(mapr.cursor)
doEdit (del:mapr.cursor for _ in [mapr.cursor...mapr.input.length])
when 'y'
doEdit (ins: {cha, at: mapr.cursor + n} for cha,n in yank)
else console.log mod, str key
when 'alt' then switch key.str || key.act
when 'f','right'
rest = mapr.input.slice(mapr.cursor)
rest = rest.match(/\W*\w*/)[0] # XX unicode
update cursor: mapr.cursor + rest.length
when 'b','left'
prev = mapr.input.slice(0,mapr.cursor)
prev = prev.split('').reverse().join('') # XX
prev = prev.match(/\W*\w*/)[0] # XX unicode
update cursor: mapr.cursor - prev.length
when 'baxp'
prev = mapr.input.slice(0,mapr.cursor)
prev = prev.split('').reverse().join('') # XX
prev = prev.match(/\W*\w*/)[0] # XX unicode
yank = prev
doEdit (del: mapr.cursor-1 - n for _,n in prev)
else console.log mod, str key
Mousetrap.handleKey = (char, mod, e)->
norm = {
capslock: 'caps'
pageup: 'pgup'
pagedown: 'pgdn'
backspace: 'baxp'
enter: 'entr'
}
key = switch
when char.length is 1
if e.type is 'keypress'
chac = char.charCodeAt(0)
if chac < 32 # normalize ctrl keys
char = String.fromCharCode chac | 96
str: char
when e.type is 'keydown'
if char isnt 'space'
act: norm[char] ? char
when e.type is 'keyup' and norm[key] is 'caps'
act: 'uncap'
if !key then return
if key.act and key.act in mod
return
e.preventDefault()
#[fore, aft] = (
# [sli,cur] = [mapr.input.slice, mapr.cursor]
# [sli(0, cur), sli(cur)]
#)
eatKyev mod, key
#amod = (arr)->
# for i in arr
# unless mod.indexOf(i) < 0
# return yes
# no
# if key.str or key.act is 'baxp' or key.act is 'entr'
# termRev++
# [bot, rest...] = old = matr.props.rows
# matr.setProps rows:(
# switch key.act
# when 'baxp'
# if amod ['ctrl', 'meta']
# ['', rest...]
# else if amod ['alt']
# [(bot.replace /\ *[^ ]*$/, ''), rest...]
# else if bot and bot.length
# [bot.slice(0, -1), rest...]
# else if rest[0] and rest[0].length
# res = rest.slice()
# res[0] = res[0].slice(0, -1)
# res
# else rest
# when 'entr'
# ['', old...]
# when undefined
# if mod.length > 1 or (mod.length and !amod ['shift'])
# old
# else unless old and bot isnt null
# [key.str]
# #else if bot.length is termWif
# # [key.str, old...]
# else [bot + key.str, rest...]
# )
# document.title = "Matri" # XX debug
# later {mod, key}

83
main/pub/sole/src/share.coffee Normal file
View File

@ -0,0 +1,83 @@
# See /hook/core/sole/lib
str = JSON.stringify
clog = (a)-> console.log a
class window.Share
constructor: (@buf = "", @ven = [0, 0], @leg = []) ->
#
abet: -> buf:@buf, leg:@leg.slice(), ven:@ven.slice()
apply: (ted)->
switch
when 'nop' == ted then return
when ted.map then ted.map @apply, @
else switch Object.keys(ted)[0]
when 'set' then @buf = ted.set
when 'del' then @buf = @buf.slice(0,ted.del) + @buf.slice(ted.del + 1)
when 'ins'
{at,cha} = ted.ins
@buf = @buf.slice(0,at) + cha + @buf.slice(at)
else throw "%sole-edit -lost.#{str ted}"
#
transmute: (sin,dex)->
switch
when sin == 'nop' or dex == 'nop' then dex
when sin.reduce
sin.reduce ((dex,syn) => @transmute(syn,dex)), dex
when dex.map then dex.map (dax) => @transmute(sin,dax)
when dex.set != undefined then dex
else switch Object.keys(sin)[0]
when 'set' then 'nop'
when 'del'
if sin.del is dex.del then return 'nop'
dex = $.extend true, {}, dex # clone
switch Object.keys(dex)[0]
when 'del' then if sin.del < dex.del then dex.del--
when 'ins' then if sin.del < dex.ins.at then dex.ins.at--
return dex
when 'ins'
dex = $.extend true, {}, dex # clone
{at,cha} = sin.ins
switch Object.keys(dex)[0]
when 'del' then if at < dex.del then dex.del++
when 'ins' then if at < dex.ins.at or
(at == dex.ins.at and !(cha <= dex.ins.cha))
dex.ins.at++
return dex
else throw "%sole-edit -lost.#{str sin}"
#
commit: (ted)->
@ven[0]++
@leg.push ted
@apply ted
#
inverse: (ted)->
switch
when 'nop' == ted then ted
when ted.map
ted.map( (tad)=> res=@inverse tad; @apply tad; res).reverse()
else switch Object.keys(ted)[0]
when 'set' then set: @buf
when 'ins' then del: ted.ins
when 'del' then ins: at: ted.del, cha: @buf[ted.del]
else throw "%sole-edit -lost.#{str ted}"
#
receive: ({ler,ted})->
if !(ler[1] is @ven[1])
throw "-out-of-sync.[#{str ler} #{str @ven}]"
@leg = @leg.slice @leg.length + ler[0] - @ven[0]
dat = @transmute @leg, ted
@ven[1]++; @apply dat; dat
#
remit: -> throw 'stub'
transmit: (ted)->
act = {ted, ler:[@ven[1], @ven[0]]}
@commit ted
return act
#
transceive: ({ler,ted})->
old = new Share @buf
dat = @receive {ler, ted}
old.inverse dat
#
transpose: (ted,pos)->
if pos == undefined then @transpose @leg, ted
else ((@transmute ted, ins: at: pos).ins ? at:0).at

2
main/pub/talk/src/js/actions/MessageActions.coffee
View File

@ -64,4 +64,4 @@ module.exports =
MessageDispatcher.handleViewAction
type:"message-send"
message:_message
window.chat.MessagePersistence.sendMessage _message.thought
window.chat.MessagePersistence.sendMessage _message.thought

2
main/pub/talk/src/js/persistence/MessagePersistence.coffee
View File

@ -55,4 +55,4 @@ module.exports =
}, (err,res) ->
console.log 'sent'
console.log arguments
cb(err,res) if cb
cb(err,res) if cb

3
main/pub/tree/src/css/main.css
View File

@ -132,7 +132,8 @@ pre {
margin-left: -0.3rem;
}
code {
font-size: 0.9rem;
font-size: 0.8rem;
line-height: 1.2rem;
background-color: #f4f4f4;
margin-top: -0.05rem;
padding: 0.2rem;

3
main/pub/tree/src/css/main.styl
View File

@ -62,7 +62,8 @@ pre
margin-left -.3rem
code
font-size .9rem
font-size .8rem
line-height 1.2rem
background-color #f4f4f4
margin-top -.05rem
padding .2rem

7
main/pub/tree/src/js/components/AnchorComponent.coffee
View File

@ -36,14 +36,15 @@ module.exports = recl
setPath: (href,hist) ->
if hist isnt false then history.pushState {}, "", window.tree.basepath href
TreeActions.setCurr href
TreeActions.setCurr href.split("#")[0]
goTo: (path) ->
@toggleFocus false
$("html,body").animate {scrollTop:0}
frag = path.split("#")[0]
@setPath path
if not @checkPath path
TreeActions.getPath path
if not @checkPath frag
TreeActions.getPath frag
checkURL: ->
if @state.url isnt window.location.pathname

5
main/pub/tree/src/js/components/ListComponent.coffee
View File

@ -45,7 +45,10 @@ module.exports = recl
_path = @state.path+"/"+v
if @props.dataPreview?
c = "preview"
prev = @state.snip[_path]
if @props.titlesOnly
prev = @state.snip[_path].head
else
prev = @state.snip[_path]
else
c = ""
prev = (h1 {},v)

53
main/pub/tree/src/js/main.js
View File

@ -1,4 +1,4 @@
(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({"/Users/galen/Documents/src/urbit-test/urb/zod/docs/pub/tree/src/js/actions/TreeActions.coffee":[function(require,module,exports){
var TreeDispatcher, TreePersistence;
TreeDispatcher = require('../dispatcher/Dispatcher.coffee');
@ -72,7 +72,7 @@ module.exports = {
},{"../dispatcher/Dispatcher.coffee":7,"../persistence/TreePersistence.coffee":12}],2:[function(require,module,exports){
},{"../dispatcher/Dispatcher.coffee":"/Users/galen/Documents/src/urbit-test/urb/zod/docs/pub/tree/src/js/dispatcher/Dispatcher.coffee","../persistence/TreePersistence.coffee":"/Users/galen/Documents/src/urbit-test/urb/zod/docs/pub/tree/src/js/persistence/TreePersistence.coffee"}],"/Users/galen/Documents/src/urbit-test/urb/zod/docs/pub/tree/src/js/components/AnchorComponent.coffee":[function(require,module,exports){
var TreeActions, TreeStore, a, div, recl, ref;
TreeStore = require('../stores/TreeStore.coffee');
@ -124,16 +124,18 @@ module.exports = recl({
if (hist !== false) {
history.pushState({}, "", window.tree.basepath(href));
}
return TreeActions.setCurr(href);
return TreeActions.setCurr(href.split("#")[0]);
},
goTo: function(path) {
var frag;
this.toggleFocus(false);
$("html,body").animate({
scrollTop: 0
});
frag = path.split("#")[0];
this.setPath(path);
if (!this.checkPath(path)) {
return TreeActions.getPath(path);
if (!this.checkPath(frag)) {
return TreeActions.getPath(frag);
}
},
checkURL: function() {
@ -293,7 +295,7 @@ module.exports = recl({
},{"../actions/TreeActions.coffee":1,"../stores/TreeStore.coffee":13}],3:[function(require,module,exports){
},{"../actions/TreeActions.coffee":"/Users/galen/Documents/src/urbit-test/urb/zod/docs/pub/tree/src/js/actions/TreeActions.coffee","../stores/TreeStore.coffee":"/Users/galen/Documents/src/urbit-test/urb/zod/docs/pub/tree/src/js/stores/TreeStore.coffee"}],"/Users/galen/Documents/src/urbit-test/urb/zod/docs/pub/tree/src/js/components/BodyComponent.coffee":[function(require,module,exports){
var TreeActions, TreeStore, div, input, load, recl, ref, textarea;
TreeStore = require('../stores/TreeStore.coffee');
@ -358,7 +360,7 @@ module.exports = recl({
},{"../actions/TreeActions.coffee":1,"../stores/TreeStore.coffee":13,"./LoadComponent.coffee":6}],4:[function(require,module,exports){
},{"../actions/TreeActions.coffee":"/Users/galen/Documents/src/urbit-test/urb/zod/docs/pub/tree/src/js/actions/TreeActions.coffee","../stores/TreeStore.coffee":"/Users/galen/Documents/src/urbit-test/urb/zod/docs/pub/tree/src/js/stores/TreeStore.coffee","./LoadComponent.coffee":"/Users/galen/Documents/src/urbit-test/urb/zod/docs/pub/tree/src/js/components/LoadComponent.coffee"}],"/Users/galen/Documents/src/urbit-test/urb/zod/docs/pub/tree/src/js/components/KidsComponent.coffee":[function(require,module,exports){
var TreeActions, TreeStore, a, div, hr, li, recl, ref, ul;
TreeStore = require('../stores/TreeStore.coffee');
@ -425,7 +427,7 @@ module.exports = recl({
},{"../actions/TreeActions.coffee":1,"../stores/TreeStore.coffee":13}],5:[function(require,module,exports){
},{"../actions/TreeActions.coffee":"/Users/galen/Documents/src/urbit-test/urb/zod/docs/pub/tree/src/js/actions/TreeActions.coffee","../stores/TreeStore.coffee":"/Users/galen/Documents/src/urbit-test/urb/zod/docs/pub/tree/src/js/stores/TreeStore.coffee"}],"/Users/galen/Documents/src/urbit-test/urb/zod/docs/pub/tree/src/js/components/ListComponent.coffee":[function(require,module,exports){
var TreeActions, TreeStore, a, div, h1, li, load, recl, ref, ul;
TreeStore = require('../stores/TreeStore.coffee');
@ -493,7 +495,11 @@ module.exports = recl({
_path = _this.state.path + "/" + v;
if (_this.props.dataPreview != null) {
c = "preview";
prev = _this.state.snip[_path];
if (_this.props.titlesOnly) {
prev = _this.state.snip[_path].head;
} else {
prev = _this.state.snip[_path];
}
} else {
c = "";
prev = h1({}, v);
@ -516,7 +522,7 @@ module.exports = recl({
},{"../actions/TreeActions.coffee":1,"../stores/TreeStore.coffee":13,"./LoadComponent.coffee":6}],6:[function(require,module,exports){
},{"../actions/TreeActions.coffee":"/Users/galen/Documents/src/urbit-test/urb/zod/docs/pub/tree/src/js/actions/TreeActions.coffee","../stores/TreeStore.coffee":"/Users/galen/Documents/src/urbit-test/urb/zod/docs/pub/tree/src/js/stores/TreeStore.coffee","./LoadComponent.coffee":"/Users/galen/Documents/src/urbit-test/urb/zod/docs/pub/tree/src/js/components/LoadComponent.coffee"}],"/Users/galen/Documents/src/urbit-test/urb/zod/docs/pub/tree/src/js/components/LoadComponent.coffee":[function(require,module,exports){
var div, input, recl, ref, textarea;
recl = React.createClass;
@ -554,7 +560,7 @@ module.exports = recl({
},{}],7:[function(require,module,exports){
},{}],"/Users/galen/Documents/src/urbit-test/urb/zod/docs/pub/tree/src/js/dispatcher/Dispatcher.coffee":[function(require,module,exports){
var Dispatcher;
Dispatcher = require('flux').Dispatcher;
@ -576,7 +582,7 @@ module.exports = _.extend(new Dispatcher(), {
},{"flux":9}],8:[function(require,module,exports){
},{"flux":"/Users/galen/Documents/src/urbit-test/urb/zod/docs/pub/tree/src/js/node_modules/flux/index.js"}],"/Users/galen/Documents/src/urbit-test/urb/zod/docs/pub/tree/src/js/main.coffee":[function(require,module,exports){
var rend;
rend = React.render;
@ -734,7 +740,7 @@ $(function() {
},{"./actions/TreeActions.coffee":1,"./components/AnchorComponent.coffee":2,"./components/BodyComponent.coffee":3,"./components/KidsComponent.coffee":4,"./components/ListComponent.coffee":5,"./persistence/TreePersistence.coffee":12}],9:[function(require,module,exports){
},{"./actions/TreeActions.coffee":"/Users/galen/Documents/src/urbit-test/urb/zod/docs/pub/tree/src/js/actions/TreeActions.coffee","./components/AnchorComponent.coffee":"/Users/galen/Documents/src/urbit-test/urb/zod/docs/pub/tree/src/js/components/AnchorComponent.coffee","./components/BodyComponent.coffee":"/Users/galen/Documents/src/urbit-test/urb/zod/docs/pub/tree/src/js/components/BodyComponent.coffee","./components/KidsComponent.coffee":"/Users/galen/Documents/src/urbit-test/urb/zod/docs/pub/tree/src/js/components/KidsComponent.coffee","./components/ListComponent.coffee":"/Users/galen/Documents/src/urbit-test/urb/zod/docs/pub/tree/src/js/components/ListComponent.coffee","./persistence/TreePersistence.coffee":"/Users/galen/Documents/src/urbit-test/urb/zod/docs/pub/tree/src/js/persistence/TreePersistence.coffee"}],"/Users/galen/Documents/src/urbit-test/urb/zod/docs/pub/tree/src/js/node_modules/flux/index.js":[function(require,module,exports){
/**
* Copyright (c) 2014, Facebook, Inc.
* All rights reserved.
@ -746,7 +752,7 @@ $(function() {
module.exports.Dispatcher = require('./lib/Dispatcher')
},{"./lib/Dispatcher":10}],10:[function(require,module,exports){
},{"./lib/Dispatcher":"/Users/galen/Documents/src/urbit-test/urb/zod/docs/pub/tree/src/js/node_modules/flux/lib/Dispatcher.js"}],"/Users/galen/Documents/src/urbit-test/urb/zod/docs/pub/tree/src/js/node_modules/flux/lib/Dispatcher.js":[function(require,module,exports){
/*
* Copyright (c) 2014, Facebook, Inc.
* All rights reserved.
@ -998,7 +1004,7 @@ var _prefix = 'ID_';
module.exports = Dispatcher;
},{"./invariant":11}],11:[function(require,module,exports){
},{"./invariant":"/Users/galen/Documents/src/urbit-test/urb/zod/docs/pub/tree/src/js/node_modules/flux/lib/invariant.js"}],"/Users/galen/Documents/src/urbit-test/urb/zod/docs/pub/tree/src/js/node_modules/flux/lib/invariant.js":[function(require,module,exports){
/**
* Copyright (c) 2014, Facebook, Inc.
* All rights reserved.
@ -1053,7 +1059,7 @@ var invariant = function(condition, format, a, b, c, d, e, f) {
module.exports = invariant;
},{}],12:[function(require,module,exports){
},{}],"/Users/galen/Documents/src/urbit-test/urb/zod/docs/pub/tree/src/js/persistence/TreePersistence.coffee":[function(require,module,exports){
var TreeActions;
TreeActions = require('../actions/TreeActions.coffee');
@ -1075,7 +1081,7 @@ module.exports = {
},{"../actions/TreeActions.coffee":1}],13:[function(require,module,exports){
},{"../actions/TreeActions.coffee":"/Users/galen/Documents/src/urbit-test/urb/zod/docs/pub/tree/src/js/actions/TreeActions.coffee"}],"/Users/galen/Documents/src/urbit-test/urb/zod/docs/pub/tree/src/js/stores/TreeStore.coffee":[function(require,module,exports){
var EventEmitter, MessageDispatcher, TreeStore, _cont, _curr, _load, _snip, _tree;
EventEmitter = require('events').EventEmitter;
@ -1163,7 +1169,10 @@ TreeStore = _.extend(EventEmitter.prototype, {
results = [];
for (k in snip) {
v = snip[k];
results.push(_snip[path + "/" + v.name] = window.tree.reactify(v.body));
results.push(_snip[path + "/" + v.name] = {
head: window.tree.reactify(v.body.head),
body: window.tree.reactify(v.body.body)
});
}
return results;
},
@ -1286,7 +1295,7 @@ module.exports = TreeStore;
},{"../dispatcher/Dispatcher.coffee":7,"events":14}],14:[function(require,module,exports){
},{"../dispatcher/Dispatcher.coffee":"/Users/galen/Documents/src/urbit-test/urb/zod/docs/pub/tree/src/js/dispatcher/Dispatcher.coffee","events":"/usr/local/lib/node_modules/watchify/node_modules/browserify/node_modules/events/events.js"}],"/usr/local/lib/node_modules/watchify/node_modules/browserify/node_modules/events/events.js":[function(require,module,exports){
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
@ -1346,8 +1355,10 @@ EventEmitter.prototype.emit = function(type) {
er = arguments[1];
if (er instanceof Error) {
throw er; // Unhandled 'error' event
} else {
throw TypeError('Uncaught, unspecified "error" event.');
}
throw TypeError('Uncaught, unspecified "error" event.');
return false;
}
}
@ -1589,4 +1600,4 @@ function isUndefined(arg) {
return arg === void 0;
}
},{}]},{},[8]);
},{}]},{},["/Users/galen/Documents/src/urbit-test/urb/zod/docs/pub/tree/src/js/main.coffee"]);

4
main/pub/tree/src/js/stores/TreeStore.coffee
View File

@ -55,7 +55,9 @@ TreeStore = _.extend EventEmitter.prototype, {
loadSnip: (path,snip) ->
@mergePathToTree path,_.pluck(snip,"name")
for k,v of snip
_snip[path+"/"+v.name] = window.tree.reactify v.body
_snip[path+"/"+v.name] =
head: window.tree.reactify v.body.head
body: window.tree.reactify v.body.body
loadKids: (path,kids) ->
@mergePathToTree path,_.pluck(kids,"name")

2
main/tree/hymn.hook
View File

@ -18,10 +18,12 @@
;title: urbit Tree
;meta(name "viewport", content "width=device-width, initial-scale=1");
;link(type "text/css", rel "stylesheet", href "/docs/pub/tree/src/css/main.css");
::;link(type "text/css", rel "stylesheet", href "http://localhost:8000/docs/pub/tree/src/css/main.css");
;script(type "text/javascript", src "//cdnjs.cloudflare.com/ajax/libs/jquery/2.1.3/jquery.min.js");
;script(type "text/javascript", src "//cdnjs.cloudflare.com/ajax/libs/lodash.js/2.4.1/lodash.min.js");
;script(type "text/javascript", src "//cdnjs.cloudflare.com/ajax/libs/react/0.12.2/react.js");
;script(type "text/javascript", src "/docs/pub/tree/src/js/main.js");
::;script(type "text/javascript", src "http://localhost:8000/docs/pub/tree/src/js/main.js");
==
;body
;script(type "text/javascript"):"""

11
main/tree/json.hook
View File

@ -8,9 +8,9 @@
/_ /react-js/
::
/= sal /: /=docs=/pub
/; |= a=(map ,@ta cord) a
/; |= a=(map ,@ta json) a
/% 2
/_ /react-snip-js/
/_ /react-snip-json/
::
::::
::
@ -23,6 +23,7 @@
::
^- json
=+ ~(. util gas)
:: .json?kids
?: (~(has by qix.gas) %kids)
%+ joba %kids
=. pal (~(del by pal) %md) :: XX haxor
@ -32,15 +33,17 @@
name/s/a
body/s/b
==
:: .json?snip
?: (~(has by qix.gas) %snip)
%+ joba %snip
=. sal (~(del by sal) %md) :: XX haxor
=- [%a (turn (~(tap by sal)) -)]
|= [a=span b=cord]
|= [a=span b=json]
%- jobe :~
name/s/a
body/s/b
body/b
==
:: .json
%- jobe :~
kids/[%a (turn get-kids |=(a=span s/a))]
body/[%s ral]