urbit/arvo/zuse.hoon
Raymond Pasco 84ae855cce Merge remote-tracking branch 'ohaitch/tree-apps'
The proverbial various fixes and improvements
2016-02-16 15:49:15 -05:00

2346 lines
99 KiB
Plaintext
Raw Blame History

::
:: zuse (3), standard library (tang)
::
~% %zuse + ~
!:
|%
:::::::::::::::::::::::::::::::::::::::::::::::::::::: ::
:::: chapter 3b, Arvo libraries ::::
:: ::::::::::::::::::::::::::::::::::::::::::::::::::::::
:: section 3bA, lite number theory ::
::
++ dope
~/ %dope
|= a/@
~& [%dope-zuse (mug +>)]
:(mul a a a)
::
++ fu :: modulo (mul p q)
|= a/{p/@ q/@}
=+ b=?:(=([0 0] a) 0 (~(inv fo p.a) (~(sit fo p.a) q.a)))
|%
++ dif
|= {c/{@ @} d/{@ @}}
[(~(dif fo p.a) -.c -.d) (~(dif fo q.a) +.c +.d)]
::
++ exp
|= {c/@ d/{@ @}}
:- (~(exp fo p.a) (mod c (dec p.a)) -.d)
(~(exp fo q.a) (mod c (dec q.a)) +.d)
::
++ out :: garner's formula
|= c/{@ @}
%+ add
+.c
(mul q.a (~(pro fo p.a) b (~(dif fo p.a) -.c (~(sit fo p.a) +.c))))
::
++ pro
|= {c/{@ @} d/{@ @}}
[(~(pro fo p.a) -.c -.d) (~(pro fo q.a) +.c +.d)]
::
++ sum
|= {c/{@ @} d/{@ @}}
[(~(sum fo p.a) -.c -.d) (~(sum fo q.a) +.c +.d)]
::
++ sit
|= c/@
[(mod c p.a) (mod c q.a)]
--
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
:: section 3bB, cryptosuites ::
::
++ crua !: :: cryptosuite A (RSA)
^- acru
=| {mos/@ pon/(unit {p/@ q/@ r/{p/@ q/@} s/_*fu})}
=> |%
++ mx (dec (met 0 mos)) :: bit length
++ dap :: OEAP decode
|= {wid/@ xar/@ dog/@} ^- {p/@ q/@}
=+ pav=(sub wid xar)
=+ qoy=(cut 0 [xar pav] dog)
=+ dez=(mix (end 0 xar dog) (shaw %pad-b xar qoy))
[dez (mix qoy (shaw %pad-a pav dez))]
::
++ pad :: OEAP encode
|= {wid/@ rax/{p/@ q/@} meg/@} ^- @
=+ pav=(sub wid p.rax)
?> (gte pav (met 0 meg))
^- @
=+ qoy=(mix meg (shaw %pad-a pav q.rax))
=+ dez=(mix q.rax (shaw %pad-b p.rax qoy))
(can 0 [p.rax dez] [pav qoy] ~)
::
++ pull |=(a/@ (~(exp fo mos) 3 a))
++ push |=(a/@ (~(exp fo mos) 5 a))
++ pump
|= a/@ ^- @
?~ pon !!
(out.s.u.pon (exp.s.u.pon p.r.u.pon (sit.s.u.pon a)))
::
++ punt
|= a/@ ^- @
?~ pon !!
(out.s.u.pon (exp.s.u.pon q.r.u.pon (sit.s.u.pon a)))
--
|% :: opaque object
++ as
=> |%
++ haul :: revealing haul
|= a/pass
=+ [mag=(end 3 1 a) bod=(rsh 3 1 a)]
?> =('a' mag)
..as(mos bod, pon ~)
--
^?
|% ++ seal
|= {a/pass b/@ c/@}
^- @
=> .(c (sign b c))
=+ her=(haul a)
=+ det=(lte (add 256 (met 0 c)) mx.her)
=+ lip=?:(det c 0)
=- (add ?:(p.mav 0 1) (lsh 0 1 q.mav))
^= mav ^- {p/? q/@}
:- det
=+ dog=(pad mx.her [256 b] lip)
=+ hog=(push.her dog)
=+ ben=(en b c)
?:(det hog (jam hog ben))
++ sign
|= {a/@ b/@} ^- @
=- (add ?:(p.mav 0 1) (lsh 0 1 q.mav))
^= mav ^- {p/? q/@}
=+ det=(lte (add 128 (met 0 b)) mx)
:- det
=+ hec=(shaf (mix %agis a) b)
=+ dog=(pad mx [128 hec] ?:(det b 0))
=+ hog=(pump dog)
?:(det hog (jam hog b))
++ sure
|= {a/@ b/@}
^- (unit @)
=+ [det==(0 (end 0 1 b)) bod=(rsh 0 1 b)]
=+ gox=?:(det [p=bod q=0] ((hard {p/@ q/@}) (cue bod)))
=+ dog=(pull p.gox)
=+ pig=(dap mx 128 dog)
=+ log=?:(det q.pig q.gox)
?.(=(p.pig (shaf (mix %agis a) log)) ~ [~ log])
++ tear
|= {a/pass b/@}
^- (unit {p/@ q/@})
=+ her=(haul a)
=+ [det==(0 (end 0 1 b)) bod=(rsh 0 1 b)]
=+ gox=?:(det [p=bod q=0] ((hard {p/@ q/@}) (cue bod)))
=+ dog=(punt p.gox)
=+ pig=(dap mx 256 dog)
=+ ^= cow
^- (unit @)
?: det
[~ q.pig]
(de p.pig q.gox)
?~ cow ~
=> .(cow (sure:as.her p.pig u.cow))
?~ cow ~
[~ p.pig u.cow]
--
::
++ de
|~ {key/@ cep/@} ^- (unit @)
=+ toh=(met 8 cep)
?: (lth toh 2)
~
=+ adj=(dec toh)
=+ [hax=(end 8 1 cep) bod=(rsh 8 1 cep)]
=+ msg=(mix (~(raw og (mix hax key)) (mul 256 adj)) bod)
?. =(hax (shax (mix key (shax (mix adj msg)))))
~
[~ msg]
::
++ dy |~({a/@ b/@} (need (de a b)))
++ en
|~ {key/@ msg/@} ^- @ux
=+ len=(met 8 msg)
=+ adj=?:(=(0 len) 1 len)
=+ hax=(shax (mix key (shax (mix adj msg))))
(rap 8 hax (mix msg (~(raw og (mix hax key)) (mul 256 adj))) ~)
::
++ ex ^?
|% ++ fig ^- @uvH (shaf %afig mos)
++ pac ^- @uvG (end 6 1 (shaf %acod sec))
++ pub ^- pass (cat 3 'a' mos)
++ sec ^- ring ?~(pon !! (cat 3 'A' (jam p.u.pon q.u.pon)))
--
::
++ nu
=> |%
++ elcm
|= {a/@ b/@}
(div (mul a b) d:(egcd a b))
::
++ eldm
|= {a/@ b/@ c/@}
(~(inv fo (elcm (dec b) (dec c))) a)
::
++ ersa
|= {a/@ b/@}
[a b [(eldm 3 a b) (eldm 5 a b)] (fu a b)]
--
^?
|% ++ com
|= a/@
^+ ^?(..nu)
..nu(mos a, pon ~)
::
++ pit
|= {a/@ b/@}
=+ c=(rsh 0 1 a)
=+ [d=(ramp c [3 5 ~] b) e=(ramp c [3 5 ~] +(b))]
^+ ^?(..nu)
..nu(mos (mul d e), pon [~ (ersa d e)])
::
++ nol
|= a/@
^+ ^?(..nu)
=+ b=((hard {p/@ q/@}) (cue a))
..nu(mos (mul p.b q.b), pon [~ (ersa p.b q.b)])
--
-- ::
::
++ bruw :: create keypair
|= {a/@ b/@} :: width seed
^- acru
(pit:nu:crua a b)
::
++ haul :: activate public key
|= a/pass
^- acru
=+ [mag=(end 3 1 a) bod=(rsh 3 1 a)]
?> =('a' mag)
(com:nu:crua bod)
::
++ weur :: activate secret key
|= a/ring
^- acru
=+ [mag=(end 3 1 a) bod=(rsh 3 1 a)]
?> =('A' mag)
(nol:nu:crua bod)
::
++ trua :: test rsa
|= msg/@tas
^- @
=+ ali=(bruw 1.024 (shax 'ali'))
=+ bob=(bruw 1.024 (shax 'bob'))
=+ tef=(sign:as.ali [0 msg])
=+ lov=(sure:as.ali [0 tef])
?. &(?=(^ lov) =(msg u.lov))
~|(%test-fail-sign !!)
=+ key=(shax (shax (shax msg)))
=+ sax=(seal:as.ali pub:ex.bob key msg)
=+ tin=(tear:as.bob pub:ex.ali sax)
?. &(?=(^ tin) =(key p.u.tin) =(msg q.u.tin))
~|(%test-fail-seal !!)
msg
::
++ crub :: cryptosuite B (Ed)
^- acru
=| {pub/{c/@ e/@} sek/{c/@ e/@}}
=> |%
++ skey
|= {a/bloq key/@ nonc/@ ct/@ mctr/@ buf/(list {p/@ q/@})}
=+ ctext=(en:aesc key (mix (lsh (dec a) 1 nonc) ct))
:: =+ nbuf=(mix (lsh a 1 buf) ctext)
=+ nbuf=[[p=1 q=ctext] buf]
?: =(ct mctr)
(can a buf)
$(ct +(ct), buf nbuf)
::
++ hiv
|= ruz/@
=+ haz=(shax ruz)
=+ hax=(mix (end 7 1 haz) (rsh 7 1 haz))
(mix (end 6 1 hax) (rsh 6 1 hax))
--
|%
++ as
=> |%
++ hail
|= a/pass
=+ [mag=(end 3 1 a) bod=(rsh 3 1 a)]
?> =('b' mag)
..as(pub [c=(rsh 8 1 bod) e=(end 8 1 bod)])
::
++ tide :: shared secret
|= a/@ ^- @
:: (curt a (curt c.sek 9))
(curt c.sek a)
--
^?
|%
++ seal
|= {a/pass b/@ c/@}
=+ =+ her=(hail a)
tie=(tide c.pub.her)
=+ [hog=(en tie b) ben=(en b c)]
=+ sig=(sign:ed ben e.sek)
(jam hog ben sig)
::
++ sign
|= {a/@ b/@} ^- @
(jam (en a (shax b)) b)
++ sure
|= {a/@ b/@}
^- (unit @)
=+ bod=((hard {h/@ m/@}) (cue b))
?: =((need (de a h.bod)) (shax m.bod))
(some m.bod)
~
::
++ tear
|= {a/pass b/@}
^- (unit {p/@ q/@})
=+ bod=((hard {p/@ q/@ s/@}) (cue b))
=+ =+ her=(hail a)
tie=(tide c.pub.her)
?. (veri:ed s.bod q.bod (end 8 1 (rsh 3 1 a)))
~
=+ hog=(de tie p.bod)
?~ hog ~
=+ ben=(de u.hog q.bod)
?~ ben ~
[~ u.hog u.ben]
--
::
++ de
|~ {key/@ cep/@} ^- (unit @)
=+ noc=(end 6 1 cep)
=+ cth=(rsh 6 1 cep)
=+ byt=(end 7 1 cth)
=+ cex=(rsh 7 1 cth)
=+ nox=(met 7 cex)
=+ cip=(skey 7 key noc 0 (dec nox) ~)
=+ msg=(mix cex (end 3 byt cip))
=+ h=(hiv msg)
?: =(h noc)
(some msg)
~
::
++ dy
|~ {a/@ b/@} ^- @
(need (de a b))
::
++ en
|~ {key/@ msg/@} ^- @ux
=+ h=(hiv msg)
=+ boc=(met 7 msg)
=+ cip=(skey 7 key h 0 (dec boc) ~)
=+ byt=(met 3 msg)
`@u`(mix (lsh 6 1 (mix (lsh 7 1 (mix (end 3 byt cip) msg)) byt)) h)
::
++ ex ^?
|% ++ fig ^- @uvH (shaf %bfig e.^pub)
++ pac ^- @uvG (end 6 1 (shaf %acod e.sek))
++ pub ^- pass (cat 3 'b' (mix (lsh 8 1 c.^pub) e.^pub))
++ sec ^- ring (cat 3 'B' (mix (lsh 8 1 c.sek) e.sek))
--
::
++ nu
^?
|% ++ com
|= a/@
^+ ^?(..nu)
..nu(sek [c=~ e=~], pub [c=(rsh 8 1 a) e=(end 8 1 a)])
::
++ pit
|= {a/@ b/@}
^+ ^?(..nu)
=+ [rb=(rsh 8 1 b) eb=(end 8 1 b)]
..nu(sek [c=rb e=eb], pub [c=(curt rb 9) e=(puck:ed eb)])
::
++ nol
|= a/@
^+ ^?(..nu)
=+ [ra=(rsh 8 1 a) ea=(end 8 1 a)]
..nu(sek [c=ra e=ea], pub [c=(curt ra 9) e=(puck:ed ea)])
--
--
++ brew :: create keypair
|= {a/@ b/@} :: width seed
^- acru
(pit:nu:crub a b)
::
++ hail :: activate public key
|= a/pass
^- acru
=+ [mag=(end 3 1 a) bod=(rsh 3 1 a)]
?> =('b' mag)
(com:nu:crub bod)
::
++ wear :: activate secret key
|= a/ring
^- acru
=+ [mag=(end 3 1 a) bod=(rsh 3 1 a)]
?> =('B' mag)
(nol:nu:crub bod)
::
++ trub :: test ed
|= msg/@tas
^- @
=+ ali=(brew 1.024 (cat 8 (shax 'ali') (shad 'ali')))
=+ bob=(brew 1.024 (cat 8 (shax 'bob') (shad 'bob')))
=+ tef=(sign:as.ali [0 msg])
=+ lov=(sure:as.ali [0 tef])
?. &(?=(^ lov) =(msg u.lov))
~|(%test-fail-sign !!)
=+ key=(shax (shax (shax msg)))
=+ sax=(seal:as.ali pub:ex.bob key msg)
=+ tin=(tear:as.bob pub:ex.ali sax)
?. &(?=(^ tin) =(key p.u.tin) =(msg q.u.tin))
~|(%test-fail-seal !!)
msg
::
++ hmac :: HMAC-SHA1
|= {key/@ mes/@}
=+ ip=(fil 3 64 0x36)
=+ op=(fil 3 64 0x5c)
=+ ^= kex
?: (gth (met 3 key) 64)
(lsh 3 44 (shan (swap 3 key)))
(lsh 3 (sub 64 (met 3 key)) (swap 3 key))
=+ inn=(shan (swap 3 (cat 3 (swap 3 mes) (mix ip kex))))
(shan (swap 3 (cat 3 inn (mix op kex))))
::
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
:: section 3bC, UTC :: Gregorian only
::
++ dawn :: Jan 1 weekday
|= yer/@ud
=+ yet=(sub yer 1)
%- mod :_ 7
:(add 1 (mul 5 (mod yet 4)) (mul 4 (mod yet 100)) (mul 6 (mod yet 400)))
::
++ daws :: date weekday
|= yed/date
%- mod :_ 7
(add (dawn y.yed) (sub (yawn [y.yed m.yed d.t.yed]) (yawn y.yed 1 1)))
::
++ deal :: to leap sec time
|= yer/@da
=+ n=0
=+ yud=(yore yer)
|- ^- date
?: (gte yer (add (snag n lef:yu) ~s1))
(yore (year yud(s.t (add n s.t.yud))))
?: &((gte yer (snag n lef:yu)) (lth yer (add (snag n lef:yu) ~s1)))
yud(s.t (add +(n) s.t.yud))
?: =(+(n) (lent lef:yu))
(yore (year yud(s.t (add +(n) s.t.yud))))
$(n +(n))
::
++ lead :: from leap sec time
|= ley/date
=+ ler=(year ley)
=+ n=0
|- ^- @da
=+ led=(sub ler (mul n ~s1))
?: (gte ler (add (snag n les:yu) ~s1))
led
?: &((gte ler (snag n les:yu)) (lth ler (add (snag n les:yu) ~s1)))
?: =(s.t.ley 60)
(sub led ~s1)
led
?: =(+(n) (lent les:yu))
(sub led ~s1)
$(n +(n))
::
++ dust :: print UTC format
|= yed/date
^- tape
=+ wey=(daws yed)
;: weld
`tape`(snag wey (turn wik:yu |=(a/tape (scag 3 a))))
", " ~(rud at d.t.yed) " "
`tape`(snag (dec m.yed) (turn mon:yu |=(a/tape (scag 3 a))))
" " (scag 1 ~(rud at y.yed)) (slag 2 ~(rud at y.yed)) " "
~(rud at h.t.yed) ":" ~(rud at m.t.yed) ":" ~(rud at s.t.yed)
" " "+0000"
==
::
++ stud !: :: parse UTC format
=< |= a/cord :: expose parsers
%+ biff (rush a (more sepa elem))
|= b/(list _(wonk *elem)) ^- (unit date)
=- ?.((za:jo -) ~ (some (zp:jo -)))
^+ =+ [*date u=unit]
*{(u _[a y]) (u _m) (u _d.t) (u _+.t) $~}
:~ :: XX types
|-(?~(b ~ ?.(?=($y -.i.b) $(b t.b) `+.i.b)))
|-(?~(b ~ ?.(?=($m -.i.b) $(b t.b) `+.i.b)))
|-(?~(b ~ ?.(?=($d -.i.b) $(b t.b) `+.i.b)))
|-(?~(b ~ ?.(?=($t -.i.b) $(b t.b) `+.i.b)))
==
|%
::
++ snug
|= a/wall
|= b/tape
=+ [pos=1 len=(lent b)]
|- ^- (unit @u)
?~ a ~
?: =(b (scag len i.a))
`pos
$(pos +(pos), a t.a)
::
::
++ sepa ;~(pose ;~(plug com (star ace)) (plus ace))
++ elem
;~ pose
(stag %t t) (stag %y y) (stag %m m) (stag %d d)
(stag %w w) (stag %z z)
==
::
++ y (stag %& (bass 10 (stun 3^4 dit)))
++ m (sear (snug mon:yu) (plus alf))
++ d (bass 10 (stun 1^2 dit))
++ t [;~(plug - - + (easy ~))]:[;~(sfix d col) d]
++ w (sear (snug wik:yu) (plus alf))
++ z [;~(plug (mask "-+") . .)]:(bass 10 (stun 2^2 dit))
--
::
++ unt :: UGT to UTC time
|= a/@
(div (sub a ~1970.1.1) ~s1)
::
++ yu :: UTC format constants
|%
++ mon ^- (list tape)
:~ "January" "February" "March" "April" "May" "June" "July"
"August" "September" "October" "November" "December"
==
::
++ wik ^- (list tape)
:~ "Sunday" "Monday" "Tuesday" "Wednesday" "Thursday"
"Friday" "Saturday"
==
::
++ les ^- (list @da)
:~ ~2015.7.1 ~2012.7.1 ~2009.1.1 ~2006.1.1 ~1999.1.1 ~1997.7.1
~1996.1.1 ~1994.7.1 ~1993.7.1 ~1992.7.1 ~1991.1.1 ~1990.1.1
~1988.1.1 ~1985.7.1 ~1983.7.1 ~1982.7.1 ~1981.7.1 ~1980.1.1
~1979.1.1 ~1978.1.1 ~1977.1.1 ~1976.1.1 ~1975.1.1 ~1974.1.1
~1973.1.1 ~1972.7.1
==
++ lef ^- (list @da)
:~ ~2015.6.30..23.59.59 ~2012.6.30..23.59.59
~2008.12.31..23.59.58 ~2005.12.31..23.59.57
~1998.12.31..23.59.56 ~1997.6.30..23.59.55
~1995.12.31..23.59.54 ~1994.6.30..23.59.53
~1993.6.30..23.59.52 ~1992.6.30..23.59.51
~1990.12.31..23.59.50 ~1989.12.31..23.59.49
~1987.12.31..23.59.48 ~1985.6.30..23.59.47
~1983.6.30..23.59.46 ~1982.6.30..23.59.45
~1981.6.30..23.59.44 ~1979.12.31..23.59.43
~1978.12.31..23.59.42 ~1977.12.31..23.59.41
~1976.12.31..23.59.40 ~1975.12.31..23.59.39
~1974.12.31..23.59.38 ~1973.12.31..23.59.37
~1972.12.31..23.59.36 ~1972.6.30..23.59.35
==
--
::
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
:: section 3bD, JSON and XML ::
::
++ moon :: mime type to text
|= myn/mite
%- crip
|- ^- tape
?~ myn ~
?: =(~ t.myn) (trip i.myn)
(weld (trip i.myn) `tape`['/' $(myn t.myn)])
::
++ perk :: parse cube fork
|* a/(pole @tas)
?~ a fail
;~ pose
(cold -.a (jest -.a))
$(a +.a)
==
::
++ poja :: parse JSON
=< |=(a/cord `(unit json)`(rush a apex))
|%
++ apex :: JSON value
%+ knee *json |. ~+
%+ ifix [spac spac]
;~ pose
(cold ~ (jest 'null'))
(stag %b bool)
(stag %s stri)
(cook |=(s/tape [%n p=(rap 3 s)]) numb)
abox
obox
==
++ tops ;~(pose abox obox) :: JSON strict
:: JSON arrays
++ abox (stag %a (ifix [sel (ws ser)] (more (ws com) apex)))
:: JSON objects
++ pair ;~(plug ;~(sfix (ws stri) (ws col)) apex)
++ obje (ifix [(ws kel) (ws ker)] (more (ws com) pair))
++ obox (stag %o (cook malt obje))
:: JSON booleans
++ bool ;~(pose (cold & (jest 'true')) (cold | (jest 'false')))
:: JSON strings
++ stri (cook crip (ifix [doq doq] (star jcha)))
++ jcha ;~(pose ;~(less doq bas prn) esca) :: character in string
++ esca :: Escaped character
;~ pfix bas
;~ pose
doq fas soq bas
(sear ~(get by `(map @t @)`(my b+8 t+9 n+10 f+12 r+13 ~)) low)
;~(pfix (just 'u') (cook tuft qix:ab)) :: 4-digit hex to UTF-8
==
==
:: JSON numbers
++ numb
;~ (comp twel)
(mayb (piec hep))
;~ pose
(piec (just '0'))
;~(plug (shim '1' '9') digs)
==
(mayb frac)
(mayb expo)
==
++ digs (star (shim '0' '9'))
++ expo :: Exponent part
;~ (comp twel)
(piec (mask "eE"))
(mayb (piec (mask "+-")))
digs
==
++ frac ;~(plug dot digs) :: Fractional part
:: whitespace
++ spac (star (mask [`@`9 `@`10 `@`13 ' ' ~]))
++ ws |*(sef/rule ;~(pfix spac sef))
:: plumbing
++ mayb |*(bus/rule ;~(pose bus (easy "")))
++ twel |=({a/tape b/tape} (weld a b))
++ piec
|* bus/rule
(cook |=(a/@ [a ~]) bus)
--
::
++ pojo :: print json
=| rez/tape
|= val/json
^- tape
?~ val (weld "null" rez)
?- -.val
$a
:- '['
=. rez [']' rez]
!.
?~ p.val rez
|-
?~ t.p.val ^$(val i.p.val)
^$(val i.p.val, rez [',' $(p.val t.p.val)])
::
$b (weld ?:(p.val "true" "false") rez)
$n (weld (trip p.val) rez)
$s
:- '"'
=. rez ['"' rez]
=+ viz=(trip p.val)
!.
|- ^- tape
?~ viz rez
=+ hed=(jesc i.viz)
?: ?=({@ $~} hed) :: common case
[i.hed $(viz t.viz)] :: cons-and-tail
(weld hed $(viz t.viz))
::
$o
:- '{'
=. rez ['}' rez]
=+ viz=(~(tap by p.val))
?~ viz rez
!.
|- ^+ rez
?~ t.viz ^$(val [%s p.i.viz], rez [':' ^$(val q.i.viz)])
=. rez [',' $(viz t.viz)]
^$(val [%s p.i.viz], rez [':' ^$(val q.i.viz)])
==
::
++ poxo :: node to tape
=< |=(a/manx `tape`(apex a ~))
|_ _[unq=`?`| cot=`?`|] :: self-close all tags
++ apex :: top level
|= {mex/manx rez/tape}
^- tape
?: ?=({$$ {{$$ *} $~}} g.mex)
(escp v.i.a.g.mex rez)
=+ man=`mane`n.g.mex
=. unq |(unq =(%script man) =(%style man))
=+ tam=(name man)
=+ att=`mart`a.g.mex
:- '<'
%+ welp tam
=- ?~(att rez [' ' (attr att rez)])
^- rez/tape
?: &(?=($~ c.mex) |(cot (clot man)))
[' ' '/' '>' rez]
:- '>'
(many c.mex :(weld "</" tam ">" rez))
::
++ attr :: attributes to tape
|= {tat/mart rez/tape}
^- tape
?~ tat rez
=. rez $(tat t.tat)
;: weld
(name n.i.tat)
"=\""
(escp(unq |) v.i.tat '"' ?~(t.tat rez [' ' rez]))
==
::
++ escp :: escape for xml
|= {tex/tape rez/tape}
?: unq
(weld tex rez)
=+ xet=`tape`(flop tex)
!.
|- ^- tape
?~ xet rez
%= $
xet t.xet
rez ?- i.xet
$34 ['&' 'q' 'u' 'o' 't' ';' rez]
$38 ['&' 'a' 'm' 'p' ';' rez]
$39 ['&' '#' '3' '9' ';' rez]
$60 ['&' 'l' 't' ';' rez]
$62 ['&' 'g' 't' ';' rez]
* [i.xet rez]
==
==
::
++ many :: nodelist to tape
|= {lix/(list manx) rez/tape}
|- ^- tape
?~ lix rez
(apex i.lix $(lix t.lix))
::
++ name :: name to tape
|= man/mane ^- tape
?@ man (trip man)
(weld (trip -.man) `tape`[':' (trip +.man)])
::
++ clot ~+ :: self-closing tags
%~ has in
%- silt ^- (list term) :~
%area %base %br %col %command %embed %hr %img %input %keygen
%link %meta %param %source %track %wbr
== ==
--
::
++ foo
;~(plug fas fas fas)
++ poxa :: xml parser
=< |=(a/cord (rush a apex))
|_ ent/_`(map term @t)`[[%apos '\''] ~ ~]
++ apex
=+ spa=;~(pose comt whit)
%+ knee *manx |. ~+
%+ ifix [(star spa) (star spa)]
;~ pose
%+ sear |=({a/marx b/marl c/mane} ?.(=(c n.a) ~ (some [a b])))
;~(plug head many tail)
empt
==
::
++ attr :: attributes
%+ knee *mart |. ~+
%- star
;~ plug
;~(pfix (plus whit) name)
;~ pose
(ifix [;~(plug tis doq) doq] (star ;~(less doq escp)))
(ifix [;~(plug tis soq) soq] (star ;~(less soq escp)))
(easy ~)
==
==
::
++ chrd :: character data
%+ cook |=(a/tape ^-(mars ;/(a)))
(plus ;~(less doq ;~(pose (just `@`10) escp)))
::
++ comt :: comments
=- (ifix [(jest '<!--') (jest '-->')] (star -))
;~ pose
;~(less hep prn)
whit
;~(less (jest '-->') hep)
==
::
++ escp ;~(pose ;~(less gal gar pam prn) enty)
++ enty :: entity
%+ ifix pam^sem
;~ pose
=+ def=^+(ent (my [%gt '>'] [%lt '<'] [%amp '&'] [%quot '"'] ~))
%+ sear ~(get by (~(uni by def) ent))
(cook crip ;~(plug alf (stun 1^31 aln)))
%+ cook |=(a/@c ?:((gth a 0x10.ffff) '<27>' (tuft a)))
=< ;~(pfix hax ;~(pose - +))
:- (bass 10 (stun 1^8 dit))
(bass 16 ;~(pfix (mask "xX") (stun 1^8 hit)))
==
::
++ empt :: self-closing tag
%+ ifix [gal (jest '/>')]
;~(plug ;~(plug name attr) (cold ~ (star whit)))
::
++ head :: opening tag
(ifix [gal gar] ;~(plug name attr))
::
++ many
(more (star comt) ;~(pose apex chrd))
::
++ name :: tag name
=+ ^= chx
%+ cook crip
;~ plug
;~(pose cab alf)
(star ;~(pose cab dot alp))
==
;~(pose ;~(plug ;~(sfix chx col) chx) chx)
::
++ tail (ifix [(jest '</') gar] name) :: closing tag
++ whit (mask ~[' ' `@`0x9 `@`0xa]) :: whitespace
--
::
++ jo :: json reparser
=> |% ++ grub (unit *)
++ fist $-(json grub)
--
|%
++ ar :: array as list
|* wit/fist
|= jon/json
?. ?=({$a *} jon) ~
%- zl
|-
?~ p.jon ~
[i=(wit i.p.jon) t=$(p.jon t.p.jon)]
::
++ at :: array as tuple
|* wil/(pole fist)
|= jon/json
?. ?=({$a *} jon) ~
=+ raw=((at-raw wil) p.jon)
?.((za raw) ~ (some (zp raw)))
::
++ at-raw :: array as tuple
|* wil/(pole fist)
|= jol/(list json)
?~ wil ~
:- ?~(jol ~ (-.wil i.jol))
((at-raw +.wil) ?~(jol ~ t.jol))
::
++ bo :: boolean
|=(jon/json ?.(?=({$b *} jon) ~ [~ u=p.jon]))
::
++ bu :: boolean not
|=(jon/json ?.(?=({$b *} jon) ~ [~ u=!p.jon]))
::
++ ci :: maybe transform
|* {poq/$-(* *) wit/fist}
|= jon/json
(biff (wit jon) poq)
::
++ cu :: transform
|* {poq/$-(* *) wit/fist}
|= jon/json
(bind (wit jon) poq)
::
++ da :: UTC date
|= jon/json
?. ?=({$s *} jon) ~
(bind (stud p.jon) |=(a/date (year a)))
::
++ di :: millisecond date
%+ cu
|= a/@u ^- @da
(add ~1970.1.1 (div (mul ~s1 a) 1.000))
ni
::
++ mu :: true unit
|* wit/fist
|= jon/json
?~(jon (some ~) (bind (wit jon) some))
::
++ ne :: number as real
|= jon/json
^- (unit @rd)
!!
::
++ ni :: number as integer
|= jon/json
?. ?=({$n *} jon) ~
(rush p.jon dem)
::
++ no :: number as cord
|= jon/json
?. ?=({$n *} jon) ~
(some p.jon)
::
++ of :: object as frond
|* wer/(pole {cord fist})
|= jon/json
?. ?=({$o {@ *} $~ $~} jon) ~
|-
?~ wer ~
?: =(-.-.wer p.n.p.jon)
((pe -.-.wer +.-.wer) q.n.p.jon)
((of +.wer) jon)
::
++ ot :: object as tuple
|* wer/(pole {cord fist})
|= jon/json
?. ?=({$o *} jon) ~
=+ raw=((ot-raw wer) p.jon)
?.((za raw) ~ (some (zp raw)))
::
++ ot-raw :: object as tuple
|* wer/(pole {cord fist})
|= jom/(map @t json)
?~ wer ~
=+ ten=(~(get by jom) -.-.wer)
[?~(ten ~ (+.-.wer u.ten)) ((ot-raw +.wer) jom)]
::
++ om :: object as map
|* wit/fist
|= jon/json
?. ?=({$o *} jon) ~
(zm (~(run by p.jon) wit))
::
++ op :: parse keys of map
|* {fel/rule wit/fist}
%+ cu my
%- ci :_ (om wit)
|= a/(map cord _(need *wit))
^- (unit (list _[(wonk *fel) (need *wit)]))
=- (zl (turn (~(tap by a)) -))
|* {a/cord b/*}
=+ nit=(rush a fel)
?~ nit ~
(some [u.nit b])
::
++ pe :: prefix
|* {pre/* wit/fist}
(cu |*(* [pre +<]) wit)
::
++ sa :: string as tape
|= jon/json
?.(?=({$s *} jon) ~ (some (trip p.jon)))
::
++ so :: string as cord
|= jon/json
?.(?=({$s *} jon) ~ (some p.jon))
::
++ su :: parse string
|* sab/rule
|= jon/json
?. ?=({$s *} jon) ~
(rush p.jon sab)
::
++ ul |=(jon/json ?~(jon (some ~) ~)) :: null
++ za :: full unit pole
|* pod/(pole (unit))
?~ pod &
?~ -.pod |
(za +.pod)
::
++ zl :: collapse unit list
|* lut/(list (unit))
?. |- ^- ?
?~(lut & ?~(i.lut | $(lut t.lut)))
~
%- some
|-
?~ lut ~
[i=u:+.i.lut t=$(lut t.lut)]
::
++ zp :: unit tuple
|* but/(pole (unit))
?~ but !!
?~ +.but
u:->.but
[u:->.but (zp +.but)]
::
++ zm :: collapse unit map
|* lum/(map term (unit))
?: (~(rep by lum) |=({{@ a/(unit)} b/_|} |(b ?=($~ a))))
~
(some (~(run by lum) need))
--
::
++ joba :: object from k-v pair
|= {p/@t q/json}
^- json
[%o [[p q] ~ ~]]
::
++ jobe :: object from k-v list
|= a/(list {p/@t q/json})
^- json
[%o (~(gas by *(map @t json)) a)]
::
++ jape :: string from tape
|= a/tape
^- json
[%s (crip a)]
::
++ jone :: number from unsigned
|= a/@u
^- json
:- %n
?: =(0 a) '0'
(crip (flop |-(^-(tape ?:(=(0 a) ~ [(add '0' (mod a 10)) $(a (div a 10))])))))
::
++ jode :: ms timestamp
|= a/time
=- (jone (div (mul - 1.000) ~s1))
(add (div ~s1 2.000) (sub a ~1970.1.1))
::
++ jesc
=+ utf=|=(a/@ ['\\' 'u' ((x-co 4):co a)])
|= a/@ ^- tape
?+ a ?:((gth a 0x1f) [a ~] (utf a))
$10 "\\n"
$34 "\\\""
$92 "\\\\"
==
::
++ scanf :: formatted scan
|* {tape (pole _;/(*{$^(rule tape)}))}
=> .(+< [a b]=+<)
(scan a (parsf b))
++ parsf :: make parser from:
|^ |* a/(pole _;/(*{$^(rule tape)})) :: ;"chars{rule}chars"
%- cook :_ (bill (norm a))
|* (list)
?~ +< ~
?~ t i
[i $(+< t)]
::
:: .= (norm [;"{n}, {n}"]:n=dim:ag) ~[[& dim] [| ", "] [& dim]]:ag
++ norm
|* (pole _;/(*{$^(rule tape)}))
?~ +< ~
=> .(+< [i=+<- t=+<+])
:_ t=$(+< t)
=+ rul=->->.i
^= i
?~ rul [%| p=rul]
?~ +.rul [%| p=rul]
?@ &2.rul [%| p=;;(tape rul)]
[%& p=rul]
::
:: .= (bill ~[[& dim] [| ", "] [& dim]]:ag)
:: ;~(plug dim ;~(pfix com ace ;~(plug dim (easy)))):ag
++ bill
|* (list (each rule tape))
?~ +< (easy ~)
?: ?=($| -.i) ;~(pfix (jest (crip p.i)) $(+< t))
%+ cook |*({* *} [i t]=+<)
;~(plug p.i $(+< t))
--
::
++ taco :: atom to octstream
|= tam/@ ^- octs
[(met 3 tam) tam]
::
++ tact :: tape to octstream
|= tep/tape ^- octs
(taco (rap 3 tep))
::
++ tell :: wall to octstream
|= wol/wall ^- octs
=+ buf=(rap 3 (turn wol |=(a/tape (crip (weld a `tape`[`@`10 ~])))))
[(met 3 buf) buf]
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
:: section 3bF, filesystem interface ::
::
++ feel :: simple file write
|= {pax/path val/cage}
^- miso
=+ dir=.^(arch %cy pax)
?~ fil.dir [%ins val]
[%mut val]
::
++ file :: simple file load
|= pax/path
^- (unit)
=+ dir=.^(arch %cy pax)
?~(fil.dir ~ [~ .^(* %cx pax)])
::
++ foal :: high-level write
|= {pax/path val/cage}
^- toro
?> ?=({* * * *} pax)
[i.t.pax [%& [[[t.t.t.pax (feel pax val)] ~]]]]
::
++ fray :: high-level delete
|= pax/path
^- toro
?> ?=({* * * *} pax)
[i.t.pax [%& [[[t.t.t.pax [%del ~]] ~]]]]
::
++ furl :: unify changes
|= {one/toro two/toro}
^- toro
~| %furl
?> ?& =(p.one p.two) :: same path
&(?=($& -.q.one) ?=($& -.q.two)) :: both deltas
==
[p.one [%& (weld p.q.one p.q.two)]]
::
++ tame :: parse kite path
|= hap/path
^- (unit kite)
?. ?=({@ @ @ @ *} hap) ~
=+ :* hyr=(slay i.hap)
fal=(slay i.t.hap)
dyc=(slay i.t.t.hap)
ved=(slay i.t.t.t.hap)
:: ved=(slay i.t.hap)
:: fal=(slay i.t.t.hap)
:: dyc=(slay i.t.t.t.hap)
tyl=t.t.t.t.hap
==
?. ?=({$~ $$ $tas @} hyr) ~
?. ?=({$~ $$ $p @} fal) ~
?. ?=({$~ $$ $tas @} dyc) ~
?. ?=({$~ $$ case} ved) ~
=+ his=`@p`q.p.u.fal
=+ [dis=(end 3 1 q.p.u.hyr) rem=(rsh 3 1 q.p.u.hyr)]
?. ?&(?=($c dis) ?=(?($v $w $x $y $z) rem)) ~
[~ rem p.u.ved q.p.u.fal q.p.u.dyc tyl]
::
++ tome :: parse path to beam
|= pax/path
^- (unit beam)
?. ?=({* * * *} pax) ~
%+ biff (slaw %p i.pax)
|= who/ship
%+ biff (slaw %tas i.t.pax)
|= dex/desk
%+ biff (slay i.t.t.pax)
|= cis/coin
?. ?=({$$ case} cis) ~
`(unit beam)`[~ [who dex `case`p.cis] (flop t.t.t.pax)]
::
++ tope :: beam to path
|= bem/beam
^- path
[(scot %p p.bem) q.bem (scot r.bem) (flop s.bem)]
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
:: section 3bG, URL handling ::
::
++ deft :: parse url extension
|= rax/(list @t)
|- ^- pork
?~ rax
[~ ~]
?^ t.rax
[p.pok [ire q.pok]]:[pok=$(rax t.rax) ire=i.rax]
=+ ^- raf/(like term)
=> |=(a/@ ((sand %tas) (crip (flop (trip a)))))
(;~(sfix (sear . sym) dot) [1^1 (flop (trip i.rax))])
?~ q.raf
[~ [i.rax ~]]
=+ `{ext/term {@ @} fyl/tape}`u.q.raf
:- `ext
?:(=(~ fyl) ~ [(crip (flop fyl)) ~])
::
++ fuel :: parse fcgi
|= {bem/beam ced/noun:cred quy/|-($@($~ {p/@t q/@t t/$}))}
^- epic
=+ qix=|-(`quay`?~(quy quy [[p q]:quy $(quy t.quy)]))
[(malt qix) ((hard cred) ced) bem /]
::
++ sifo :: 64-bit encode
|= tig/@
^- tape
=+ poc=(~(dif fo 3) 0 (met 3 tig))
=+ pad=(lsh 3 poc (swap 3 tig))
=+ ^= cha
'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
=+ ^= sif
|- ^- tape
?~ pad
~
=+ d=(end 0 6 pad)
[(cut 3 [d 1] cha) $(pad (rsh 0 6 pad))]
(weld (flop (slag poc sif)) (reap poc '='))
::
++ ofis :: XX broken
=- |=(a/cord (rash a fel))
=< fel=(cook |~(a/@ `@t`(swap 3 a)) (bass 64 .))
=- (cook welp ;~(plug (plus siw) (stun 0^2 (cold %0 tis))))
^= siw
;~ pose
(cook |=(a/@ (sub a 'A')) (shim 'A' 'Z'))
(cook |=(a/@ (sub a 'G')) (shim 'a' 'z'))
(cook |=(a/@ (add a 4)) (shim '0' '9'))
(cold 62 (just '+'))
(cold 63 (just '/'))
==
::
++ dray :: load tuple into path
=- |* {a/{@tas (pole @tas)} b/*} ^- (paf a)
=> .(b `(tup -.a +.a)`b)
?~ +.a [(scot -.a b) ~]
[(scot -.a -.b) `(paf +.a)`(..$ +.a +.b)]
:- paf=|*(a/(pole) ?~(a $~ {(odo:raid -.a(. %ta)) (..$ +.a)}))
tup=|*({a/@tas b/(pole @tas)} =+(c=(odo:raid a) ?~(b c {c (..$ -.b +.b)})))
::
:: .= [p=%ack q=~sarnel r=&]
:: (raid /ack/~sarnel+.y p=%tas q=%p r=%f ~)
++ raid :: demand path odors
=- |* {a/path b/{@tas (pole @tas)}}
?~ +.b `(odo -.b)`(slav -.b -.a)
[`(odo -.b)`(slav -.b -.a) (..$ +.a +.b)]
^= odo
|* a/@tas
|= b/*
=< a(. (. b)) :: preserve face
?+ a @
$c @c $da @da $dr @dr $f @f $if @if $is @is $p @p
$u @u $uc @uc $ub @ub $ui @ui $ux @ux $uv @uv $uw @uw
$s @s $t @t $ta @ta $tas @tas
==
::
++ read :: parse odored path
=< |*({a/path b/{@tas (pole @tas)}} ((+> b) a))
|* b/{@tas (pole @tas)}
|= a/path
?~ a ~
=+ hed=(slaw -.b i.a)
?~ +.b
^- (unit (odo:raid -.b))
?^(+.a ~ hed)
^- (unit {(odo:raid -.b) _(need *(..^$ +.b))})
(both hed ((..^$ +.b) +.a))
::
++ urle :: URL encode
|= tep/tape
^- tape
%- zing
%+ turn tep
|= tap/char
=+ xen=|=(tig/@ ?:((gte tig 10) (add tig 55) (add tig '0')))
?: ?| &((gte tap 'a') (lte tap 'z'))
&((gte tap 'A') (lte tap 'Z'))
&((gte tap '0') (lte tap '9'))
=('.' tap)
=('-' tap)
=('~' tap)
=('_' tap)
==
[tap ~]
['%' (xen (rsh 0 4 tap)) (xen (end 0 4 tap)) ~]
::
++ urld :: URL decode
|= tep/tape
^- (unit tape)
?~ tep [~ ~]
?: =('%' i.tep)
?. ?=({@ @ *} t.tep) ~
=+ nag=(mix i.t.tep (lsh 3 1 i.t.t.tep))
=+ val=(rush nag hex:ag)
?~ val ~
=+ nex=$(tep t.t.t.tep)
?~(nex ~ [~ [`@`u.val u.nex]])
=+ nex=$(tep t.tep)
?~(nex ~ [~ i.tep u.nex])
::
++ earf :: purf to tape
|= purf
(weld (earn p) ?~(q "" `tape`['#' (trip u.q)]))
::
++ earl :: localize purl
|= {who/@p pul/purl}
^- purl
pul(q.q [(rsh 3 1 (scot %p who)) q.q.pul])
::
++ earn :: purl to tape
=< |=(pul/purl `tape`(apex %& pul))
|%
++ apex
|= qur/quri ^- tape
?- -.qur
$& (weld (head p.p.qur) `tape`$(qur [%| +.p.qur]))
$| ['/' (weld (body p.qur) (tail q.qur))]
==
::
++ body
|= pok/pork ^- tape
?~ q.pok ~
|-
=+ seg=(trip i.q.pok)
?~ t.q.pok
?~(p.pok seg (welp seg '.' (trip u.p.pok)))
(welp seg '/' $(q.pok t.q.pok))
::
++ head
|= har/hart
^- tape
;: weld
?:(&(p.har !?=(hoke r.har)) "https://" "http://")
::
?- -.r.har
$| (trip (rsh 3 1 (scot %if p.r.har)))
$& =+ rit=(flop p.r.har)
|- ^- tape
?~(rit ~ (weld (trip i.rit) ?~(t.rit "" `tape`['.' $(rit t.rit)])))
==
::
?~(q.har ~ `tape`[':' ((d-co:co 1) u.q.har)])
==
::
++ tail
|= kay/quay
^- tape
?: =(~ kay) ~
:- '?'
|- ^- tape
?~ kay ~
;: welp
(urle (trip p.i.kay))
?~(q.i.kay ~ ['=' (urle (trip q.i.kay))])
?~(t.kay ~ `tape`['&' $(kay t.kay)])
==
--
::
++ urlp :: url+header parser
|%
++ apat :: 2396 abs_path
%+ cook deft
(ifix [fas ;~(pose fas (easy ~))] (more fas smeg))
++ aurf :: 2396 with fragment
%+ cook |~(a/purf a)
;~(plug auri (punt ;~(pfix hax (cook crip (star pque)))))
++ auri :: 2396 URL
%+ cook
|= a/purl
?.(?=(hoke r.p.a) a a(p.p &))
;~ plug
;~ plug
%+ sear
|= a/@t
^- (unit ?)
?+(a ~ $http [~ %|], $https [~ %&])
;~(sfix scem ;~(plug col fas fas))
thor
==
;~(plug ;~(pose apat (easy *pork)) yque)
==
++ cock :: cookie
(most ;~(plug sem ace) ;~(plug toke ;~(pfix tis tosk)))
++ dlab :: 2396 domainlabel
%+ sear
|= a/@ta
?.(=('-' (rsh 3 (dec (met 3 a)) a)) [~ u=a] ~)
%+ cook cass
;~(plug aln (star alp))
::
++ fque (cook crip (plus pquo)) :: normal query field
++ fquu (cook crip (star pquo)) :: optional field
++ pcar ;~(pose pure pesc psub col pat) :: 2396 path char
++ pcok ;~(less bas sem com doq prn) :: cookie char
++ pesc ;~(pfix cen mes) :: 2396 escaped
++ pold (cold ' ' (just '+')) :: old space code
++ pque ;~(pose pcar fas wut) :: 3986 query char
++ pquo ;~(pose pure pesc pold fas wut) :: normal query char
++ pure ;~(pose aln hep dot cab sig) :: 2396 unreserved
++ psub ;~ pose :: 3986 sub-delims
zap buc pam soq pel per
tar lus com sem tis
==
++ ptok ;~ pose :: 2616 token
aln zap hax buc cen pam soq tar lus
hep dot ket cab tec bar sig
==
++ scem :: 2396 scheme
%+ cook cass
;~(plug alf (star ;~(pose aln lus hep dot)))
::
++ smeg (cook crip (plus pcar)) :: 2396 segment
++ tock (cook crip (plus pcok)) :: 6265 cookie-value
++ tosk ;~(pose tock (ifix [doq doq] tock)) :: 6265 cookie-value
++ toke (cook crip (plus ptok)) :: 2616 token
++ thor :: 2396 host+port
%+ cook |*({* *} [+<+ +<-])
;~ plug
thos
;~((bend) (easy ~) ;~(pfix col dim:ag))
==
++ thos :: 2396 host, no local
;~ plug
;~ pose
%+ stag %&
%+ sear :: LL parser weak here
|= a/(list @t)
=+ b=(flop a)
?> ?=(^ b)
=+ c=(end 3 1 i.b)
?.(&((gte c 'a') (lte c 'z')) ~ [~ u=b])
(most dot dlab)
::
%+ stag %|
=+ tod=(ape:ag ted:ab)
%+ bass 256
;~(plug tod (stun [3 3] ;~(pfix dot tod)))
==
==
++ yque :: query ending
;~ pose
;~(pfix wut yquy)
(easy ~)
==
++ yquy :: query
;~ pose :: proper query
%+ more
;~(pose pam sem)
;~(plug fque ;~(pose ;~(pfix tis fquu) (easy '')))
::
%+ cook :: funky query
|=(a/tape [[%$ (crip a)] ~])
(star pque)
==
++ zest :: 2616 request-uri
;~ pose
(stag %& (cook |=(a/purl a) auri))
(stag %| ;~(plug apat yque))
==
--
++ epur :: url+header parser
=>(urlp |=(a/cord `(unit purl)`(rush a auri)))
::
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
:: section 3bH, names etc ::
::
++ clan :: ship to rank
|= who/ship ^- rank
=+ wid=(met 3 who)
?: (lte wid 1) %czar
?: =(2 wid) %king
?: (lte wid 4) %duke
?: (lte wid 8) %earl
?> (lte wid 16) %pawn
::
++ glam :: carrier names
|= zar/@pD ^- tape
(weld "galaxy " (scow %p zar))
::
++ gnom :: ship display name
|= {{our/@p now/@da} him/@p} ^- @t
=+ yow=(scot %p him)
=+ pax=[(scot %p our) %name (scot %da now) yow ~]
=+ woy=.^(@t %a pax)
?: =(%$ woy) yow
(rap 3 yow ' ' woy ~)
::
++ gnow
|= {who/@p gos/gcos} ^- @t
?- -.gos
$czar (rap 3 '|' (rap 3 (glam who)) '|' ~)
$king (rap 3 '_' p.gos '_' ~)
$earl (rap 3 ':' p.gos ':' ~)
$pawn ?~(p.gos %$ (rap 3 '.' u.p.gos '.' ~))
$duke
?: ?=($anon -.p.gos) %$
%+ rap 3
^- (list @)
?- -.p.gos
$punk ~['"' q.p.gos '"']
?($lord $lady)
=+ ^= nad
=+ nam=`name`s.p.p.gos
%+ rap 3
:~ p.nam
?~(q.nam 0 (cat 3 ' ' u.q.nam))
?~(r.nam 0 (rap 3 ' (' u.r.nam ')' ~))
' '
s.nam
==
?:(=(%lord -.p.gos) ~['[' nad ']'] ~['(' nad ')'])
==
==
++ pale :: filter peers
|= {hid/bowl fun/$-(sink ?)}
(skim (~(tap by sup.hid)) fun)
::
++ prix :: filter gate
|= pax/path |= sink ^- ?
?~ pax & ?~ r.+< |
&(=(i.pax i.r.+<) $(pax t.pax, r.+< t.r.+<))
::
++ prey |=({pax/path hid/bowl} (pale hid (prix pax))) :: prefix
++ hunt :: first of unit dates
|= {one/(unit @da) two/(unit @da)}
^- (unit @da)
?~ one two
?~ two one
?:((lth u.one u.two) one two)
::
++ mole :: new to old sky
|= ska/$-(* (unit (unit)))
|= a/*
^- (unit)
=+ b=(ska a)
?~ b ~
?~ u.b ~
[~ u.u.b]
::
++ myle :: new to old sky
|= ska/$-({* *} (unit (unit)))
^- $-({* *} (unit))
|= a/{* *}
^- (unit)
=+ b=(ska a)
?~ b ~
?~ u.b ~
[~ u.u.b]
::
++ pack :: light path encoding
|= {a/term b/path} ^- knot
%+ rap 3 :- (wack a)
(turn b |=(c/knot (cat 3 '_' (wack c))))
::
++ puck :: light path decoding
=+ fel=(most cab (sear wick urt:ab))
|=(a/knot `(unit {p/term q/path})`(rush a fel))
::
++ saxo :: autocanon
|= who/ship
^- (list ship)
?: (lth who 256) [who ~]
[who $(who (sein who))]
::
++ sein :: autoboss
|= who/ship ^- ship
=+ mir=(clan who)
?- mir
$czar who
$king (end 3 1 who)
$duke (end 4 1 who)
$earl (end 5 1 who)
$pawn `@p`0
==
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
:: section 3bI, Arvo structures ::
::
++ acru :: asym cryptosuite
$_ ^? |% :: opaque object
++ as ^? :: asym ops
|% ++ seal |~({a/pass b/@ c/@} *@) :: encrypt to a
++ sign |~({a/@ b/@} *@) :: certify as us
++ sure |~({a/@ b/@} *(unit @)) :: authenticate from us
++ tear |~ {a/pass b/@} :: accept from a
*(unit {p/@ q/@}) ::
-- ::
++ de |~({a/@ b/@} *(unit @)) :: symmetric de, soft
++ dy |~({a/@ b/@} *@) :: symmetric de, hard
++ en |~({a/@ b/@} *@) :: symmetric en
++ ex ^? :: export
|% ++ fig *@uvH :: fingerprint
++ pac *@uvG :: default passcode
++ pub *pass :: public key
++ sec *ring :: private key
-- ::
++ nu ^? :: reconstructors
|% ++ pit |~({a/@ b/@} ^?(..nu)) :: from [width seed]
++ nol |~(a/@ ^?(..nu)) :: from naked ring
++ com |~(a/@ ^?(..nu)) :: from naked pass
-- ::
-- ::
++ aeon @ud ::
++ agon (map {p/ship q/desk} {p/@ud q/@ud r/waks}) :: mergepts
++ ankh :: fs node (new)
$: fil/(unit {p/lobe q/cage}) :: file
dir/(map @ta ankh) :: folders
== ::
++ apex {p/@uvI q/(map @ta @uvI) r/(map @ta $~)} :: node report (old)
++ ares (unit {p/term q/(list tank)}) :: possible error
++ ball @uw :: statement payload
++ bait {p/skin q/@ud r/dove} :: fmt nrecvd spec
++ bath :: convo per client
$: sop/shed :: not stalled
raz/(map path race) :: statements inbound
ryl/(map path rill) :: statements outbound
== ::
++ beam {{p/ship q/desk r/case} s/path} :: global name
++ beak {p/ship q/desk r/case} :: garnish with beak
++ bird :: packet in travel
$: gom/soap :: message identity
mup/@ud :: pktno in msg
nux/@ud :: xmission count
lys/@da :: last sent
pac/rock :: packet data
== ::
++ bitt (map bone (pair ship path)) :: incoming subs
++ blob :: fs blob
$% {$delta p/lobe q/{p/mark q/lobe} r/page} :: delta on q
{$direct p/lobe q/page} :: immediate
== ::
++ boat (map (pair bone wire) (trel bean ship path)) :: outgoing subs
++ boon :: fort output
$% {$beer p/ship q/@uvG} :: gained ownership
{$cake p/sock q/soap r/coop s/duct} :: e2e message result
{$coke p/sock q/soap r/cape s/duct} :: message result
{$mead p/lane q/rock} :: accept packet
{$milk p/sock q/soap r/*} :: accept message
{$mulk p/sock q/soap r/*} :: e2e pass message
{$ouzo p/lane q/rock} :: transmit packet
{$wine p/sock q/tape} :: notify user
== ::
++ bowl :: standard app state
$: $: our/ship :: host
src/ship :: guest
dap/term :: agent
== ::
$: wex/boat :: outgoing subs
sup/bitt :: incoming subs
== ::
$: ost/bone :: opaque cause
act/@ud :: change number
eny/@uvI :: entropy
now/@da :: current time
byk/beak :: load source
== == ::
++ bray {p/life q/(unit life) r/ship s/@da} :: our parent us now
++ brow {p/@da q/@tas} :: browser version
++ buck {p/mace q/will} :: all security data
++ cake {p/sock q/skin r/@} :: top level packet
++ cape :: end-to-end result
$? $good :: delivered
$dead :: rejected
== ::
++ care ?($u $v $w $x $y $z) :: clay submode
++ case :: ship desk case spur
$% {$da p/@da} :: date
{$tas p/@tas} :: label
{$ud p/@ud} :: number
== ::
++ chum @uvI :: hashed passcode
++ clot :: symmetric record
$: yed/(unit {p/hand q/code}) :: outbound
heg/(map hand code) :: proposed
qim/(map hand code) :: inbound
== ::
++ coal * :: untyped vase
++ code @uvI :: symmetric key
++ cone :: reconfiguration
$% {$& p/twig} :: transform
{$| p/(list @tas)} :: alter
== ::
++ chum @uvI :: hashed passcode
++ claw :: startup chain
$: joy/(unit coal) :: local context
ran/(unit coal) :: arguments
pux/(unit path) :: execution path
jiv/(unit coal) :: app configuration
kyq/(unit coal) :: app customization
gam/(unit coal) :: app image
== ::
++ clip (each @if @is) :: client IP
++ coal * :: untyped vase
++ code @uvI :: symmetric key
++ cone :: reconfiguration
$% {$& p/twig} :: transform
{$| p/(list @tas)} :: alter
== ::
++ coop (unit ares) :: e2e ack
++ corn :: flow by server
$: hen/duct :: admin channel
nys/(map flap bait) :: packets incoming
olz/(map flap cape) :: packets completed
wab/(map ship bath) :: relationship
== ::
++ cred :: credential
$: hut/hart :: client host
aut/(jug @tas @t) :: client identities
orx/oryx :: CSRF secret
acl/(unit @t) :: accept-language
cip/(each @if @is) :: client IP
cum/(map @tas *) :: custom dirt
== ::
++ deed {p/@ q/step r/?} :: sig stage fake?
++ dome :: project state
$: ank/ankh :: state
let/@ud :: top id
hit/(map @ud tako) :: changes by id
lab/(map @tas @ud) :: labels
== ::
++ dore :: foreign contact
$: wod/road :: connection to
wyl/will :: inferred mirror
caq/clot :: symmetric key state
== ::
++ dove {p/@ud q/(map @ud @)} :: count hash 13-blocks
++ epic :: FCGI parameters
$: qix/(map @t @t) :: query
ced/cred :: client credentials
bem/beam :: original path
but/path :: ending
== ::
++ flap @uvH :: network packet id
++ flow :: packet connection
$: rtt/@dr :: decaying avg rtt
wid/@ud :: logical wdow msgs
== ::
++ fort :: formal state
$: $0 :: version
gad/duct :: client interface
hop/@da :: network boot date
ton/town :: security
zac/(map ship corn) :: flows by server
== ::
++ gank (each vase (list tank)) :: abstract result
++ gilt {@tas *} :: presumed gift
++ gens {p/lang q/gcos} :: general identity
++ germ :: merge style
$? $init :: new desk
$this :: ours with parents
$that :: hers with parents
$fine :: fast forward
$meet :: orthogonal files
$mate :: orthogonal changes
$meld :: force merge
== ::
++ gcos :: id description
$% {$czar $~} :: 8-bit ship
{$duke p/what} :: 32-bit ship
{$earl p/@t} :: 64-bit ship
{$king p/@t} :: 16-bit ship
{$pawn p/(unit @t)} :: 128-bit ship
== ::
++ govt path :: country+postcode
++ hand @uvH :: hash of code
++ hart {p/? q/(unit @ud) r/host} :: http sec+port+host
++ hate {p/purl q/@p r/moth} :: semi-cooked request
++ heir {p/@ud q/mess r/(unit love)} :: status+headers+data
++ hiss {p/purl q/moth} :: outbound request
++ hist {p/@ud q/(list @t)} :: depth texts
++ hole @t :: session identity
++ hort {p/(unit @ud) q/host} :: http port+host
++ host (each (list @t) @if) :: http host
++ hoke %+ each {$localhost $~} :: local host
?($.0.0.0.0 $.127.0.0.1) ::
++ httq :: raw http request
$: p/meth :: method
q/@t :: unparsed url
r/(list {p/@t q/@t}) :: headers
s/(unit octs) :: body
== ::
++ httr {p/@ud q/mess r/(unit octs)} :: raw http response
++ httx :: encapsulated http
$: p/? :: https?
q/clip :: source IP
r/httq ::
== ::
++ kite {p/care q/case r/ship s/desk t/spur} :: parsed global name
++ json :: normal json value
$@ $~ :: null
$% {$a p/(list json)} :: array
{$b p/?} :: boolean
{$o p/(map @t json)} :: object
{$n p/@ta} :: number
{$s p/@t} :: string
== ::
++ lamb :: short path
$% {$& p/@tas} :: auto
{$| p/twig} :: manual
== ::
++ lane :: packet route
$% {$if p/@da q/@ud r/@if} :: IP4/public UDP/addr
{$is p/@ud q/(unit lane) r/@is} :: IPv6 w+alternates
{$ix p/@da q/@ud r/@if} :: IPv4 provisional
== ::
++ lang @ta :: IETF lang as code
++ lark {p/(unit @tas) q/lawn} :: parsed command
++ lass ?($0 $1 $2) :: power increment
++ lath $% :: pipeline stage
{$0 p/lass q/lamb r/(list cone) s/twig} :: command
{$1 p/twig} :: generator
{$2 p/twig} :: filter
== ::
++ lawn (list lath) ::
++ lice {p/ship q/buck} :: full license
++ life @ud :: regime number
++ lint (list rock) :: fragment array
++ lobe @uvI :: blob ref
++ love $% :: http response
{$ham p/manx} :: html node
{$mid p/mite q/octs} :: mime-typed data
{$raw p/httr} :: raw http response
{$wan p/wain} :: text lines
{$zap p/@ud q/(list tank)} :: status+error
== ::
++ maki {p/@ta q/@ta r/@ta s/path} ::
++ mace (list {p/life q/ring}) :: private secrets
++ math (map @t (list @t)) :: semiparsed headers
++ meal :: payload
$% {$back p/cape q/flap r/@dr} :: acknowledgment
{$buck p/coop q/flap r/@dr} :: e2e ack
{$bond p/life q/path r/@ud s/*} :: message
{$bund p/life q/path r/@ud s/*} :: e2e message
{$carp p/@ q/@ud r/@ud s/flap t/@} :: skin+inx+cnt+hash
{$fore p/ship q/(unit lane) r/@} :: forwarded packet
== ::
++ mess (list {p/@t q/@t}) :: raw http headers
++ meta :: path metadata
$% {$& q/@uvI} :: hash
{$| q/(list @ta)} :: dir
== ::
++ meth :: http methods
$? $conn :: CONNECT
$delt :: DELETE
$get :: GET
$head :: HEAD
$opts :: OPTIONS
$post :: POST
$put :: PUT
$trac :: TRACE
== ::
++ mime {p/mite q/octs} :: mimetyped data
++ mite (list @ta) :: mime type
++ miso :: ankh delta
$% {$del $~} :: delete
{$ins p/cage} :: insert
{$dif p/cage} :: mutate from diff
{$mut p/cage} :: mutate from raw
== ::
++ misu :: computed delta
$% {$del $~} :: delete
{$ins p/cage} :: insert
{$dif p/lobe q/cage} :: mutate from diff
== ::
++ mizu {p/@u q/(map @ud tako) r/rang} :: new state
++ moar {p/@ud q/@ud} :: normal change range
++ moat {p/case q/case r/path} :: change range
++ mood {p/care q/case r/path} :: request in desk
++ moth {p/meth q/math r/(unit octs)} :: http operation
++ name {p/@t q/(unit @t) r/(unit @t) s/@t} :: first mid+nick last
++ newt ?($boot $kick $mess $slay $wake) :: lifecycle events
++ nori :: repository action
$% {$& p/soba} :: delta
{$| p/@tas} :: label
== ::
++ nuri :: repository action
$% {$& p/suba} :: delta
{$| p/@tas} :: label
== ::
++ octs {p/@ud q/@t} :: octet-stream
++ oryx @t :: CSRF secret
++ page (cask *) :: untyped cage
++ pail ?($none $warm $cold) :: connection status
++ plan (trel view (pair @da (unit @dr)) path) :: subscription
++ plea {p/@ud q/{p/? q/@t}} :: live prompt
++ plop blob :: unvalidated blob
++ pork {p/(unit @ta) q/(list @t)} :: fully parsed url
++ pred {p/@ta q/@tas r/@ta $~} :: proto-path
++ prod {p/prom q/tape r/tape} :: prompt
++ prom ?($text $pass $none) :: format type
++ purf (pair purl (unit @t)) :: url with fragment
++ purl {p/hart q/pork r/quay} :: parsed url
++ putt :: outgoing message
$: ski/snow :: sequence acked+sent
wyv/(list rock) :: packet list XX gear
== ::
++ pyre :: cascade stash
$: p/(map {p/path q/path r/coal} coal) :: by path
q/(map {p/path q/@uvI r/coal} coal) :: by source hash
r/(map {p/* q/coal} coal) :: by (soft) twig
== ::
++ quay (list {p/@t q/@t}) :: parsed url query
++ quri :: request-uri
$% {$& p/purl} :: absolute
{$| p/pork q/quay} :: relative
== ::
++ race :: inbound stream
$: did/@ud :: filled sequence
dod/? :: not processing
bum/(map @ud ares) :: nacks
mis/(map @ud {p/cape q/lane r/flap s/(unit)}) :: misordered
== ::
++ rank ?($czar $king $duke $earl $pawn) :: ship width class
++ rang $: hut/(map tako yaki) ::
lat/(map lobe blob) ::
== ::
++ rand :: unvalidated rant
$: p/{p/care q/case r/@tas} :: clade release book
q/path :: spur
r/page :: data
== ::
++ rant :: namespace binding
$: p/{p/care q/case r/@tas} :: clade release book
q/path :: spur
r/cage :: data
== ::
++ rave :: general request
$% {$sing p/mood} :: single request
{$next p/mood} :: next version
{$many p/? q/moat} :: change range
== ::
++ rill :: outbound stream
$: sed/@ud :: sent
san/(map @ud duct) :: outstanding
== ::
++ riot (unit rant) :: response+complete
++ road :: secured oneway route
$: exp/@da :: expiration date
lun/(unit lane) :: route to friend
lew/will :: will of friend
== ::
++ rock @uvO :: packet
++ rout {p/(list host) q/path r/oryx s/path} :: http route (new)
++ rump {p/care q/case r/@tas s/path} :: relative path
++ saba {p/ship q/@tas r/moar s/dome} :: patch+merge
++ sack {p/ship q/ship} :: incoming [our his}
++ sufi :: domestic host
$: hoy/(list ship) :: hierarchy
val/wund :: private keys
law/will :: server will
seh/(map hand {p/ship q/@da}) :: key cache
hoc/(map ship dore) :: neighborhood
== ::
++ salt @uv :: entropy
++ seal :: auth conversation
$: whu/(unit ship) :: client identity
pul/purl :: destination url
wit/? :: wait for partner
foy/(unit {p/ship q/hole}) :: partner to notify
pus/(unit @ta) :: password
== ::
++ sect ?($black $blue $red $orange $white) :: banner
++ shed :: packet flow
$: $: rtt/@dr :: smoothed rtt
rto/@dr :: retransmit timeout
rtn/(unit @da) :: next timeout
rue/(unit @da) :: last heard from
== ::
$: nus/@ud :: number sent
nif/@ud :: number live
nep/@ud :: next expected
caw/@ud :: logical window
cag/@ud :: congest thresh
== ::
$: diq/(map flap @ud) :: packets sent
pyz/(map soup @ud) :: message+unacked
puq/(qeu {p/@ud q/soul}) :: packet queue
== ::
== ::
++ skit {p/(unit @ta) q/(list @ta) r/(list @ta)} :: tracking path
++ skin ?($none $open $fast $full) :: encoding stem
++ snow {p/@ud q/@ud r/(set @ud)} :: window exceptions
++ soap {p/{p/life q/life} q/path r/@ud} :: statement id
++ soup {p/path q/@ud} :: new statement id
++ soul :: packet in travel
$: gom/soup :: message identity
nux/@ud :: xmission count
liv/? :: deemed live
lys/@da :: last sent
pac/rock :: packet data
== ::
++ soba (list {p/path q/miso}) :: delta
++ sock {p/ship q/ship} :: outgoing [from to]
++ spur path :: ship desk case spur
++ step {p/bray q/gens r/pass} :: identity stage
++ suba (list {p/path q/misu}) :: delta
++ tako @ :: yaki ref
++ tick @ud :: process id
++ toro {p/@ta q/nori} :: general change
++ town :: all security state
$: lit/@ud :: imperial modulus
any/@ :: entropy
urb/(map ship sufi) :: all keys and routes
fak/? ::
== ::
++ tube {p/@ta q/@ta r/@ta s/path} :: canonical path
++ tutu * :: presumed type
++ yaki {p/(list tako) q/(map path lobe) r/tako t/@da} :: commit
++ view ?($u $v $w $x $y $z) :: view mode
++ waks (map path woof) :: list file states
++ what :: logical identity
$% {$anon $~} :: anonymous
{$lady p/whom} :: female person ()
{$lord p/whom} :: male person []
{$punk p/sect q/@t} :: opaque handle ""
== ::
++ whom {p/@ud q/govt r/sect s/name} :: year+govt+id
++ woof $@ $know :: udon transform
{$chan (list {$@(@ud {p/@ud q/@ud})})} ::
++ wund (list {p/life q/ring r/acru}) :: mace in action
++ will (list deed) :: certificate
++ zuse %310 :: hoon+zuse kelvin
:: ::
:::: :::: this will become `%york`, vane structures.
:: ::
++ gift-ames :: out result <-$
$% {$hear p/lane q/@} :: receive packet
{$init p/@p} :: report install
{$mass p/mass} :: memory usage
{$send p/lane q/@} :: transmit packet
{$waft p/sock q/*} :: response message
{$wart p/sock q/@tas r/path s/*} :: network request
{$went p/ship q/cape} :: reaction message
{$woot p/ship q/coop} :: e2e reaction message
== ::
++ kiss-ames :: in request ->$
$% {$barn $~} :: new unix process
{$crud p/@tas q/(list tank)} :: error with trace
{$cash p/@p q/buck} :: civil license
{$hear p/lane q/@} :: receive packet
{$hole p/lane q/@} :: packet failed
{$junk p/@} :: entropy
{$kick p/@da} :: wake up
{$make p/(unit @t) q/@ud r/@ s/?} :: wild license
{$sith p/@p q/@uw r/?} :: imperial generator
{$wake $~} :: timer activate
{$want p/sock q/path r/*} :: send message
{$wegh $~} :: report memory
{$west p/sack q/path r/*} :: network request
{$wont p/sock q/path r/*} :: e2e send message
== ::
::
:::: %behn
::
++ gift-behn :: out result <-$
$% {$mass p/mass} :: memory usage
{$wake $~} :: wakey-wakey
== ::
++ kiss-behn :: in request ->$
$% {$rest p/@da} :: cancel alarm
{$wait p/@da} :: set alarm
{$wake $~} :: timer activate
{$wegh $~} :: report memory
== ::
::
:::: %clay
::
++ khan ::
$: fil/(unit (unit cage)) :: XX see khan-to-soba
dir/(unit (map @ta (unit khan))) ::
== ::
++ mode (list {path (unit mime)}) ::
++ riff {p/desk q/(unit rave)} :: request+desist
:::: ::
++ gift-clay :: out result <-$
$% {$ergo p/@tas q/mode} :: version update
{$hill p/(list @tas)} :: mount points
{$mack p/(unit tang)} :: ack
{$mass p/mass} :: memory usage
{$mere p/(each (set path) (pair term tang))} :: merge result
{$note p/@tD q/tank} :: debug message
{$ogre p/@tas} :: delete mount point
{$writ p/riot} :: response
== ::
++ kiss-clay :: in request ->$
$% {$boat $~} :: pier rebooted
{$drop p/@p q/@tas} :: cancel pending merge
{$info p/@p q/@tas r/nori} :: internal edit
{$init p/@p} :: report install
{$into p/@tas q/? r/mode} :: external edit
{$merg p/@p q/@tas r/@p s/@tas t/case u/germ} :: merge desks
{$mont p/@tas q/@p r/@tas s/path} :: mount to unix
{$ogre p/$@(@tas beam)} :: delete mount point
{$warp p/sock q/riff} :: file request
{$wegh $~} :: report memory
{$west p/sack q/path r/*} :: network request
== ::
::
::::
::
++ blew {p/@ud q/@ud} :: columns rows
++ belt :: old belt
$% {$aro p/?($d $l $r $u)} :: arrow key
{$bac $~} :: true backspace
{$ctl p/@c} :: control-key
{$del $~} :: true delete
{$met p/@c} :: meta-key
{$ret $~} :: return
{$txt p/(list @c)} :: utf32 text
== ::
++ blit :: old blit
$% {$bel $~} :: make a noise
{$clr $~} :: clear the screen
{$hop p/@ud} :: set cursor position
{$lin p/(list @c)} :: set current line
{$mor $~} :: newline
{$sag p/path q/*} :: save to jamfile
{$sav p/path q/@} :: save to file
{$url p/@t} :: activate url
== ::
++ dill-belt :: new belt
$% {$aro p/?($d $l $r $u)} :: arrow key
{$bac $~} :: true backspace
{$cru p/@tas q/(list tank)} :: echo error
{$ctl p/@} :: control-key
{$del $~} :: true delete
{$hey $~} :: refresh
{$met p/@} :: meta-key
{$ret $~} :: return
{$rez p/@ud q/@ud} :: resize, cols, rows
{$txt p/(list @c)} :: utf32 text
{$yow p/gill} :: connect to app
== ::
++ dill-blit :: new blit
$% {$bel $~} :: make a noise
{$clr $~} :: clear the screen
{$hop p/@ud} :: set cursor position
{$mor p/(list dill-blit)} :: multiple blits
{$pro p/(list @c)} :: show as cursor+line
{$qit $~} :: close console
{$out p/(list @c)} :: send output line
{$sag p/path q/*} :: save to jamfile
{$sav p/path q/@} :: save to file
{$url p/@t} :: activate url
== ::
++ flog :: sent to %dill
$% {$crud p/@tas q/(list tank)} ::
{$heft $~} ::
{$text p/tape} ::
{$veer p/@ta q/path r/@t} :: install vane
{$vega p/path} :: reboot by path
{$verb $~} :: verbose mode
== ::
++ gill (pair ship term) :: general contact
::::
++ gift-dill :: out result <-$
$% {$bbye $~} :: reset prompt
{$blit p/(list blit)} :: terminal output
{$burl p/@t} :: activate url
{$init p/@p} :: set owner
{$logo $~} :: logout
{$mass p/mass} :: memory usage
{$veer p/@ta q/path r/@t} :: install vane
{$vega p/path} :: reboot by path
{$verb $~} :: verbose mode
== ::
++ kiss-dill :: in request ->$
$% {$belt p/belt} :: terminal input
{$blew p/blew} :: terminal config
{$boot p/*} :: weird %dill boot
{$crud p/@tas q/(list tank)} :: error with trace
{$flog p/flog} :: wrapped error
{$flow p/@tas q/(list gill)} :: terminal config
{$hail $~} :: terminal refresh
{$heft $~} :: memory report
{$hook $~} :: this term hung up
{$harm $~} :: all terms hung up
{$init p/ship} :: after gall ready
{$tick p/@p q/@p} :: initial ticket
{$noop $~} :: no operation
{$talk p/tank} ::
{$text p/tape} ::
{$veer p/@ta q/path r/@t} :: install vane
{$vega p/path} :: reboot by path
{$verb $~} :: verbose mode
== ::
::
:::: %eyre
::
++ gram :: inter-ship message
=+ fuz={path *} :: ames format
$? {{$lon $~} p/hole} :: login request
{{$aut $~} p/hole} :: login reply
{{$hat $~} p/hole q/hart} :: login redirect
{{$get $~} p/@uvH q/{? clip httq}} :: remote request
{{$got $~} p/@uvH q/httr} :: remote response
{{$gib $~} p/@uvH} :: remote cancel
== ::
:::: ::
++ kiss-eyre :: in request ->$
$% {$born $~} :: new unix process
{$crud p/@tas q/(list tank)} :: XX rethink
{$hiss p/mark q/cage} :: outbound user req
{$init p/@p} :: report install
{$serv p/$@(desk beam)} :: set serving root
{$them p/(unit hiss)} :: outbound request
{$they p/@ud q/httr} :: inbound response
{$this p/? q/clip r/httq} :: inbound request
{$thud $~} :: inbound cancel
{$wegh $~} :: report memory
{$west p/sack q/fuz:gram} :: network request
== ::
++ gift-eyre :: out result <-$
$% {$mass p/mass} :: memory usage
{$mack p/(unit tang)} :: message ack
{$sigh p/cage} :: marked http response
{$thou p/httr} :: raw http response
{$thus p/@ud q/(unit hiss)} :: http request+cancel
{$veer p/@ta q/path r/@t} :: drop-through
{$vega p/path} :: drop-through
== ::
::
:::: %ford
::
++ hood :: assembly plan
$: zus/@ud :: zuse kelvin
sur/(list hoof) :: structures
lib/(list hoof) :: libraries
fan/(list horn) :: resources
src/(list hoop) :: program
== ::
++ hoof (pair term (unit (pair case ship))) :: resource reference
++ hoop :: source in hood
$% {$& p/twig} :: direct twig
{$| p/beam} :: resource location
== ::
++ horn :: resource tree
$% {$ape p/twig} :: /~ twig by hand
{$arg p/twig} :: /$ argument
{$alt p/(list horn)} :: /| options
{$dep p/horn} :: /# insert dephash
{$dub p/term q/horn} :: /= apply face
{$fan p/(list horn)} :: /. list
{$for p/(list (pair path:spur horn))} :: /, switch by path
{$hel p/horn} :: /% propagate args
{$lin p/(list mark) q/horn} :: /& translates
{$man p/(map knot horn)} :: /* hetero map
{$nap p/horn} :: /_ homo map
{$now p/horn} :: /@ list by @da
{$saw p/twig q/horn} :: /; operate on
{$see p/beam q/horn} :: /: relative to
{$sic p/twig q/horn} :: /^ cast
{$toy p/? q/mark} :: /mark/ static/hook
== ::
++ milk (trel ship desk silk) :: sourced silk
++ silk :: construction layer
$^ {p/silk q/silk} :: cons
$% {$$ p/cage} :: literal
{$alts p/(list silk)} :: options
{$bake p/mark q/coin r/beam} :: local synthesis
{$bunt p/mark} :: example of mark
{$call p/silk q/silk} :: slam
{$cast p/mark q/silk} :: translate
{$core p/beam} :: build program
{$diff p/silk q/silk} :: diff
{$dude p/(trap tank) q/silk} :: error wrap
{$file p/beam} :: from clay
{$flag p/(set $@(@uvH beam)) q/silk} :: add dependencies
{$join p/mark q/silk r/silk} :: merge
{$mash p/mark q/milk r/milk} :: annotate
{$mute p/silk q/(list (pair wing silk))} :: mutant
{$pact p/silk q/silk} :: patch
{$plan p/beam q/coin r/hood} :: structured assembly
{$reef $~} :: kernel reef
{$ride p/twig q/silk} :: silk thru twig
{$tabl p/(list (pair silk silk))} :: list
{$vale p/mark q/*} :: validate
{$volt p/(cask *)} :: unsafe add type
== ::
::::
++ bilk (pair beak silk) :: sourced request
++ gage :: recursive cage+tang
$% {$& p/cage} :: success
{$| p/tang} :: error
{$tabl p/(list (pair gage gage))} :: table of results
==
++ gift-ford :: out result <-$
$% {$made p/@uvH q/gage} :: computed result
{$mass p/mass} :: memory usage
{$news p/@uvH} :: fresh depends
== ::
++ kiss-ford :: in request ->$
$% {$exec p/@p q/(unit bilk)} :: make / kill
{$wasp p/@p q/{@uvH ?}} :: depends ask / kill
{$wegh $~} :: report memory
{$wipe p/@p $~} :: clear cache
== ::
::
:::: %gall
::
++ club :: agent action
$% {$peel p/mark q/path} :: translated peer
{$peer p/path} :: subscribe
{$poke p/cage} :: apply
{$puff p/mark q/noun} :: unchecked poke
{$pull $~} :: unsubscribe
{$punk p/mark q/cage} :: translated poke
{$pump $~} :: pump yes+no
== ::
++ cuft :: internal gift
$% {$coup p/(unit tang)} :: poke result
{$diff p/cage} :: subscription output
{$doff p/mark q/noun} :: untyped diff
{$quit $~} :: close subscription
{$reap p/(unit tang)} :: peer result
== ::
++ culm :: config action
$% {$load p/scup} :: load+reload
:: {$kick $~} :: restart everything
:: {$stop $~} :: toggle suspend
:: {$wipe $~} :: destroy all state
== ::
++ cush (pair term club) :: internal kiss
++ dude term :: server identity
++ scup (pair ship desk) :: autoupdate
++ well (pair desk term) ::
++ suss (trel dude @tas @da) :: config report
:::: ::
++ kiss-gall :: incoming request
$% {$conf p/dock q/culm} :: configure app
{$init p/ship} :: set owner
{$deal p/sock q/cush} :: full transmission
{$west p/sack q/path r/*} :: network request
{$wegh $~} :: report memory
== ::
++ gift-gall :: outgoing result
$% {$mass p/mass} :: memory usage
{$onto p/(each suss tang)} :: about agent
{$unto p/cuft} :: within agent
{$mack p/(unit tang)} :: message ack
== ::
::
:::: %arvo
::
++ gift-arvo :: out result <-$
$? gift-ames
gift-clay
gift-dill
gift-eyre
gift-ford
gift-gall
gift-behn
==
++ kiss-arvo :: in request ->$
$? kiss-ames
kiss-clay
kiss-dill
kiss-eyre
kiss-ford
kiss-gall
kiss-behn
==
++ note-arvo :: out request $->
$? {@tas $meta vase}
$% {$a kiss-ames}
{$b kiss-behn}
{$c kiss-clay}
{$d kiss-dill}
{$e kiss-eyre}
{$f kiss-ford}
{$g kiss-gall}
== ==
++ sign-arvo :: in result $<-
$% {$a gift-ames}
{$b gift-behn}
{$c gift-clay}
{$d gift-dill}
{$e gift-eyre}
{$f gift-ford}
{$g gift-gall}
==
--