shrub/arvo/zuse.hoon

3164 lines
118 KiB
Plaintext
Raw Normal View History

2014-04-10 04:06:33 +04:00
::
2014-08-05 05:19:15 +04:00
:: zuse (3), standard library (tang)
2013-09-29 00:21:18 +04:00
::
2014-12-04 02:21:55 +03:00
~% %zuse + ~
2013-09-29 00:21:18 +04:00
|%
:::::::::::::::::::::::::::::::::::::::::::::::::::::: ::
:::: chapter 3b, Arvo libraries ::::
:: ::::::::::::::::::::::::::::::::::::::::::::::::::::::
:: section 3bA, lite number theory ::
::
2014-12-04 02:21:55 +03:00
++ dope
~/ %dope
|= a=@
~& [%dope-zuse (mug +>)]
:(mul a a a)
::
2013-09-29 00:21:18 +04:00
++ 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)
2013-09-29 00:21:18 +04:00
(~(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)
2014-04-10 04:28:22 +04:00
^- 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)))
--
|%
++ as
=> |%
2014-04-10 04:28:22 +04:00
++ 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
2014-04-10 00:03:02 +04:00
[~ 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)])
--
--
2014-04-10 04:28:22 +04:00
++ bruw :: create keypair
2013-09-29 00:21:18 +04:00
|= [a=@ b=@] :: width seed
2014-04-10 04:28:22 +04:00
^- acru
(pit:nu:crua a b)
2013-09-29 00:21:18 +04:00
::
2014-04-10 04:28:22 +04:00
++ haul :: activate public key
2013-09-29 00:21:18 +04:00
|= a=pass
2014-04-10 04:28:22 +04:00
^- acru
2013-09-29 00:21:18 +04:00
=+ [mag=(end 3 1 a) bod=(rsh 3 1 a)]
?> =('a' mag)
2014-04-10 04:28:22 +04:00
(com:nu:crua bod)
2013-09-29 00:21:18 +04:00
::
2014-04-10 04:28:22 +04:00
++ weur :: activate secret key
2013-09-29 00:21:18 +04:00
|= a=ring
2014-04-10 04:28:22 +04:00
^- acru
2013-09-29 00:21:18 +04:00
=+ [mag=(end 3 1 a) bod=(rsh 3 1 a)]
?> =('A' mag)
2014-04-10 04:28:22 +04:00
(nol:nu:crua bod)
2013-09-29 00:21:18 +04:00
::
2014-04-10 04:28:22 +04:00
++ trua :: test rsa
2013-09-29 00:21:18 +04:00
|= msg=@tas
^- @
2014-04-10 04:28:22 +04:00
=+ 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 !!)
2013-09-29 00:21:18 +04:00
=+ key=(shax (shax (shax msg)))
=+ sax=(seal:as.ali pub:ex.bob key msg)
=+ tin=(tear:as.bob pub:ex.ali sax)
2013-09-29 00:21:18 +04:00
?. &(?=(^ tin) =(key p.u.tin) =(msg q.u.tin))
~|(%test-fail-seal !!)
msg
::
++ crub :: cryptosuite B (Ed)
2014-05-19 21:48:10 +04:00
^- acru
=| [puc=pass sed=ring]
=> |%
++ 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] ~)
--
|%
++ as
=> |%
++ haul :: revealing haul
|= a=pass
!!
--
^?
|% ++ seal
|= [a=pass b=@ c=@]
^- @
!!
++ sign
|= [a=@ b=@] ^- @
!!
++ sure
|= [a=@ b=@]
^- (unit ,@)
!!
++ tear
|= [a=pass b=@]
^- (unit ,[p=@ q=@])
!!
--
::
++ de
|+ [key=@ cep=@] ^- (unit ,@)
!!
::
++ dy
|+ [a=@ b=@] ^- @
!!
++ en
|+ [key=@ msg=@] ^- @ux
!!
::
++ ex ^?
|% ++ fig ^- @uvH (shaf %bfig puc)
++ pac ^- @uvG (end 6 1 (shaf %acod sec))
++ pub ^- pass (cat 3 'b' puc)
++ sec ^- ring sed
--
::
++ nu
^?
|% ++ com
|= a=@
^+ ^?(..nu)
2014-05-21 02:51:07 +04:00
..nu(sed ~, puc a)
2014-05-19 21:48:10 +04:00
::
++ pit
|= [a=@ b=@]
^+ ^?(..nu)
2014-05-21 02:51:07 +04:00
..nu(sed b, puc (puck:ed b))
2014-05-19 21:48:10 +04:00
::
++ nol
|= a=@
^+ ^?(..nu)
2014-05-21 02:51:07 +04:00
..nu(sed a, puc (puck:ed a))
2014-05-19 21:48:10 +04:00
--
--
++ 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
^- @
2014-05-19 21:48:10 +04:00
=+ ali=(brew 1.024 (shax 'ali'))
=+ bob=(brew 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
::
2014-06-01 03:49:48 +04:00
++ hmac :: HMAC-SHA1
|= [key=@ mes=@]
2014-08-08 02:37:25 +04:00
=+ 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))))
::
2013-09-29 00:21:18 +04:00
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
2014-04-19 07:27:19 +04:00
:: 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)))
2014-04-19 07:27:19 +04:00
::
++ 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)))
::
2014-04-19 07:27:19 +04:00
++ 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) " "
2014-04-19 07:27:19 +04:00
`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)
2014-04-19 07:27:19 +04:00
" " "+0000"
==
::
2014-12-12 01:46:17 +03:00
++ 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)
2014-04-19 07:27:19 +04:00
::
++ yu :: UTC format constants
|%
2014-04-19 07:27:19 +04:00
++ 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"
2014-04-19 07:27:19 +04:00
==
::
++ les ^- (list ,@da)
:~ ~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
2014-04-19 07:27:19 +04:00
==
++ lef ^- (list ,@da)
:~ ~2012.6.30..23.59.59 ~2008.12.31..23.59.58
2014-04-19 07:27:19 +04:00
~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
2014-04-19 07:27:19 +04:00
~1972.6.30..23.59.35
==
--
::
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
:: section 3bD, JSON and XML ::
2013-09-29 00:21:18 +04:00
::
++ moon :: mime type to text
2014-03-13 05:04:58 +04:00
|= myn=mite
%- crip
2013-09-29 00:21:18 +04:00
|- ^- tape
?~ myn ~
2013-12-24 00:49:15 +04:00
?: =(~ t.myn) (trip i.myn)
(weld (trip i.myn) `tape`['/' $(myn t.myn)])
2014-04-15 21:32:48 +04:00
::
2014-08-14 05:46:10 +04:00
++ perk :: pars cube fork
|* a=(pole ,@tas)
?~ a fail
;~ pose
(cold -.a (jest -.a))
$(a +.a)
==
::
++ poja :: parse JSON
2015-01-27 02:24:31 +03:00
=< |=(a=cord `(unit json)`(rush a apex))
2014-01-22 03:14:05 +04:00
|%
++ apex :: JSON value
2014-07-12 22:24:52 +04:00
%+ knee *json |. ~+
2014-12-12 01:46:17 +03:00
%+ ifix [spac spac]
;~ pose
(cold ~ (jest 'null'))
(stag %b bool)
(stag %s stri)
(cook |=(s=tape [%n p=(rap 3 s)]) numb)
abox
obox
2014-02-12 14:53:12 +04:00
==
++ tops ;~(pose abox obox) :: JSON strict
2014-02-12 14:53:12 +04:00
:: JSON arrays
++ abox (stag %a (ifix [sel (ws ser)] (more (ws com) apex)))
2014-02-12 14:53:12 +04:00
:: JSON objects
++ pair ;~(plug ;~(sfix (ws stri) (ws col)) apex)
2014-02-12 14:53:12 +04:00
++ obje (ifix [(ws kel) (ws ker)] (more (ws com) pair))
2014-10-28 21:55:44 +03:00
++ obox (stag %o (cook mo obje))
2014-02-12 14:53:12 +04:00
:: JSON booleans
++ bool ;~(pose (cold & (jest 'true')) (cold | (jest 'false')))
:: JSON strings
2014-10-28 21:55:44 +03:00
++ stri (cook crip (ifix [doq doq] (star jcha)))
++ jcha ;~(pose ;~(less doq bas prn) esca) :: character in string
2014-02-12 14:53:12 +04:00
++ esca :: Escaped character
;~ pfix bas
;~ pose
2014-10-28 21:55:44 +03:00
doq fas soq bas
(sear ~(get by `(map ,@t ,@)`(mo b/8 t/9 n/10 f/12 r/13 ~)) low)
;~(pfix (just 'u') (cook tuft qix:ab)) :: 4-digit hex to UTF-8
2014-01-22 03:14:05 +04:00
==
2014-02-12 14:53:12 +04:00
==
:: JSON numbers
++ numb
;~ (comp twel)
(mayb (piec hep))
;~ pose
(piec (just '0'))
2014-10-28 21:55:44 +03:00
;~(plug (shim '1' '9') digs)
2014-01-22 03:14:05 +04:00
==
2014-02-12 14:53:12 +04:00
(mayb frac)
(mayb expo)
==
++ digs (star (shim '0' '9'))
2014-10-28 21:55:44 +03:00
++ expo :: Exponent part
2014-02-12 14:53:12 +04:00
;~ (comp twel)
(piec (mask "eE"))
(mayb (piec (mask "+-")))
digs
==
2014-10-28 21:55:44 +03:00
++ frac ;~(plug dot digs) :: Fractional part
2014-02-12 14:53:12 +04:00
:: 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
2014-04-15 21:32:48 +04:00
|* bus=_rule
(cook |=(a=@ [a ~]) bus)
--
2013-09-29 00:21:18 +04:00
::
++ pojo :: print json
2014-07-12 22:24:52 +04:00
|= val=json
2013-09-29 00:21:18 +04:00
^- tape
?~ val "null"
?- -.val
%a
;: weld
"["
=| rez=tape
|- ^+ rez
?~ p.val rez
$(p.val t.p.val, rez :(weld rez ^$(val i.p.val) ?~(t.p.val ~ ",")))
"]"
==
::
%b ?:(p.val "true" "false")
%n (trip p.val)
2014-02-12 14:53:12 +04:00
%s
2014-07-06 01:26:35 +04:00
;: welp
2014-02-12 14:53:12 +04:00
"\""
%+ reel
(turn (trip p.val) jesc)
2014-07-06 01:26:35 +04:00
|=([p=tape q=tape] (welp +<))
2014-02-12 14:53:12 +04:00
"\""
==
2013-09-29 00:21:18 +04:00
%o
2014-07-06 01:26:35 +04:00
;: welp
2013-09-29 00:21:18 +04:00
"\{"
=+ viz=(~(tap by p.val) ~)
=| rez=tape
|- ^+ rez
?~ viz rez
%= $
viz t.viz
rez
2014-07-06 01:26:35 +04:00
:(welp rez "\"" (trip p.i.viz) "\":" ^$(val q.i.viz) ?~(t.viz ~ ","))
2013-09-29 00:21:18 +04:00
==
"}"
==
==
2014-04-15 21:32:48 +04:00
::
2014-10-30 23:33:15 +03:00
::
++ poxo :: node to tape
=< |=(a=manx `tape`(apex a ~))
2014-11-05 00:21:51 +03:00
|_ unq=_`?`|
2014-10-31 06:13:40 +03:00
++ apex :: top level
2014-10-30 23:33:15 +03:00
|= [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
2014-12-04 07:58:49 +03:00
=- ?~(att rez [' ' (attr att rez)])
^- rez=tape
::?~ c.mex
:: [' ' '/' '>' rez]
:- '>'
(many c.mex :(weld "</" tam ">" rez))
:: ::
2014-10-30 23:33:15 +03:00
++ 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]
==
==
::
++ name :: name to tape
|= man=mane ^- tape
?@ man (trip man)
(weld (trip -.man) `tape`[':' (trip +.man)])
::
++ many :: nodelist to tape
|= [lix=(list manx) rez=tape]
|- ^- tape
?~ lix rez
(apex i.lix $(lix t.lix))
--
::
++ poxa :: xml parser
=< |=(a=cord (rush a apex))
2014-12-09 01:51:27 +03:00
|_ ent=_`(map term ,@t)`[[%apos '\''] ~ ~]
2014-10-30 23:33:15 +03:00
++ 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])))
2014-12-04 07:58:49 +03:00
;~(plug head many tail)
2014-10-30 23:33:15 +03:00
empt
==
2014-12-04 07:58:49 +03:00
::
2014-10-30 23:33:15 +03:00
++ attr :: attributes
%+ knee *mart |. ~+
%- star
;~ pfix (plus whit)
;~ plug
;~(sfix name tis)
;~ pose
(ifix [doq doq] (star ;~(less doq escp)))
(ifix [soq soq] (star ;~(less soq escp)))
==
==
==
::
++ chrd :: character data
%+ cook |=(a=tape ^-(mars :/(a)))
2014-12-09 01:51:27 +03:00
(plus ;~(less doq ;~(pose (just `@`10) escp)))
2014-10-30 23:33:15 +03:00
::
++ comt :: comments
=- (ifix [(jest '<!--') (jest '-->')] (star -))
;~ pose
;~(less hep prn)
whit
;~(less (jest '-->') hep)
==
2014-12-09 01:51:27 +03:00
::
++ escp ;~(pose ;~(less gal gar pam prn) enty)
++ enty :: entity
%+ ifix pam^sem
2014-10-30 23:33:15 +03:00
;~ pose
2014-12-09 01:51:27 +03:00
=+ def=`_ent`(mo [%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)))
2014-10-30 23:33:15 +03:00
==
2014-12-09 01:51:27 +03:00
::
2014-10-30 23:33:15 +03:00
++ empt :: self-closing tag
%+ ifix [gal (jest '/>')]
;~(plug ;~(plug name attr) (cold ~ (star whit)))
::
++ head :: opening tag
(ifix [gal gar] ;~(plug name attr))
::
2014-12-04 07:58:49 +03:00
++ many
(more (star comt) ;~(pose apex chrd))
::
2014-10-30 23:33:15 +03:00
++ 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
--
::
2014-07-21 07:15:02 +04:00
++ 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
2014-07-03 06:56:33 +04:00
|* wil=(pole fist)
|= jon=json
2014-07-09 11:37:47 +04:00
?. ?=([%a *] jon) ~
=+ raw=((at-raw wil) p.jon)
2014-07-03 06:56:33 +04:00
?.((za raw) ~ (some (zp raw)))
::
++ at-raw :: array as tuple
|* wil=(pole fist)
2014-07-09 11:37:47 +04:00
|= jol=(list json)
?~ wil ~
2014-07-09 11:37:47 +04:00
:- ?~(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]))
::
2014-12-06 04:18:31 +03:00
++ 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) ~
2014-12-12 01:46:17 +03:00
(bind (stud p.jon) |=(a=date (year a)))
::
++ di :: millisecond date
%- cu :_ ni
|= a=@u ^- @da
(add ~1970.1.1 (div (mul ~s1 a) 1.000))
::
++ mu :: true unit
|* wit=fist
|= jon=json
2014-10-29 04:31:16 +03:00
?~(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
2014-07-08 22:38:07 +04:00
|* wer=(pole ,[cord fist])
|= jon=json
?. ?=([%o [@ *] ~ ~] jon) ~
|-
?~ wer ~
2014-07-08 22:38:07 +04:00
?: =(-.-.wer p.n.p.jon)
((pe -.-.wer +.-.wer) q.n.p.jon)
((of +.wer) jon)
::
++ ot :: object as tuple
2014-07-08 22:38:07 +04:00
|* wer=(pole ,[cord fist])
2014-07-03 06:56:33 +04:00
|= jon=json
2014-07-09 11:37:47 +04:00
?. ?=([%o *] jon) ~
=+ raw=((ot-raw wer) p.jon)
2014-07-03 06:56:33 +04:00
?.((za raw) ~ (some (zp raw)))
::
++ ot-raw :: object as tuple
2014-07-08 22:38:07 +04:00
|* wer=(pole ,[cord fist])
2014-07-09 11:37:47 +04:00
|= jom=(map ,@t json)
?~ wer ~
2014-07-09 11:37:47 +04:00
=+ 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))
::
2015-01-08 04:49:57 +03:00
++ op :: parse keys of map
|* [fel=_rule wit=fist]
%+ cu mo
%- 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 |*(a=* [pre a]) 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
2014-07-03 06:56:33 +04:00
++ 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 ~
2014-07-16 03:07:39 +04:00
[i=u:+.i.lut t=$(lut t.lut)]
::
2014-07-03 06:56:33 +04:00
++ zp :: unit tuple
|* but=(pole (unit))
?~ but !!
?~ +.but
u:->.but
[u:->.but (zp +.but)]
::
++ zm :: collapse unit map
|* lum=(map term (unit))
2015-01-09 02:56:48 +03:00
?: (~(rep by lum) |=([[@ a=(unit)] b=_|] |(b ?=(~ a))))
~
(some (~(run by lum) need))
--
::
++ joba :: object from k-v pair
2014-07-12 22:24:52 +04:00
|= [p=@t q=json]
2014-04-15 21:32:48 +04:00
^- json
[%o [[p q] ~ ~]]
::
++ jobe :: object from k-v list
2014-07-12 22:24:52 +04:00
|= a=(list ,[p=@t q=json])
2014-04-15 21:32:48 +04:00
^- json
2014-07-12 22:24:52 +04:00
[%o (~(gas by *(map ,@t json)) a)]
2014-04-15 21:32:48 +04:00
::
++ jape :: string from tape
2014-04-16 04:49:11 +04:00
|= a=tape
2014-07-12 22:24:52 +04:00
^- json
2014-04-16 04:49:11 +04:00
[%s (crip a)]
::
++ jone :: number from unsigned
|= a=@u
2014-07-12 22:24:52 +04:00
^- json
2014-04-16 04:49:11 +04:00
:- %n
?: =(0 a) '0'
(crip (flop |-(^-(tape ?:(=(0 a) ~ [(add '0' (mod a 10)) $(a (div a 10))])))))
::
2015-01-11 11:00:36 +03:00
++ jode :: ms timestamp
|= a=time
=- (jone (div (mul - 1.000) ~s1))
(add (div ~s1 2.000) (sub a ~1970.1.1))
::
2014-04-16 04:49:11 +04:00
++ jesc
|= a=@ ^- tape
2014-08-11 22:51:48 +04:00
?+ a [a ~]
10 "\\n"
34 "\\\""
92 "\\\\"
==
2014-03-23 01:42:25 +04:00
::
2014-08-13 03:16:30 +04:00
++ scanf :: formatted scan
|* [tape (pole ,_:/(*$&(_rule tape)))]
=> .(+< [a b]=+<)
(scan a (parsf b))
++ parsf :: make parser from:
2014-08-18 03:43:33 +04:00
|^ |* a=(pole ,_:/(*$&(_rule tape))) :: ;"chars{rule}chars"
2014-08-13 03:16:30 +04:00
%- cook :_ (bill (norm a))
|* (list)
?~ +< ~
?~ t i
[i $(+< t)]
2014-08-18 03:43:33 +04:00
::
2014-08-13 03:16:30 +04:00
:: .= (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]
2014-08-18 03:43:33 +04:00
::
2014-08-13 03:16:30 +04:00
:: .= (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))
--
::
2014-03-23 01:42:25 +04:00
++ taco :: atom to octstream
|= tam=@ ^- octs
[(met 3 tam) tam]
2013-09-29 00:21:18 +04:00
::
++ tact :: tape to octstream
|= tep=tape ^- octs
2014-03-23 01:42:25 +04:00
(taco (rap 3 tep))
2013-09-29 00:21:18 +04:00
::
2014-03-12 23:50:39 +04:00
++ tell :: wall to octstream
|= wol=wall ^- octs
=+ buf=(rap 3 (turn wol |=(a=tape (crip (weld a `tape`[`@`10 ~])))))
[(met 3 buf) buf]
::
2014-07-16 09:47:43 +04:00
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
2014-04-19 07:27:19 +04:00
:: section 3bE, tree sync ::
2013-09-29 00:21:18 +04:00
::
2014-07-10 00:56:23 +04:00
::
2014-09-09 04:21:40 +04:00
++ invert-miso :: invert miso
|= mis=miso
?- -.mis
%del [%ins p.mis]
%ins [%del p.mis]
%mut [%mut (limp p.mis)]
2013-09-29 00:21:18 +04:00
==
::
++ cosh :: locally rehash
2014-09-09 22:53:27 +04:00
|= ank=ankh :: NB v/unix.c
ank(p rehash:(zu ank))
2013-09-29 00:21:18 +04:00
::
++ cost :: new external patch
2014-09-09 22:53:27 +04:00
|= [bus=ankh ank=ankh] :: NB v/unix.c
2013-09-29 00:21:18 +04:00
^- soba
:- [p.ank p.bus]
%- flop
2014-09-09 22:53:27 +04:00
myz:(change-tree:(zu ank) %c bus)
2013-09-29 00:21:18 +04:00
::
++ loth
2014-08-07 22:06:53 +04:00
|= pat=(map path ,*)
^- (set path)
2014-08-07 22:06:53 +04:00
%+ roll (~(tap by pat) ~)
|= [[p=path *] q=(set path)]
%. p %~ put in q
::
++ luth
|= [p=(map path ,*) q=(map path ,*)] :: merge keysets
2014-07-25 19:38:13 +04:00
^- (set path)
2014-08-07 22:06:53 +04:00
(~(uni in (loth p)) (loth q))
::
2014-09-09 04:21:40 +04:00
++ blob-to-lobe :: p.blob
2014-07-22 22:56:04 +04:00
|= p=blob
^- lobe
?- -.p
%delta p.p
%direct p.p
%indirect p.p
==
::
2014-11-01 01:36:01 +03:00
++ ze !:
2014-07-22 22:56:04 +04:00
|_ [lim=@da dome rang]
2014-09-09 22:53:27 +04:00
++ aeon-to-tako ~(got by hit)
2014-09-17 04:29:12 +04:00
++ aeon-to-yaki (cork aeon-to-tako tako-to-yaki)
2014-09-09 04:21:40 +04:00
++ make-yaki :: make yaki
2014-07-17 22:27:14 +04:00
|= [p=(list tako) q=(map path lobe) t=@da]
^- yaki
2014-08-01 20:40:19 +04:00
=+ ^= has
%^ cat 7 (sham [%yaki (roll p add) q t])
(sham [%tako (roll p add) q t])
[p q has t]
2014-07-17 22:27:14 +04:00
::
2014-09-09 22:53:27 +04:00
++ tako-to-yaki ~(got by hut) :: grab yaki
2014-09-09 04:21:40 +04:00
++ lobe-to-blob ~(got by lat) :: grab blob
++ lobe-to-noun :: grab blob
2014-07-25 19:38:13 +04:00
|= p=lobe :: ^- *
2014-09-09 04:21:40 +04:00
%- blob-to-noun
(lobe-to-blob p)
2014-07-17 22:27:14 +04:00
::
2014-09-09 22:53:27 +04:00
++ make-direct :: make blob
|= [p=* q=umph]
^- blob
[%direct (mug p) p q]
2014-07-17 22:27:14 +04:00
::
2014-09-09 04:21:40 +04:00
++ make-delta :: make blob delta
2014-07-17 22:27:14 +04:00
|= [p=lobe q=udon]
^- blob
=+ t=[%delta 0 p q]
2014-09-09 04:21:40 +04:00
=+ z=(blob-to-noun t)
2014-08-01 20:40:19 +04:00
=+ ^= has
%^ cat 7 (sham [%blob z])
(sham [%lobe z])
[%delta has p q]
2014-07-17 22:27:14 +04:00
::
2014-09-09 04:21:40 +04:00
++ blob-to-umph :: blob umph [prep]
2014-07-17 22:27:14 +04:00
|= p=blob :: used in merge
^- umph
?- -.p
%delta p.r.p
%direct r.p
%indirect p.r.p
==
::
2014-09-09 22:53:27 +04:00
++ blob-to-noun :: grab blob
|= p=blob
?- -.p
%delta (lump r.p (lobe-to-noun q.p))
%direct q.p
%indirect q.p
==
2014-07-25 21:44:06 +04:00
::
::
::
2014-09-09 04:21:40 +04:00
++ diff-yakis :: fundamental diff
2014-07-17 22:27:14 +04:00
|= [p=yaki q=yaki]
^- (map path miso)
2014-07-25 19:38:13 +04:00
%+ roll (~(tap in (luth q.p q.q)) ~)
2014-07-17 22:27:14 +04:00
|= [pat=path yeb=(map path miso)]
=+ leb=(~(get by q.p) pat)
=+ lob=(~(get by q.q) pat)
2014-09-09 04:21:40 +04:00
?~ leb (~(put by yeb) pat [%ins (lobe-to-noun (need lob))])
?~ lob (~(put by yeb) pat [%del (lobe-to-noun (need leb))])
2014-08-01 19:45:29 +04:00
?: =(u.leb u.lob) yeb
2014-09-09 04:21:40 +04:00
=+ veq=(lobe-to-blob u.leb)
=+ voq=(lobe-to-blob u.lob)
2014-07-17 22:27:14 +04:00
%+ ~(put by yeb) pat
2014-08-01 19:45:29 +04:00
:- %mut
2014-09-09 04:21:40 +04:00
?: &(?=(%delta -.voq) =(u.leb q.voq)) :: avoid diff
2014-08-01 19:45:29 +04:00
r.voq
2014-09-09 04:21:40 +04:00
=+ zeq=(blob-to-noun veq)
=+ zoq=(blob-to-noun voq)
((diff (blob-to-umph (lobe-to-blob u.leb))) zeq zoq)
2014-07-17 22:27:14 +04:00
::
2014-09-09 04:21:40 +04:00
++ lobes-at-path :: lobes-at-path:ze
2014-09-17 04:29:12 +04:00
|= [yon=aeon pax=path] :: data at path
^- (map path lobe)
2014-09-17 04:29:12 +04:00
?: =(0 yon) ~
%- mo
%+ skim
%. ~
%~ tap by
=< q
2014-09-17 04:29:12 +04:00
%- aeon-to-yaki
yon
|= [p=path q=lobe]
?| ?=(~ pax)
?& !?=(~ p)
=(-.pax -.p)
$(p +.p, pax +.pax)
== ==
2014-07-25 21:44:06 +04:00
::
2014-09-09 04:21:40 +04:00
++ case-to-aeon :: case-to-aeon:ze
|= lok=case :: act count through
2014-09-09 04:21:40 +04:00
^- (unit aeon)
2013-09-29 00:21:18 +04:00
?- -.lok
%da
?: (gth p.lok lim) ~
2014-09-09 04:21:40 +04:00
|- ^- (unit aeon)
?: =(0 let) [~ 0] :: avoid underflow
2014-07-22 17:28:35 +04:00
?: %+ gte p.lok
=< t
2014-09-17 04:29:12 +04:00
%- aeon-to-yaki
2014-07-22 17:28:35 +04:00
let
[~ let]
$(let (dec let))
::
2013-09-29 00:21:18 +04:00
%tas (~(get by lab) p.lok)
%ud ?:((gth p.lok let) ~ [~ p.lok])
==
::
2014-09-09 04:21:40 +04:00
++ as-arch :: as-arch:ze
2013-09-29 00:21:18 +04:00
^- arch :: arch report
:+ p.ank
?~(q.ank ~ [~ p.u.q.ank])
|- ^- (map ,@ta ,~)
?~ r.ank ~
[[p.n.r.ank ~] $(r.ank l.r.ank) $(r.ank r.r.ank)]
::
2014-09-09 04:21:40 +04:00
++ reachable-takos :: reachable
|= p=tako :: XX slow
2014-07-18 00:04:18 +04:00
^- (set tako)
2014-09-09 04:21:40 +04:00
=+ y=(tako-to-yaki p)
2014-10-31 06:13:40 +03:00
=+ t=(~(put in *(set tako)) p)
2014-07-18 00:04:18 +04:00
%+ roll p.y
|= [q=tako s=_t]
2014-09-09 04:21:40 +04:00
?: (~(has in s) q) :: already done
s :: hence skip
(~(uni in s) ^$(p q)) :: otherwise traverse
2014-07-18 00:04:18 +04:00
::
2014-09-09 22:53:27 +04:00
++ new-lobes :: object hash set
2014-09-09 04:21:40 +04:00
|= [b=(set lobe) a=(set tako)] :: that aren't in b
2014-07-18 00:04:18 +04:00
^- (set lobe)
%+ roll (~(tap in a) ~)
|= [tak=tako bar=(set lobe)]
^- (set lobe)
2014-09-09 04:21:40 +04:00
=+ yak=(tako-to-yaki tak)
2014-07-18 00:04:18 +04:00
%+ roll (~(tap by q.yak) ~)
2014-07-24 19:11:40 +04:00
|= [[path lob=lobe] far=_bar]
2014-07-18 00:04:18 +04:00
^- (set lobe)
2014-09-09 04:21:40 +04:00
?~ (~(has in b) lob) :: don't need
2014-07-24 23:21:58 +04:00
far
2014-09-09 04:21:40 +04:00
=+ gar=(lobe-to-blob lob)
2014-07-18 00:04:18 +04:00
?- -.gar
2014-07-24 19:11:40 +04:00
%direct (~(put in far) lob)
2014-07-18 00:04:18 +04:00
%delta (~(put in $(lob q.gar)) lob)
%indirect (~(put in $(lob s.gar)) lob)
==
2014-09-10 04:31:17 +04:00
::
2014-09-09 22:53:27 +04:00
++ new-lobes-takos :: garg & repack
2014-07-18 00:04:18 +04:00
|= [b=(set lobe) a=(set tako)]
^- [(set tako) (set lobe)]
2014-09-09 22:53:27 +04:00
[a (new-lobes b a)]
2014-07-18 00:04:18 +04:00
::
2014-09-09 04:21:40 +04:00
++ reachable-between-takos
|= [a=(unit tako) b=tako] :: pack a through b
2014-07-18 00:04:18 +04:00
^- [(set tako) (set lobe)]
2014-07-24 19:11:40 +04:00
=+ ^= sar
?~ a ~
2014-09-09 04:21:40 +04:00
(reachable-takos r:(tako-to-yaki u.a))
=+ yak=`yaki`(tako-to-yaki b)
2014-09-09 22:53:27 +04:00
%+ new-lobes-takos (new-lobes ~ sar) :: get lobes
2014-09-09 04:21:40 +04:00
|- ^- (set tako) :: walk onto sar
2014-07-18 00:04:18 +04:00
?: (~(has in sar) r.yak)
~
2014-07-24 19:11:40 +04:00
=+ ber=`(set tako)`(~(put in `(set tako)`~) `tako`r.yak)
%- ~(uni in ber)
^- (set tako)
2014-07-18 00:04:18 +04:00
%+ roll p.yak
|= [yek=tako bar=(set tako)]
2014-07-24 19:11:40 +04:00
^- (set tako)
2014-09-09 04:21:40 +04:00
?: (~(has in bar) yek) :: save some time
2014-07-18 00:04:18 +04:00
bar
%- ~(uni in bar)
2014-09-09 04:21:40 +04:00
^$(yak (tako-to-yaki yek))
::
++ takos-to-yakis :: trivial
|= a=(set tako)
^- (set yaki)
(sa (turn (~(tap by a)) tako-to-yaki))
::
++ lobes-to-blobs :: trivial
|= a=(set lobe)
^- (set blob)
(sa (turn (~(tap by a)) lobe-to-blob))
::
++ make-nako :: gack a through b
|= [a=aeon b=aeon]
^- [(map aeon tako) aeon (set yaki) (set blob)]
2014-07-24 19:11:40 +04:00
:_ :- b
2014-09-09 04:21:40 +04:00
=- [(takos-to-yakis -<) (lobes-to-blobs ->)]
%+ reachable-between-takos
(~(get by hit) a) :: if a not found, a=0
(aeon-to-tako b)
^- (map aeon tako)
2014-07-22 17:28:35 +04:00
%- mo %+ skim (~(tap by hit) ~)
2014-09-09 04:21:40 +04:00
|= [p=aeon *]
2014-07-24 19:11:40 +04:00
&((gth p a) (lte p b))
2014-07-22 17:28:35 +04:00
::
2014-07-01 06:28:47 +04:00
::::::::::::::::::::::::::::::::::::::::::::::::::::::::
2014-09-09 04:21:40 +04:00
++ query :: query:ze
2014-07-24 19:11:40 +04:00
|= ren=?(%u %v %x %y %z) :: endpoint query
2013-09-29 00:21:18 +04:00
^- (unit ,*)
?- ren
2014-09-09 04:21:40 +04:00
%u [~ `rang`+<+>.query]
%v [~ `dome`+<+<.query]
2013-09-29 00:21:18 +04:00
%x ?~(q.ank ~ [~ q.u.q.ank])
2014-09-09 04:21:40 +04:00
%y [~ as-arch]
%z [~ ank]
2013-09-29 00:21:18 +04:00
==
::
2014-09-09 04:21:40 +04:00
++ rewind :: rewind:ze
2014-09-17 04:29:12 +04:00
|= yon=aeon :: rewind to aeon
2013-09-29 00:21:18 +04:00
^+ +>
2014-09-17 04:29:12 +04:00
?: =(let yon) +>
?: (gth yon let) !! :: don't have version
+>(ank (checkout-ankh q:(aeon-to-yaki yon)), let yon)
::
::::
2014-09-09 04:21:40 +04:00
++ update-lat :: update-lat:ze
|= [lag=(map path blob) sta=(map lobe blob)] :: fix lat
^- [(map lobe blob) (map path lobe)]
%+ roll (~(tap by lag) ~)
|= [[pat=path bar=blob] [lut=_sta gar=(map path lobe)]]
?~ (~(has by lut) p.bar)
[lut (~(put by gar) pat p.bar)]
:- (~(put by lut) p.bar bar)
(~(put by gar) pat p.bar)
::
++ apply-changes :: apply-changes:ze
|= lar=(list ,[p=path q=miso]) :: store changes
^- (map path blob)
2014-07-22 17:28:35 +04:00
=+ ^= hat :: current state
2014-07-24 19:11:40 +04:00
?: =(let 0) :: initial commit
~ :: has nothing
2014-07-22 17:28:35 +04:00
=< q
2014-09-17 04:29:12 +04:00
%- aeon-to-yaki
2014-07-22 17:28:35 +04:00
let
2014-09-16 19:25:06 +04:00
=- =+ sar=(sa (turn lar |=([p=path *] p))) :: changed paths
%+ roll (~(tap by hat) ~) :: find unchanged
2014-07-17 22:27:14 +04:00
|= [[pat=path gar=lobe] bat=_bar]
?: (~(has in sar) pat) :: has update
bat
(~(put by bat) pat (lobe-to-blob gar)) :: use original
2014-09-16 19:25:06 +04:00
^= bar ^- (map path blob)
%+ roll lar
|= [[pat=path mys=miso] bar=(map path blob)]
^+ bar
?- -.mys
%ins :: insert if not exist
?: (~(has by bar) pat) !! ::
?: (~(has by hat) pat) !! ::
2014-09-09 04:21:40 +04:00
(~(put by bar) pat (make-direct p.mys %c)) :: TODO content type?
%del :: delete if exists
?. |((~(has by hat) pat) (~(has by bar) pat)) !!
(~(del by bar) pat)
%mut :: mutate, must exist
=+ ber=(~(get by bar) pat)
?~ ber
=+ har=(~(get by hat) pat)
?~ har !!
%+ ~(put by bar) pat
2014-09-09 04:21:40 +04:00
(make-delta u.har p.mys)
2014-07-17 22:27:14 +04:00
%+ ~(put by bar) pat
2014-09-09 04:21:40 +04:00
(make-delta p.u.ber p.mys)
==
2014-09-09 04:21:40 +04:00
++ checkout-ankh :: checkout-ankh:ze
2014-07-17 22:27:14 +04:00
|= hat=(map path lobe) :: checkout commit
^- ankh
2014-08-05 18:10:15 +04:00
%- cosh
%+ roll (~(tap by hat) ~)
2014-07-17 22:27:14 +04:00
|= [[pat=path bar=lobe] ank=ankh]
^- ankh
2014-08-05 18:10:15 +04:00
%- cosh
2014-09-03 23:56:16 +04:00
?~ pat
2014-09-09 04:21:40 +04:00
=+ zar=(lobe-to-noun bar)
2014-09-03 23:56:16 +04:00
ank(q [~ (sham zar) zar])
=+ nak=(~(get by r.ank) i.pat)
%= ank
r %+ ~(put by r.ank) i.pat
2014-10-31 06:13:40 +03:00
$(pat t.pat, ank (fall nak *ankh))
==
::
2014-09-09 04:21:40 +04:00
++ forge-yaki :: forge-yaki:ze
2014-07-24 19:11:40 +04:00
|= [wen=@da par=(unit tako) lem=soba] :: forge yaki
=+ ^= per
?~ par ~
~[u.par]
2014-09-09 04:21:40 +04:00
=+ gar=(update-lat (apply-changes q.lem) lat)
:- %^ make-yaki per +.gar wen :: from existing diff
2014-07-17 22:27:14 +04:00
-.gar :: fix lat
::
2014-09-09 04:21:40 +04:00
++ forge-nori :: forge-nori:ze
|= yak=yaki :: forge nori (ugly op)
^- nori :: basically zerg w/ nori
?~ p.yak !! :: no parent -> can't diff
2014-09-09 04:21:40 +04:00
:+ %& *cart :: diff w/ 1st parent
(~(tap by (diff-yakis (tako-to-yaki i.p.yak) yak)) ~)
::
2014-08-06 21:31:42 +04:00
:: graph algorithms (bottleneck)
2014-07-24 20:13:36 +04:00
::
2014-09-09 04:21:40 +04:00
++ reduce-merge-points :: reduce merge points
2014-08-01 20:21:26 +04:00
|= unk=(set yaki) :: maybe need jet
=| gud=(set yaki)
=+ ^= zar
^- (map tako (set tako))
%+ roll (~(tap in unk) ~)
|= [yak=yaki qar=(map tako (set tako))]
2014-09-09 04:21:40 +04:00
(~(put by qar) r.yak (reachable-takos r.yak))
2014-08-01 20:21:26 +04:00
|-
2014-07-24 23:21:58 +04:00
^- (set yaki)
?~ unk gud
=+ tek=`yaki`n.unk
=+ bun=(~(del in `(set yaki)`unk) tek)
?: %+ roll (~(tap by (~(uni in gud) bun)) ~) :: only good + unknown
|= [tak=yaki god=?]
^- ?
?. god god
2014-08-01 20:21:26 +04:00
(~(has in (~(got by zar) r.tak)) tek)
2014-07-24 23:21:58 +04:00
$(gud (~(put in gud) tek), unk bun)
$(unk bun)
::
2014-09-09 04:21:40 +04:00
++ future-find-merge-points :: merge points fast
2014-08-06 21:31:42 +04:00
|= [p=yaki q=yaki] :: (future zeal)
^- (set yaki) :: zear still uses zule
2014-09-09 04:21:40 +04:00
%- reduce-merge-points :: this is test-only
2014-10-31 06:13:40 +03:00
=+ s=(~(put in *(set tako)) r.p) :: not actually used
=+ t=(~(put in *(set tako)) t.p) :: but might be active
2014-08-06 21:31:42 +04:00
=| u=(set yaki) :: eventually
|- ^- (set yaki)
=+ v=(~(int in s) t) :: found common
=+ ^= qez :: drop common
^- [s=(set tako) t=(set tako)]
%+ roll (~(tap in v) ~)
|= [tak=tako bar=_s zar=_t]
[(~(del in bar) tak) (~(del in zar) tak)]
?: &(=(~ s.qez) =(~ s.qez))
2014-09-09 04:21:40 +04:00
(~(uni in u) (takos-to-yakis v))
2014-09-09 22:53:27 +04:00
%= $
u (~(uni in u) (takos-to-yakis v))
s (add-parents s.qez)
t (add-parents t.qez)
==
2014-08-06 21:31:42 +04:00
::
2014-09-09 22:53:27 +04:00
++ add-parents :: expand set
2014-08-06 21:31:42 +04:00
|= qez=(set tako)
^- (set tako)
%+ roll (~(tap in qez) ~)
|= [tak=tako zar=(set tako)]
%- ~(uni in (~(put in zar) tak))
2014-09-09 04:21:40 +04:00
(sa p:(tako-to-yaki tak))
2014-08-06 21:31:42 +04:00
::
2014-09-09 04:21:40 +04:00
++ find-merge-points :: merge points
2014-08-01 20:21:26 +04:00
|= [p=yaki q=yaki] :: maybe need jet
2014-07-24 23:21:58 +04:00
^- (set yaki)
2014-09-09 04:21:40 +04:00
%- reduce-merge-points
=+ r=(reachable-takos r.p)
2014-07-24 20:13:36 +04:00
|- ^- (set yaki)
2014-10-31 06:13:40 +03:00
?: (~(has in r) q) (~(put in *(set yaki)) q) :: done
2014-07-24 20:13:36 +04:00
%+ roll p.q
|= [t=tako s=(set yaki)]
2014-07-24 23:21:58 +04:00
?: (~(has in r) t)
2014-09-09 04:21:40 +04:00
(~(put in s) (tako-to-yaki t)) :: found
(~(uni in s) ^$(q (tako-to-yaki t))) :: traverse
2014-07-24 20:13:36 +04:00
::
:: merge logic
::
2014-09-09 22:53:27 +04:00
++ clean :: clean
2014-07-24 20:13:36 +04:00
|= wig=(urge)
^- (urge)
?~ wig ~
?~ t.wig wig
?: ?=(%& -.i.wig)
?: ?=(%& -.i.t.wig)
$(wig [[%& (add p.i.wig p.i.t.wig)] t.t.wig])
[i.wig $(wig t.wig)]
2014-07-30 21:04:40 +04:00
?: ?=(%| -.i.t.wig)
$(wig [[%| (welp p.i.wig p.i.t.wig) (welp q.i.wig q.i.t.wig)] t.t.wig])
2014-07-24 20:13:36 +04:00
[i.wig $(wig t.wig)]
::
2014-09-09 22:53:27 +04:00
++ match-conflict :: match conflict
|= [us=[ship desk] th=[ship desk] p=(urge) q=(urge) r=(list)]
2014-07-30 21:04:40 +04:00
^- [p=[p=(list) q=(list)] q=[p=(urge) q=(urge) r=(list)]]
=+ cas=(hard (list ,@t))
=+ cat=(hard (urge ,@t))
2014-09-09 22:53:27 +04:00
=+ mar=(match-merge (cat p) (cat q) (cas r))
2014-07-30 21:04:40 +04:00
:- :- s.q.mar
2014-09-09 22:53:27 +04:00
(annotate us th p.p.mar q.p.mar s.q.mar) :: annotation
2014-07-30 21:04:40 +04:00
:- p.q.mar
:- q.q.mar
r.q.mar
2014-09-09 22:53:27 +04:00
::
++ annotate :: annotate conflict
|= [us=[ship desk] th=[ship desk] p=(list ,@t) q=(list ,@t) r=(list ,@t)]
2014-07-30 21:04:40 +04:00
^- (list ,@t)
%- zing
2014-07-30 21:42:48 +04:00
^- (list (list ,@t))
%- flop
^- (list (list ,@t))
:- :_ ~
%^ cat 3 '<<<<<<<<<<<<'
%^ cat 3 ' '
%^ cat 3 `@t`(scot %p -.us)
%^ cat 3 '/'
+.us
2014-08-07 22:06:53 +04:00
:- p
2014-07-30 21:04:40 +04:00
:- ~['------------']
:- r
:- ~['++++++++++++']
2014-08-07 22:06:53 +04:00
:- q
:- :_ ~
%^ cat 3 '>>>>>>>>>>>>'
%^ cat 3 ' '
%^ cat 3 `@t`(scot %p -.th)
%^ cat 3 '/'
+.th
2014-07-30 21:04:40 +04:00
~
::
2014-09-09 22:53:27 +04:00
++ match-merge :: match merge
2014-07-30 21:04:40 +04:00
|= [p=(urge ,@t) q=(urge ,@t) r=(list ,@t)] :: resolve conflict
=| s=[p=(list ,@t) q=(list ,@t)] :: p chunk
=| t=[p=(list ,@t) q=(list ,@t)] :: q chunk
2014-09-09 22:53:27 +04:00
|- ^- $: p=[p=(list ,@t) q=(list ,@t)]
$= q
$: p=(urge ,@t)
q=(urge ,@t)
r=(list ,@t)
s=(list ,@t)
== ==
2014-07-30 21:04:40 +04:00
?~ p [[q.s q.t] p q r p.s] :: can't be conflict
?~ q [[q.s q.t] p q r p.s] :: can't be conflict
?- -.i.p
%& ?> ?=(%| -.i.q) :: is possibly conflict
?: (gte p.i.p (lent p.i.q)) :: trivial resolve
:::- (weld p.s p.i.q) :: extend to q
2014-07-30 21:42:48 +04:00
:- :- (welp (flop (scag (lent p.i.q) r)) q.s)
(welp q.i.q q.t)
2014-07-30 21:04:40 +04:00
:- ?: =(p.i.p (lent p.i.q)) t.p
[[%& (sub p.i.p (lent p.i.q))] t.p]
:- t.q
2014-07-30 21:42:48 +04:00
:- (flop (slag (lent p.i.q) r))
(welp (flop (scag (lent p.i.q) r)) p.s)
=+ tex=(flop (scag p.i.p r))
2014-07-30 21:04:40 +04:00
?~ t.p :: extend to end
%= $
::s [(welp p.s tex) (welp q.s tex)]
p ~[[%| [tex tex]]]
::r (slag p.i.p r)
==
?> ?=(%| -.i.t.p) :: fake skip
%= $
::s [(welp p.s tex) (welp q.s tex)]
2014-07-30 21:42:48 +04:00
p [[%| [(welp p.i.t.p tex) (welp q.i.t.p tex)]] t.t.p]
2014-07-30 21:04:40 +04:00
::r (slag p.i.p r)
==
%| ?- -.i.q
%& =+ mar=$(p q, q p, s t, t s) :: swap recursion
[[q.p.mar p.p.mar] q.q.mar p.q.mar r.q.mar s.q.mar]
2014-07-30 21:42:48 +04:00
%| ?: =((lent p.i.p) (lent p.i.q)) :: perfect conflict
2014-07-30 21:04:40 +04:00
?> =(p.i.p p.i.q) :: sane conflict
2014-07-30 21:42:48 +04:00
:- :- (welp q.i.p q.s)
(welp q.i.q q.t)
2014-07-30 21:04:40 +04:00
:- t.p
:- t.q
2014-07-30 21:42:48 +04:00
:- (scag (lent p.i.p) r)
(welp (flop (scag (lent p.i.p) r)) p.s)
2014-07-30 21:04:40 +04:00
?. (lth (lent p.i.p) (lent p.i.q))
=+ mar=$(p q, q p, s t, t s) :: swap recursion
[[q.p.mar p.p.mar] q.q.mar p.q.mar r.q.mar s.q.mar]
2014-09-09 22:53:27 +04:00
?> .= p.i.p :: sane conflict
(slag (sub (lent p.i.q) (lent p.i.p)) p.i.q)
2014-07-30 21:04:40 +04:00
%= $ :: extend p
p t.p
2014-07-30 21:42:48 +04:00
p.s (welp p.i.p p.s)
q.s (welp q.i.p q.s)
p.t (welp p.i.p p.s) :: subset of q
q.t (welp q.i.q q.s) :: just consume all out
q [[%| (scag (sub (lent p.i.q) (lent p.i.p)) p.i.q) ~] t.q]
2014-07-30 21:04:40 +04:00
r (slag (lent p.i.p) r)
==
==
==
2014-07-24 20:13:36 +04:00
++ qeal :: merge p,q
|* [us=[ship desk] th=[ship desk] pat=path p=miso q=miso r=(list) con=?]
2014-07-30 21:04:40 +04:00
^- miso :: in case of conflict
2014-07-24 20:13:36 +04:00
~| %qeal-fail
?> ?=(%mut -.p)
?> ?=(%mut -.q)
?> ?=(%c -.q.p.p)
?> ?=(%c -.q.p.q)
2014-09-09 22:53:27 +04:00
=+ s=(clean p.q.p.p)
=+ t=(clean p.q.p.q)
2014-07-24 20:13:36 +04:00
:- %mut
:- %c :: todo is this p.p.p?
:- %c
|- ^- (urge)
::?~ s ?: (qual t) t
:: ~| %qail-conflict !!
::?~ t ?: (qual s) s
:: ~| %qail-conflict !!
?~ s t
?~ t s
?- -.i.s
%&
2014-07-30 21:04:40 +04:00
?- -.i.t
%&
?: =(p.i.s p.i.t)
[i.s $(s t.s, t t.t, r (slag p.i.s r))]
?: (gth p.i.s p.i.t)
[i.t $(t t.t, p.i.s (sub p.i.s p.i.t), r (slag p.i.t r))]
[i.s $(s t.s, p.i.t (sub p.i.t p.i.s), r (slag p.i.s r))]
%|
?: =(p.i.s (lent p.i.t))
[i.t $(s t.s, t t.t, r (slag p.i.s r))]
?: (gth p.i.s (lent p.i.t))
:- i.t
$(t t.t, p.i.s (sub p.i.s (lent p.i.t)), r (slag (lent p.i.t) r))
?. con ~| %quil-conflict !! :: conflict
~& [%quil-conflict-soft pat]
2014-09-09 22:53:27 +04:00
=+ mar=(match-conflict us th s t r)
2014-07-30 21:04:40 +04:00
[[%| p.mar] $(s p.q.mar, t q.q.mar, r r.q.mar)]
2014-07-24 20:13:36 +04:00
==
%|
2014-07-30 21:04:40 +04:00
?- -.i.t
%|
?. con ~| %quil-conflict !!
~& [%quil-conflict-soft pat]
2014-09-09 22:53:27 +04:00
=+ mar=(match-conflict us th s t r)
2014-07-30 21:04:40 +04:00
[[%| p.mar] $(s p.q.mar, t q.q.mar, r r.q.mar)]
%&
?: =(p.i.t (lent p.i.s))
[i.s $(s t.s, t t.t, r (slag p.i.t r))]
?: (gth p.i.t (lent p.i.s))
2014-09-09 22:53:27 +04:00
:- i.s
$(s t.s, p.i.t (sub p.i.t (lent p.i.s)), r (slag (lent p.i.s) r))
2014-07-30 21:04:40 +04:00
?. con ~| %quil-conflict !!
~& [%quil-conflict-soft pat]
2014-09-09 22:53:27 +04:00
=+ mar=(match-conflict us th s t r)
2014-07-30 21:04:40 +04:00
[[%| p.mar] $(s p.q.mar, t q.q.mar, r r.q.mar)]
==
2014-07-24 20:13:36 +04:00
==
++ quil :: merge p,q
2014-09-09 22:53:27 +04:00
|= $: us=[ship desk]
th=[ship desk]
pat=path
p=(unit miso)
q=(unit miso)
r=(unit (list))
con=?
==
2014-07-24 20:13:36 +04:00
^- (unit miso)
?~ p q :: trivial
?~ q p :: trivial
2014-08-07 22:06:53 +04:00
?- -.u.p
%ins ?> ?=(%ins -.u.q)
?. con !!
%- some
:- %ins
2014-10-22 06:04:27 +04:00
%- role
2014-09-09 22:53:27 +04:00
%- annotate
2014-08-07 22:06:53 +04:00
:- us
:- th
:- (lore ((hard ,@) p.u.p))
:- (lore ((hard ,@) p.u.q))
~
%del p
%mut ?> ?=(%mut -.u.q)
%- some
%^ qeal us th
:^ pat u.p u.q :: merge p,q
:- %- need r
con
==
2014-07-24 20:13:36 +04:00
::
++ meld :: merge p,q from r
|= [p=yaki q=yaki r=yaki con=? us=[ship desk] th=[ship desk]]
2014-07-24 20:13:36 +04:00
^- (map path blob)
2014-09-09 04:21:40 +04:00
=+ s=(diff-yakis r p)
=+ t=(diff-yakis r q)
2014-07-25 19:38:13 +04:00
=+ lut=(luth s t)
%- |= res=(map path blob) :: add old
^- (map path blob)
%- ~(uni by res)
%- mo
%+ turn
%+ skip (~(tap by q.r) ~) :: loop through old
|= [pat=path bar=lobe] ^- ?
(~(has in lut) pat) :: skip updated
|= [pat=path bar=lobe] ^- [path blob]
2014-09-09 04:21:40 +04:00
[pat (lobe-to-blob bar)] :: lookup objects
2014-07-25 19:38:13 +04:00
%+ roll (~(tap in (luth s t)) ~)
2014-07-24 20:13:36 +04:00
|= [pat=path res=(map path blob)]
=+ ^= v
%- need
%^ quil us th
:- pat
:+ (~(get by s) pat)
2014-07-29 22:16:35 +04:00
(~(get by t) pat)
2014-07-30 21:04:40 +04:00
:_ con
%- %- lift lore
%- %- lift %- hard ,@ :: for %c
2014-09-09 04:21:40 +04:00
%- %- lift lobe-to-noun
2014-07-29 22:16:35 +04:00
%- ~(get by q.r)
pat
2014-07-24 20:13:36 +04:00
?- -.v
%del res :: no longer exists
%ins :: new file
%+ ~(put by res) pat
2014-09-09 04:21:40 +04:00
%+ make-direct p.v %c :: TODO content type?
2014-07-24 20:13:36 +04:00
%mut :: patch from r
%+ ~(put by res) pat
2014-09-09 04:21:40 +04:00
%- make-direct
2014-07-24 20:13:36 +04:00
:_ %c
%+ lump p.v
2014-09-09 04:21:40 +04:00
%- lobe-to-noun
2014-07-25 19:38:13 +04:00
%- ~(got by q.r) pat
2014-07-24 20:13:36 +04:00
==
::
:: merge types
::
++ mate :: merge p,q
|= con=? :: %mate, %meld
|= [p=yaki q=yaki us=[ship desk] th=[ship desk]]
2014-07-24 20:13:36 +04:00
^- (map path blob)
2014-09-09 04:21:40 +04:00
=+ r=(~(tap in (find-merge-points p q)) ~)
2014-07-24 20:13:36 +04:00
?~ r
~|(%mate-no-ancestor !!)
?: =(1 (lent r))
(meld p q i.r con us th)
2014-07-24 20:13:36 +04:00
~|(%mate-criss-cross !!)
::
++ keep :: %this
|= [p=yaki q=yaki [ship desk] [ship desk]]
^- (map path blob)
%+ roll (~(tap by q.p) ~)
|= [[pat=path lob=lobe] zar=(map path blob)]
^- (map path blob)
2014-09-09 04:21:40 +04:00
(~(put by zar) pat (lobe-to-blob lob))
::
++ drop :: %that
|= [p=yaki q=yaki r=[ship desk] s=[ship desk]]
^- (map path blob)
(keep q p r s)
2014-08-01 00:17:37 +04:00
::
++ forge :: %forge
|= [p=yaki q=yaki s=[ship desk] t=[ship desk]]
^- (map path blob)
2014-09-09 04:21:40 +04:00
=+ r=(~(tap in (find-merge-points p q)) ~)
2014-08-01 00:17:37 +04:00
?~ r
~|(%forge-no-ancestor !!)
%- |= [r=yaki lut=(map lobe blob) hat=(map tako yaki)]
=. lat lut
=. hut hat
2014-09-09 04:21:40 +04:00
(meld p q r & s t) :: fake merge
2014-08-01 00:17:37 +04:00
%+ roll t.r :: fake ancestor
|= [par=yaki [for=_i.r lut=_lat hat=_hut]]
=. lat lut
=+ ^= far
^- (map path lobe)
2014-10-22 06:04:27 +04:00
%- ~(urn by (forge par for s t))
2014-09-09 04:21:40 +04:00
|= [k=path v=blob] (blob-to-lobe v)
=+ u=(make-yaki [r.par r.for ~] far `@da`0) :: fake yaki
2014-08-01 00:17:37 +04:00
:- u
:_ (~(put by hat) r.u u)
=< -
2014-09-09 04:21:40 +04:00
%- update-lat
2014-08-01 00:17:37 +04:00
:_ ~
2014-10-22 06:04:27 +04:00
%- ~(urn by q.u)
2014-08-01 00:17:37 +04:00
|= [path k=lobe]
2014-09-09 04:21:40 +04:00
(lobe-to-blob k)
2014-07-24 20:13:36 +04:00
::
:: actual merge
::
++ merge
|= [us=[ship desk] th=[ship desk]]
|= [p=yaki q=yaki r=@da s=$+([yaki yaki [ship desk] [ship desk]] (map path blob))]
2014-07-24 23:21:58 +04:00
^- [yaki (map path blob)]
=+ u=(s p q us th)
2014-07-24 20:13:36 +04:00
=+ ^= t
2014-07-24 23:21:58 +04:00
^- (map path lobe)
%+ roll (~(tap by u) ~)
2014-07-24 20:13:36 +04:00
|= [[pat=path bar=blob] yeb=(map path lobe)]
2014-09-09 04:21:40 +04:00
(~(put by yeb) pat (blob-to-lobe bar))
2014-07-24 23:21:58 +04:00
:_ u
2014-09-09 04:21:40 +04:00
(make-yaki [r.p r.q ~] t r)
2014-07-24 20:13:36 +04:00
::
2014-09-09 22:53:27 +04:00
++ strategy :: merge strategy
|= gem=?(%meld %mate %that %this)
?- gem
%meld (mate %.y)
2014-07-30 21:04:40 +04:00
%mate (mate %.n)
%this keep
%that drop
==
::
2014-09-09 22:53:27 +04:00
++ construct-merge :: construct-merge:ze
2014-07-24 23:21:58 +04:00
|= [gem=germ who=ship des=desk sab=saba now=@da] :: construct merge
2014-07-24 19:11:40 +04:00
^- (unit (unit mizu)) ::::::
=+ for=s.sab :: foreign dome
=+ mer=(merge [who des] [p.sab q.sab])
?- gem
%init :: force fine
?. =(let 0) :: hell no
!!
2014-10-31 06:13:40 +03:00
=+ hot=(~(put by *(map aeon tako)) 1 (~(got by hit.for) let.for))
2014-07-25 19:38:13 +04:00
[~ [~ [1 hot hut lat]]] :: trivial
%fine
=+ der=(~(got by hit.for) let.for)
=+ owr=(~(got by hit) let)
?: =(der owr)
[~ ~]
2014-09-09 04:21:40 +04:00
?: (~(has in (reachable-takos owr)) der)
[~ ~]
2014-09-09 04:21:40 +04:00
?. (~(has in (reachable-takos der)) owr)
~ :: not a fast forward
~& [%merge-fine p.sab q.sab]
[~ [~ [+(let) (~(put by hit) +(let) der) hut lat]]]
?(%mate %that %this %meld)
2014-09-09 04:21:40 +04:00
=+ foreign-head=(tako-to-yaki (~(got by hit.for) let.for))
=+ our-head=(tako-to-yaki (~(got by hit) let))
2014-07-24 23:21:58 +04:00
?: =(r.foreign-head r.our-head)
[~ ~] :: up to date
2014-09-09 04:21:40 +04:00
?: (~(has in (reachable-takos r.our-head)) r.foreign-head)
[~ ~] :: up to date
2014-09-09 04:21:40 +04:00
?: ?& |(=(gem %mate) =(gem %meld))
(~(has in (reachable-takos r.foreign-head)) r.our-head)
==
$(gem %fine) :: use fast forward
2014-09-09 22:53:27 +04:00
=+ gar=(mer our-head foreign-head now (strategy gem))
2014-07-24 23:21:58 +04:00
=+ yak=-.gar
=+ hek=+.gar
2014-09-09 04:21:40 +04:00
=. lat -:(update-lat hek ~) :: add new blobs
2014-10-31 06:13:40 +03:00
=. hut (~(put by *(map tako yaki)) r.yak yak)
2014-07-24 23:21:58 +04:00
=. let +(let)
2014-10-31 06:13:40 +03:00
=. hit (~(put by *(map aeon tako)) let r.yak)
2014-07-24 23:21:58 +04:00
[~ [~ [let hit hut lat]]]
==
2013-09-29 00:21:18 +04:00
::
2014-09-09 04:21:40 +04:00
++ read :: read:ze
2013-09-29 00:21:18 +04:00
|= mun=mood :: read at point
^- (unit)
?: ?=(%v p.mun)
2014-09-09 04:21:40 +04:00
[~ `dome`+<+<.read]
2013-09-29 00:21:18 +04:00
?: &(?=(%w p.mun) !?=(%ud -.q.mun))
?^(r.mun ~ [~ let])
?: ?=(%w p.mun)
2014-07-22 17:28:35 +04:00
=+ ^= yak
2014-09-17 04:29:12 +04:00
%- aeon-to-yaki
2014-07-22 17:28:35 +04:00
let
2014-09-09 04:21:40 +04:00
?^(r.mun ~ [~ [t.yak (forge-nori yak)]])
2014-09-10 00:25:00 +04:00
::?> ?=(^ hit) ?^(r.mun ~ [~ i.hit]) :: what do?? need [@da nori]
2014-09-09 22:53:27 +04:00
(query(ank ank:(descend-path:(zu ank) r.mun)) p.mun)
2013-09-29 00:21:18 +04:00
::
2014-09-09 04:21:40 +04:00
++ read-at-aeon :: read-at-aeon:ze
2014-09-17 04:29:12 +04:00
|= [yon=aeon mun=mood] :: seek and read
2013-09-29 00:21:18 +04:00
^- (unit)
?: &(?=(%w p.mun) !?=(%ud -.q.mun)) :: NB only for speed
2014-09-17 04:29:12 +04:00
?^(r.mun ~ [~ yon])
(read:(rewind yon) mun)
2013-09-29 00:21:18 +04:00
::
2014-09-09 04:21:40 +04:00
++ equiv :: test paths
2014-07-24 19:11:40 +04:00
|= [p=(map path lobe) q=(map path lobe)]
^- ?
2014-09-16 18:19:15 +04:00
=- ?. qat %.n
%+ levy (~(tap by q) ~)
|= [pat=path lob=lobe]
2014-07-24 19:11:40 +04:00
(~(has by p) pat)
2014-09-16 18:19:15 +04:00
^= qat
%+ levy (~(tap by p) ~)
|= [pat=path lob=lobe]
2014-07-24 19:11:40 +04:00
=+ zat=(~(get by q) pat)
?~ zat %.n
2014-09-09 04:21:40 +04:00
=((lobe-to-noun u.zat) (lobe-to-noun lob))
2014-07-24 19:11:40 +04:00
::
2014-09-09 04:21:40 +04:00
++ edit :: edit:ze
|= [wen=@da lem=nori] :: edit
2013-09-29 00:21:18 +04:00
^+ +>
?- -.lem
2014-09-16 18:19:15 +04:00
& =^ yak lat :: merge objects
2014-09-09 04:21:40 +04:00
%+ forge-yaki wen
2014-07-24 19:11:40 +04:00
?: =(let 0) :: initial import
[~ q.lem]
2014-09-17 04:29:12 +04:00
[(some r:(aeon-to-yaki let)) q.lem]
2014-09-09 04:21:40 +04:00
?. ?| =(0 let)
!=((lent p.yak) 1)
2014-09-17 04:29:12 +04:00
!(equiv q.yak q:(aeon-to-yaki let))
2014-09-09 04:21:40 +04:00
==
2014-07-24 19:11:40 +04:00
+>.$ :: silently ignore
=: let +(let)
2014-07-24 19:11:40 +04:00
hit (~(put by hit) +(let) r.yak)
hut (~(put by hut) r.yak yak)
==
2014-09-09 04:21:40 +04:00
+>.$(ank (checkout-ankh q.yak))
| +>.$(lab ?<((~(has by lab) p.lem) (~(put by lab) p.lem let)))
2013-09-29 00:21:18 +04:00
==
--
::
2014-11-01 01:36:01 +03:00
++ zu !: :: filesystem
2013-09-29 00:21:18 +04:00
|= ank=ankh :: filesystem state
=| myz=(list ,[p=path q=miso]) :: changes in reverse
2013-09-29 00:21:18 +04:00
=| ram=path :: reverse path into
|%
2014-09-09 22:53:27 +04:00
++ rehash :: local rehash
2013-09-29 00:21:18 +04:00
^- cash
%+ mix ?~(q.ank 0 p.u.q.ank)
=+ axe=1
|- ^- cash
2014-10-31 06:13:40 +03:00
?~ r.ank *@
2013-09-29 00:21:18 +04:00
;: mix
(shaf %dash (mix axe (shaf %dush (mix p.n.r.ank p.q.n.r.ank))))
$(r.ank l.r.ank, axe (peg axe 2))
$(r.ank r.r.ank, axe (peg axe 3))
==
::
2014-09-09 22:53:27 +04:00
++ update-hash %_(. p.ank rehash) :: rehash and save
++ ascend :: ascend
2013-09-29 00:21:18 +04:00
|= [lol=@ta kan=ankh]
^+ +>
?> &(?=(^ ram) =(lol i.ram))
%= +>
ram t.ram
ank
2013-09-29 00:21:18 +04:00
?: =([0 ~ ~] ank)
?. (~(has by r.kan) lol) kan
kan(r (~(del by r.kan) lol))
kan(r (~(put by r.kan) lol ank))
==
::
2014-09-09 22:53:27 +04:00
++ push-change :: add change
2013-09-29 00:21:18 +04:00
|= mis=miso
^+ +>
+>(myz [[(flop ram) mis] myz])
2013-09-29 00:21:18 +04:00
::
2014-09-09 22:53:27 +04:00
++ descend :: descend
2013-09-29 00:21:18 +04:00
|= lol=@ta
^+ +>
=+ you=(~(get by r.ank) lol)
+>.$(ram [lol ram], ank ?~(you [*cash ~ ~] u.you))
::
2014-09-09 22:53:27 +04:00
++ descend-path :: descend recursively
2013-09-29 00:21:18 +04:00
|= way=path
^+ +>
2014-09-09 22:53:27 +04:00
?~(way +> $(way t.way, +> (descend i.way)))
2013-09-29 00:21:18 +04:00
::
2014-09-09 22:53:27 +04:00
++ overwrite :: write over
2013-09-29 00:21:18 +04:00
|= [pum=umph val=(unit ,[p=cash q=*])]
^+ +>
?~ q.ank
?~ val +>
2014-09-09 22:53:27 +04:00
(push-change %ins q.u.val)
2013-09-29 00:21:18 +04:00
?~ val
2014-09-09 22:53:27 +04:00
(push-change %del q.u.q.ank)
2013-09-29 00:21:18 +04:00
?: =(q.u.val q.u.q.ank) +>
2014-09-09 22:53:27 +04:00
(push-change %mut ((diff pum) q.u.q.ank q.u.val))
2013-09-29 00:21:18 +04:00
::
2014-09-09 22:53:27 +04:00
++ change-tree :: modify tree
2013-09-29 00:21:18 +04:00
|= [pum=umph bus=ankh]
^+ +>
2014-09-09 22:53:27 +04:00
=. +> (overwrite pum q.bus)
2013-09-29 00:21:18 +04:00
=+ [yeg=(~(tap by r.ank) ~) gey=(~(tap by r.bus) ~)]
=. +>.$
|- ^+ +>.^$
?~ yeg +>.^$
?: (~(has by r.bus) p.i.yeg) $(yeg t.yeg)
2014-09-09 22:53:27 +04:00
$(yeg t.yeg, myz myz:rm-r(ank q.i.yeg, ram [p.i.yeg ram]))
2013-09-29 00:21:18 +04:00
|- ^+ +>.^$
?~ gey +>.^$
2014-09-09 22:53:27 +04:00
$(gey t.gey, myz myz:^$(bus q.i.gey, +> (descend p.i.gey)))
2013-09-29 00:21:18 +04:00
::
2014-09-09 22:53:27 +04:00
++ rm-r :: rm -r
2013-09-29 00:21:18 +04:00
|- ^+ +
2014-09-09 22:53:27 +04:00
=. + ?~(q.ank + (push-change %del q.u.q.ank))
2013-09-29 00:21:18 +04:00
=+ dyr=(~(tap by r.ank) ~)
|- ^+ +.^$
?~ dyr +.^$
2014-09-09 22:53:27 +04:00
=. +.^$ rm-r:(descend p.i.dyr)
2013-09-29 00:21:18 +04:00
$(dyr t.dyr)
::
++ drum :: apply effect
2014-09-09 22:53:27 +04:00
|= [pax=path mis=miso] :: XX unused (++dune)
2013-09-29 00:21:18 +04:00
^+ +>
?^ pax
2014-09-09 22:53:27 +04:00
update-hash:(ascend:$(pax t.pax, +> (descend i.pax)) i.pax ank)
~| %clay-fail
2013-09-29 00:21:18 +04:00
?- -.mis
%del
?> &(?=(^ q.ank) =(q.u.q.ank p.mis))
+>.$(p.ank (mix p.u.q.ank p.ank), q.ank ~)
::
%ins
?> ?=(~ q.ank)
=+ sam=(sham p.mis)
+>.$(p.ank (mix sam p.ank), q.ank [~ sam p.mis])
::
%mut
?> ?=(^ q.ank)
=+ nex=(lump p.mis q.u.q.ank)
=+ sam=(sham nex)
+>.$(p.ank :(mix sam p.u.q.ank p.ank), q.ank [~ sam nex])
==
::
2013-09-29 00:21:18 +04:00
++ dune :: apply
2014-09-09 22:53:27 +04:00
|- ^+ + :: XX unused (++durn)
2013-09-29 00:21:18 +04:00
?~ myz +
=> .(+ (drum p.i.myz q.i.myz))
2013-12-24 00:49:15 +04:00
$(myz ?>(?=(^ myz) t.myz))
2013-09-29 00:21:18 +04:00
::
++ durn :: apply forward
2014-09-09 22:53:27 +04:00
|= nyp=soba :: XX unused
2013-09-29 00:21:18 +04:00
^+ +>
?: =([0 0] p.nyp)
dune(myz q.nyp)
2013-09-29 00:21:18 +04:00
=> ?: =(p.ank p.p.nyp) .
~& [%durn-in-wrong p.ank p.p.nyp]
2013-09-29 00:21:18 +04:00
.
=. +> dune(myz q.nyp)
=> ?: =(p.ank q.p.nyp) .
~& [%durn-out-wrong p.ank q.p.nyp]
2013-09-29 00:21:18 +04:00
.
+>
2014-07-12 22:24:52 +04:00
--
2013-09-29 00:21:18 +04:00
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
2014-10-30 02:30:15 +03:00
:: section 3bF, filesystem interface ::
2013-09-29 00:21:18 +04:00
::
2014-10-30 02:30:15 +03:00
++ feel :: simple file write
|= [pax=path val=*]
^- miso
=+ dir=((hard arch) .^(%cy pax))
?~ q.dir [%ins val]
:- %mut
^- udon
[%a %a .^(%cx pax) val]
::
++ file :: simple file load
|= pax=path
^- (unit)
=+ dir=((hard arch) .^(%cy pax))
?~(q.dir ~ [~ .^(%cx pax)])
::
++ foal :: high-level write
|= [pax=path val=*]
^- toro
?> ?=([* * * *] pax)
[i.t.pax [%& [*cart [[t.t.t.pax (feel pax val)] ~]]]]
::
++ fray :: high-level delete
|= pax=path
^- toro
?> ?=([* * * *] pax)
[i.t.pax [%& [*cart [[t.t.t.pax [%del .^(%cx pax)]] ~]]]]
::
++ furl :: unify changes
|= [one=toro two=toro]
^- toro
~| %furl
?> ?& =(p.one p.two) :: same path
&(?=(& -.q.one) ?=(& -.q.two)) :: both deltas
==
[p.one [%& [*cart (weld q.q.q.one q.q.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 ::
2013-09-29 00:21:18 +04:00
::
++ deft :: parse url extension
2013-09-29 00:21:18 +04:00
|= rax=(list ,@t)
|- ^- pork
?~ rax
[~ ~]
?^ t.rax
[p.pok [i.rax q.pok]]:[pok=$(rax t.rax) .]
=+ ^- raf=(like tape)
%. [1^1 (flop (trip i.rax))]
;~(sfix (plus ;~(less dot next)) dot)
?~ q.raf
[~ [i.rax ~]]
=+ `[ext=tape [@ @] fyl=tape]`u.q.raf
[[~ (crip (flop ext))] [(crip (flop fyl)) ~]]
2013-09-29 00:21:18 +04:00
::
2014-07-10 03:12:26 +04:00
++ fuel :: parse fcgi
|= [bem=beam but=path]
^- epic
2014-07-10 04:48:53 +04:00
?> ?=([%web @ *] but)
=+ dyb=(slay i.t.but)
2014-03-20 05:05:42 +04:00
?> ?& ?=([~ %many *] dyb)
2014-03-26 04:48:22 +04:00
?=([* * *] p.u.dyb)
?=([%$ %ta *] i.p.u.dyb)
2014-03-26 04:48:22 +04:00
?=([%blob *] i.t.p.u.dyb)
2014-03-20 05:05:42 +04:00
==
2014-03-26 04:48:22 +04:00
=+ ced=((hard cred) p.i.t.p.u.dyb)
2014-07-09 13:40:49 +04:00
:: =+ nep=q.p.i.p.u.dyb
2014-03-20 05:05:42 +04:00
=+ ^= gut ^- (list ,@t)
2014-03-26 04:48:22 +04:00
%+ turn t.t.p.u.dyb
2014-03-20 05:05:42 +04:00
|= a=coin ^- @t
?> ?=([%$ %t @] a)
?>(((sane %t) q.p.a) q.p.a)
=+ ^= quy
2014-03-20 05:05:42 +04:00
|- ^- (list ,[p=@t q=@t])
?~ gut ~
?> ?=(^ t.gut)
[[i.gut i.t.gut] $(gut t.t.gut)]
2014-07-09 11:37:47 +04:00
:* (~(gas by *(map cord cord)) quy)
2014-03-20 05:05:42 +04:00
ced
2014-08-02 03:39:15 +04:00
bem
2014-07-10 04:48:53 +04:00
t.t.but
2014-03-20 05:05:42 +04:00
==
::
2014-10-30 02:30:15 +03:00
++ sifo :: 64-bit encode
|= tig=@
^- tape
2014-10-30 03:09:03 +03:00
=+ poc=(~(dif fo 3) 0 (met 3 tig))
2014-10-30 02:30:15 +03:00
=+ pad=(lsh 3 poc (swap 3 tig))
2014-10-30 03:09:03 +03:00
=+ ^= cha
'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
2014-10-30 02:30:15 +03:00
=+ ^= sif
|- ^- tape
?~ pad
~
=+ d=(end 0 6 pad)
2014-11-03 10:49:09 +03:00
[(cut 3 [d 1] cha) $(pad (rsh 0 6 pad))]
(weld (flop (slag poc sif)) (trip (fil 3 poc '=')))
2014-10-30 02:30:15 +03:00
::
2014-04-21 21:02:09 +04:00
++ 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)
2014-04-21 21:02:09 +04:00
==
[tap ~]
['%' (xen (rsh 0 4 tap)) (xen (end 0 4 tap)) ~]
2014-04-21 21:02:09 +04:00
::
++ 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])
::
2014-11-03 11:05:07 +03:00
++ earl :: localize purl
2014-04-21 21:02:09 +04:00
|= [who=@p pul=purl]
^- purl
pul(q.q [(rsh 3 1 (scot %p who)) q.q.pul])
::
++ earn :: purl to tape
2014-11-03 11:05:07 +03:00
|^ |= pul=purl
^- tape
:(weld (head p.pul) "/" (body q.pul) (tail r.pul))
2014-04-21 21:02:09 +04:00
::
++ body
2014-11-03 11:05:07 +03:00
|= pok=pork ^- tape
2014-11-03 11:28:58 +03:00
?~ q.pok ~
|-
2014-11-03 11:05:07 +03:00
=+ seg=(trip i.q.pok)
2014-11-03 11:28:58 +03:00
?~ t.q.pok
?~(p.pok seg (welp seg '.' (trip u.p.pok)))
(welp seg '/' $(q.pok t.q.pok))
2014-04-21 21:02:09 +04:00
::
++ head
2014-11-03 11:05:07 +03:00
|= har=hart
2014-04-21 21:02:09 +04:00
^- tape
;: weld
2015-01-15 04:47:51 +03:00
?:(&(p.har !?=(hoke r.har)) "https://" "http://")
2014-04-21 21:02:09 +04:00
::
2014-11-03 11:05:07 +03:00
?- -.r.har
| (trip (rsh 3 1 (scot %if p.r.har)))
& =+ rit=(flop p.r.har)
2014-04-21 21:02:09 +04:00
|- ^- tape
?~(rit ~ (weld (trip i.rit) ?~(t.rit "" `tape`['.' $(rit t.rit)])))
==
::
2014-11-03 11:05:07 +03:00
?~(q.har ~ `tape`[':' (trip (rsh 3 2 (scot %ui u.q.har)))])
2014-04-21 21:02:09 +04:00
==
::
++ tail
2014-11-03 11:05:07 +03:00
|= kay=quay
2014-04-21 21:02:09 +04:00
^- tape
2014-11-03 11:05:07 +03:00
?: =(~ kay) ~
2014-04-21 21:02:09 +04:00
:- '?'
|- ^- tape
2014-11-03 11:05:07 +03:00
?~ kay ~
2014-04-21 21:02:09 +04:00
;: weld
2014-11-03 11:28:58 +03:00
(urle (trip p.i.kay))
2014-04-21 21:02:09 +04:00
"="
2014-11-03 11:28:58 +03:00
(urle (trip q.i.kay))
2014-11-03 11:05:07 +03:00
?~(t.kay ~ `tape`['&' $(kay t.kay)])
2014-04-21 21:02:09 +04:00
==
--
::
2013-09-29 00:21:18 +04:00
++ epur :: url/header parser
2015-01-27 02:24:31 +03:00
=< |=(a=cord `(unit purl)`(rush a auri))
2013-09-29 00:21:18 +04:00
|%
++ apat :: 2396 abs_path
%+ cook deft
(ifix [fas ;~(pose fas (easy ~))] (more fas smeg))
2014-11-04 23:32:09 +03:00
++ auri :: 2396 URL
2014-04-23 21:02:36 +04:00
%+ cook
|= a=purl
2015-01-15 04:47:51 +03:00
?.(?=(hoke r.p.a) a a(p.p &))
2013-09-29 00:21:18 +04:00
;~ plug
;~ plug
%+ sear
|= a=@t
2013-09-29 00:21:18 +04:00
^- (unit ,?)
?+(a ~ %http [~ %|], %https [~ %&])
;~(sfix scem ;~(plug col fas fas))
thor
==
2014-03-03 02:31:03 +04:00
;~(plug ;~(pose apat (easy *pork)) yque)
==
2014-03-04 23:17:34 +04:00
++ cock :: cookie
(most ;~(plug sem ace) ;~(plug toke ;~(pfix tis tosk)))
2013-09-29 00:21:18 +04:00
++ dlab :: 2396 domainlabel
%+ sear
|= a=@ta
2014-10-11 01:16:19 +04:00
?.(=('-' (rsh 3 (dec (met 3 a)) a)) [~ u=a] ~)
2013-09-29 00:21:18 +04:00
%+ cook cass
;~(plug aln (star alp))
::
++ fque (cook crip (plus pquo)) :: normal query field
++ fquu (cook crip (star pquo)) :: optional field
2013-09-29 00:21:18 +04:00
++ pcar ;~(pose pure pesc psub col pat) :: 2396 path char
2014-11-04 23:32:09 +03:00
++ pcok ;~(less bas sem com doq prn) :: cookie char
2013-09-29 00:21:18 +04:00
++ 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) :: normal query char
++ pure ;~(pose aln hep dot cab sig) :: 2396 unreserved
++ psub ;~ pose :: 3986 sub-delims
zap buc pam soq pel per
2013-09-29 00:21:18 +04:00
tar lus com sem tis
==
2014-03-04 23:17:34 +04:00
++ ptok ;~ pose :: 2616 token
aln zap hax buc cen pam soq tar lus
2014-03-20 05:05:42 +04:00
hep dot ket cab tec bar sig
2014-03-04 23:17:34 +04:00
==
2013-09-29 00:21:18 +04:00
++ scem :: 2396 scheme
%+ cook cass
;~(plug alf (star ;~(pose aln lus hep dot)))
::
++ smeg (cook crip (plus pcar)) :: 2396 segment
2014-03-04 23:17:34 +04:00
++ 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
2013-09-29 00:21:18 +04:00
++ thor :: 2396 host/port
2013-12-21 06:35:33 +04:00
%+ cook |*(a=[* *] [+.a -.a])
2013-09-29 00:21:18 +04:00
;~ plug
thos
;~((bend) (easy ~) ;~(pfix col dim:ag))
2013-09-29 00:21:18 +04:00
==
++ 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)
2013-09-29 00:21:18 +04:00
%+ 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 '')))
2013-09-29 00:21:18 +04:00
::
%+ cook :: funky query
|=(a=tape [[%$ (crip a)] ~])
(star pque)
==
++ zest :: 2616 request-uri
;~ pose
(stag %& (cook |=(a=purl a) auri))
(stag %| ;~(plug apat yque))
==
--
::
2014-10-30 02:30:15 +03:00
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
:: section 3bH, names etc ::
2014-03-06 01:42:47 +04:00
::
2014-10-30 02:30:15 +03:00
++ 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
2014-03-06 01:42:47 +04:00
::
2014-10-30 03:09:03 +03:00
++ glam :: carrier names
2014-10-28 21:55:44 +03:00
|= zar=@pD ^- tape
2014-08-01 00:23:02 +04:00
%+ snag zar
^- (list tape)
:~ "Tianming" "Pepin the Short" "Haile Selassie" "Alfred the Great"
"Tamerlane" "Pericles" "Talleyrand" "Yongle" "Seleucus"
"Uther Pendragon" "Louis XVI" "Ahmad Shāh Durrānī" "Constantine"
"Wilhelm I" "Akbar" "Louis XIV" "Nobunaga" "Alexander VI"
"Philippe II" "Julius II" "David" "Niall Noígíallach" "Kublai Khan"
"Öz Beg Khan" "Ozymandias" "Ögedei Khan" "Jiang Jieshi" "Darius"
"Shivaji" "Qianlong" "Bolesław I Chrobry" "Tigranes" "Han Wudi"
"Charles X" "Naresuan" "Frederick II" "Simeon" "Kangxi"
"Suleiman the Magnificent" "Pedro II" "Genghis Khan" "Laozi"
"Porfirio Díaz" "Pakal" "Wu Zetian" "Garibaldi" "Matthias Corvinus"
"Leopold II" "Leonidas" "Sitting Bull" "Nebuchadnezzar II"
"Rhodes" "Henry VIII" "Attila" "Catherine II" "Chulalongkorn"
"Uthmān" "Augustus" "Faustin" "Chongde" "Justinian"
"Afonso de Albuquerque" "Antoninus Pius" "Cromwell" "Innocent X"
"Fidel" "Frederick the Great" "Canute" "Vytautas" "Amina"
"Hammurabi" "Suharto" "Victoria" "Hiawatha" "Paul V" "Shaka"
"Lê Thánh Tông" "Ivan Asen II" "Tiridates" "Nefertiti" "Gwangmu"
"Ferdinand & Isabella" "Askia" "Xuande" "Boris Godunov" "Gilgamesh"
"Maximillian I" "Mao" "Charlemagne" "Narai" "Hanno" "Charles I & V"
"Alexander II" "Mansa Musa" "Zoe Porphyrogenita" "Metternich"
"Robert the Bruce" "Pachacutec" "Jefferson" "Solomon" "Nicholas I"
"Barbarossa" "FDR" "Pius X" "Gwanggaeto" "Abbas I" "Julius Caesar"
"Lee Kuan Yew" "Ranavalona I" "Go-Daigo" "Zenobia" "Henry V"
"Bảo Đại" "Casimir III" "Cyrus" "Charles the Wise" "Sandrokottos"
"Agamemnon" "Clement VII" "Suppiluliuma" "Deng Xiaoping"
"Victor Emmanuel" "Ajatasatru" "Jan Sobieski" "Huangdi" "Xuantong"
"Narmer" "Cosimo de' Medici" "Möngke Khan" "Stephen Dušan" "Henri IV"
"Mehmed Fatih" "Conn Cétchathach" "Francisco Franco" "Leo X"
"Kammu" "Krishnadevaraya" "Elizabeth I" "Norton I" "Washington"
"Meiji" "Umar" "TR" "Peter the Great" "Agustin I" "Ashoka"
"William the Conqueror" "Kongolo Mwamba" "Song Taizu"
"Ivan the Terrible" "Yao" "Vercingetorix" "Geronimo" "Rurik"
"Urban VIII" "Alexios Komnenos" "Maria I" "Tamar" "Bismarck"
"Arthur" "Jimmu" "Gustavus Adolphus" "Suiko" "Basil I" "Montezuma"
"Santa Anna" "Xerxes" "Beyazıt Yıldırım" "Samudragupta" "James I"
"George III" "Kamehameha" "Francesco Sforza" "Trajan"
"Rajendra Chola" "Hideyoshi" "Cleopatra" "Alexander"
"Ashurbanipal" "Paul III" "Vespasian" "Tecumseh" "Narasimhavarman"
"Suryavarman II" "Bokassa I" "Charles Canning" "Theodosius"
"Francis II" "Zhou Wen" "William Jardine" "Ahmad al-Mansur"
"Lajos Nagy" "Theodora" "Mussolini" "Samuil" "Osman Gazi"
"Kim Il-sung" "Maria Theresa" "Lenin" "Tokugawa" "Marcus Aurelius"
"Nzinga Mbande" "Edward III" "Joseph II" "Pulakesi II" "Priam"
"Qin Shi Huang" "Shah Jahan" "Sejong" "Sui Wendi" "Otto I"
"Napoleon III" "Prester John" "Dido" "Joao I" "Gregory I"
"Gajah Mada" "Abd-ar Rahmān III" "Taizong" "Franz Josef I"
"Nicholas II" "Gandhi" "Chandragupta II" "Peter III"
"Oba Ewuare" "Louis IX" "Napoleon" "Selim Yavuz" "Shun"
"Hayam Wuruk" "Jagiełło" "Nicaule" "Sargon" "Saladin" "Charles II"
"Brian Boru" "Da Yu" "Antiochus III" "Charles I"
"Jan Pieterszoon Coen" "Hongwu" "Mithridates" "Hadrian" "Ptolemy"
"Benito Juarez" "Sun Yat-sen" "Raja Raja Chola" "Bolivar" "Pius VII"
"Shapur II" "Taksin" "Ram Khamhaeng" "Hatshepsut" "Alī" "Matilda"
"Ataturk"
==
2013-09-29 00:21:18 +04:00
::
2014-10-30 03:09:03 +03:00
++ glon :: ISO language codes
2013-09-29 00:21:18 +04:00
|= lag=lang
^- (unit tape)
?+ lag ~
2014-08-01 00:23:02 +04:00
%aa [~ "Afar"]
%ab [~ "Abkhazian"]
%ae [~ "Avestan"]
%af [~ "Afrikaans"]
%ak [~ "Akan"]
%am [~ "Amharic"]
%an [~ "Aragonese"]
%ar [~ "Arabic"]
%as [~ "Assamese"]
%av [~ "Avaric"]
%ay [~ "Aymara"]
%az [~ "Azerbaijani"]
%ba [~ "Bashkir"]
%be [~ "Belarusian"]
%bg [~ "Bulgarian"]
%bh [~ "Bihari"]
%bi [~ "Bislama"]
%bm [~ "Bambara"]
%bn [~ "Bengali"]
%bo [~ "Tibetan"]
%br [~ "Breton"]
%bs [~ "Bosnian"]
%ca [~ "Catalan"]
%ce [~ "Chechen"]
%ch [~ "Chamorro"]
%co [~ "Corsican"]
%cr [~ "Cree"]
%cs [~ "Czech"]
%cu [~ "Slavonic"]
%cv [~ "Chuvash"]
%cy [~ "Welsh"]
%da [~ "Danish"]
%de [~ "German"]
%dv [~ "Maldivian"]
%dz [~ "Dzongkha"]
%ee [~ "Ewe"]
%el [~ "Greek"]
%en [~ "English"]
%eo [~ "Esperanto"]
%es [~ "Spanish"]
%et [~ "Estonian"]
%eu [~ "Basque"]
%fa [~ "Persian"]
%ff [~ "Fulah"]
%fi [~ "Finnish"]
%fj [~ "Fijian"]
%fo [~ "Faroese"]
%fr [~ "French"]
%fy [~ "Frisian"]
%ga [~ "Irish Gaelic"]
%gd [~ "Scottish Gaelic"]
%gl [~ "Galician"]
%gn [~ "Guarani"]
%gu [~ "Gujarati"]
%gv [~ "Manx"]
%ha [~ "Hausa"]
%he [~ "Hebrew"]
%hi [~ "Hindi"]
%ho [~ "Hiri Motu"]
%hr [~ "Croatian"]
%ht [~ "Haitian Creole"]
%hu [~ "Hungarian"]
%hy [~ "Armenian"]
%hz [~ "Herero"]
%ia [~ "Interlingua"]
%id [~ "Indonesian"]
%ie [~ "Occidental"]
%ig [~ "Igbo"]
%ii [~ "Nuosu"]
%ik [~ "Inupiaq"]
%io [~ "Ido"]
%is [~ "Icelandic"]
%it [~ "Italian"]
%iu [~ "Inuktitut"]
%ja [~ "Japanese"]
%jv [~ "Javanese"]
%ka [~ "Georgian"]
%kg [~ "Kongo"]
%ki [~ "Kikuyu"]
%kj [~ "Kwanyama"]
%kk [~ "Kazakh"]
%kl [~ "Kalaallisut"]
%km [~ "Central Khmer"]
%kn [~ "Kannada"]
%ko [~ "Korean"]
%kr [~ "Kanuri"]
%ks [~ "Kashmiri"]
%ku [~ "Kurdish"]
%kv [~ "Komi"]
%kw [~ "Cornish"]
%ky [~ "Kyrgyz"]
%la [~ "Latin"]
%lb [~ "Luxembourgish"]
%lg [~ "Ganda"]
%li [~ "Limburgish"]
%ln [~ "Lingala"]
%lo [~ "Lao"]
%lt [~ "Lithuanian"]
%lu [~ "Luba-Katanga"]
%lv [~ "Latvian"]
%mg [~ "Malagasy"]
%mh [~ "Marshallese"]
%mi [~ "Maori"]
%mk [~ "Macedonian"]
%ml [~ "Malayalam"]
%mn [~ "Mongolian"]
%mr [~ "Marathi"]
%ms [~ "Malay"]
%mt [~ "Maltese"]
%my [~ "Burmese"]
%na [~ "Nauru"]
%nb [~ "Norwegian Bokmål"]
%nd [~ "North Ndebele"]
%ne [~ "Nepali"]
%ng [~ "Ndonga"]
%nl [~ "Dutch"]
%nn [~ "Norwegian Nynorsk"]
%no [~ "Norwegian"]
%nr [~ "South Ndebele"]
%nv [~ "Navajo"]
%ny [~ "Chichewa"]
%oc [~ "Occitan"]
%oj [~ "Ojibwa"]
%om [~ "Oromo"]
%or [~ "Oriya"]
%os [~ "Ossetian"]
%pa [~ "Punjabi"]
%pi [~ "Pali"]
%pl [~ "Polish"]
%ps [~ "Pashto"]
%pt [~ "Portuguese"]
%qu [~ "Quechua"]
%rm [~ "Romansh"]
%rn [~ "Rundi"]
%ro [~ "Romanian"]
%ru [~ "Russian"]
%rw [~ "Kinyarwanda"]
%sa [~ "Sanskrit"]
%sc [~ "Sardinian"]
%sd [~ "Sindhi"]
%se [~ "Northern Sami"]
%sg [~ "Sango"]
%si [~ "Sinhala"]
%sk [~ "Slovak"]
%sl [~ "Slovenian"]
%sm [~ "Samoan"]
%sn [~ "Shona"]
%so [~ "Somali"]
%sq [~ "Albanian"]
%sr [~ "Serbian"]
%ss [~ "Swati"]
%st [~ "Sotho"]
%su [~ "Sundanese"]
%sv [~ "Swedish"]
%sw [~ "Swahili"]
%ta [~ "Tamil"]
%te [~ "Telugu"]
%tg [~ "Tajik"]
%th [~ "Thai"]
%ti [~ "Tigrinya"]
%tk [~ "Turkmen"]
%tl [~ "Tagalog"]
%tn [~ "Tswana"]
%to [~ "Tonga"]
%tr [~ "Turkish"]
%ts [~ "Tsonga"]
%tt [~ "Tatar"]
%tw [~ "Twi"]
%ty [~ "Tahitian"]
%ug [~ "Uighur"]
%uk [~ "Ukrainian"]
%ur [~ "Urdu"]
%uz [~ "Uzbek"]
%ve [~ "Venda"]
%vi [~ "Vietnamese"]
%vo [~ "Volapük"]
%wa [~ "Walloon"]
%wo [~ "Wolof"]
%xh [~ "Xhosa"]
%yi [~ "Yiddish"]
%yo [~ "Yoruba"]
%za [~ "Zhuang"]
%zh [~ "Chinese"]
%zu [~ "Zulu"]
2013-09-29 00:21:18 +04:00
==
::
2014-10-30 02:30:15 +03:00
++ 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=((hard ,@t) .^(%a pax))
?: =(%$ woy) yow
(rap 3 yow ' ' woy ~)
::
2013-09-29 00:21:18 +04:00
++ 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
2013-11-08 05:36:28 +04:00
%punk ~['"' q.p.gos '"']
2013-09-29 00:21:18 +04:00
?(%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 ')'])
==
==
::
2014-07-02 02:51:42 +04:00
++ hunt :: first of unit dates
2013-09-29 00:21:18 +04:00
|= [one=(unit ,@da) two=(unit ,@da)]
^- (unit ,@da)
?~ one two
?~ two one
?:((lth u.one u.two) one two)
::
:: ++ mojo :: compiling load
:: |= [pax=path src=*]
:: ^- (each twig (list tank))
:: ?. ?=(@ src)
:: [%| ~[[leaf/"musk: malformed: {<pax>}"]]]
:: =+ ^= mud
:: %- mule |.
:: ((full vest) [1 1] (trip src))
:: ?: ?=(| -.mud) mud
:: ?~ q.p.mud
:: :~ %|
:: leaf/"musk: syntax error: {<pax>}"
:: leaf/"musk: line {<p.p.p.mud>}, column {<q.p.p.mud>}"
:: ==
:: [%& p.u.q.p.mud]
:: ::
2014-05-07 21:42:31 +04:00
++ mole :: new to old sky
|= ska=$+(* (unit (unit)))
|= a=*
^- (unit)
=+ b=(ska a)
?~ b ~
?~ u.b ~
[~ u.u.b]
:: ::
:: ++ much :: constructing load
:: |= [pax=path src=*]
:: ^- gank
:: =+ moj=(mojo pax src)
:: ?: ?=(| -.moj) moj
:: (mule |.((slap !>(+>.$) `twig`p.moj)))
:: ::
:: ++ musk :: compiling apply
:: |= [pax=path src=* sam=vase]
:: ^- gank
:: =+ mud=(much pax src)
:: ?: ?=(| -.mud) mud
:: (mule |.((slam p.mud sam)))
:: ::
2015-01-14 08:38:39 +03:00
++ pack :: light path encoding
|= [a=term b=path] ^- span
%+ rap 3 :- (wack a)
(turn b |=(c=span (cat 3 '_' (wack c))))
::
++ pick :: light path decoding
2015-01-26 22:15:35 +03:00
=+ fel=(most cab (sear wick urt:ab))
|=(a=span `(unit ,[p=term q=path])`(rush a fel))
2013-09-29 00:21:18 +04:00
++ saxo :: autocanon
|= who=ship
^- (list ship)
?: (lth who 256) [who ~]
[who $(who (sein who))]
::
2014-03-12 23:50:39 +04:00
++ sein :: autoboss
2013-09-29 00:21:18 +04:00
|= 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
==
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
2014-10-30 02:30:15 +03:00
:: section 3bI, Arvo models ::
2013-09-29 00:21:18 +04:00
::
++ acru :: asym cryptosuite
$_ ^? |% :: opaque object
++ as ^? :: asym ops
2014-10-31 06:13:40 +03:00
|% ++ seal |=([a=pass b=@ c=@] *@) :: encrypt to a
++ sign |=([a=@ b=@] *@) :: certify as us
++ sure |=([a=@ b=@] *(unit ,@)) :: authenticate from us
2014-07-26 04:29:01 +04:00
++ tear |= [a=pass b=@] :: accept from a
*(unit ,[p=@ q=@]) ::
-- ::
++ de |+([a=@ b=@] *(unit ,@)) :: symmetric de, soft
2014-10-31 06:13:40 +03:00
++ dy |+([a=@ b=@] *@) :: symmetric de, hard
++ en |+([a=@ b=@] *@) :: symmetric en
++ ex ^? :: export
2014-10-31 06:13:40 +03:00
|% ++ fig *@uvH :: fingerprint
++ pac *@uvG :: default passcode
++ pub *pass :: public key
++ sec *ring :: private key
2014-09-09 04:21:40 +04:00
-- ::
++ nu ^? :: reconstructors
2014-07-03 02:08:02 +04:00
|% ++ pit |=([a=@ b=@] ^?(..nu)) :: from [width seed]
++ nol |=(a=@ ^?(..nu)) :: from naked ring
++ com |=(a=@ ^?(..nu)) :: from naked pass
2014-09-09 04:21:40 +04:00
-- ::
-- ::
++ aeon ,@ud ::
++ agon (map ,[p=ship q=desk] ,[p=@ud q=@ud r=waks]) :: mergepts
2013-10-12 23:38:08 +04:00
++ ankh :: fs node (new)
2013-09-29 00:21:18 +04:00
$: p=cash :: recursive hash
q=(unit ,[p=cash q=*]) :: file
r=(map ,@ta ankh) :: folders
== ::
++ apex ,[p=@uvI q=(map ,@ta ,@uvI) r=(map ,@ta ,~)] :: node report (old)
2014-07-24 06:02:50 +04:00
++ ares (unit ,[p=term q=(list tank)]) :: possible error
2013-09-29 00:21:18 +04:00
++ 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
2013-09-29 00:21:18 +04:00
== ::
2014-06-07 22:36:31 +04:00
++ beam ,[[p=ship q=desk r=case] s=path] :: global name
2014-05-02 03:33:15 +04:00
++ beak ,[p=ship q=desk r=case] :: garnish with beak
2013-09-29 00:21:18 +04:00
++ 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
== ::
2014-07-17 22:27:14 +04:00
++ blob $% [%delta p=lobe q=lobe r=udon] :: delta on q
[%direct p=lobe q=* r=umph] ::
2014-07-18 00:04:18 +04:00
[%indirect p=lobe q=* r=udon s=lobe] ::
== ::
2013-09-29 00:21:18 +04:00
++ boat ,[(list slip) tart] :: user stage
++ boon :: fort output
$% [%beer p=ship q=@uvG] :: gained ownership
2014-07-24 06:02:50 +04:00
[%cake p=sock q=soap r=coop s=duct] :: e2e message result
[%coke p=sock q=soap r=cape s=duct] :: message result
2013-09-29 00:21:18 +04:00
[%mead p=lane q=rock] :: accept packet
[%milk p=sock q=soap r=*] :: accept message
2014-07-24 06:02:50 +04:00
[%mulk p=sock q=soap r=*] :: e2e pass message
2013-09-29 00:21:18 +04:00
[%ouzo p=lane q=rock] :: transmit packet
[%wine p=sock q=tape] :: notify user
== ::
++ bowl ,[p=(list gift) q=(unit boat)] :: app product
++ 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
== ::
++ cart ,[p=cash q=cash] :: hash change
2014-07-24 19:11:40 +04:00
++ care ?(%u %v %w %x %y %z) :: clay submode
2014-05-02 03:33:15 +04:00
++ case :: ship desk case spur
2013-09-29 00:21:18 +04:00
$% [%da p=@da] :: date
[%tas p=@tas] :: label
[%ud p=@ud] :: number
== ::
++ cash ,@uvH :: ankh hash
2014-07-23 22:25:53 +04:00
++ chum ,@uvI :: hashed passcode
2014-06-19 22:53:16 +04:00
++ clot :: symmetric record
2013-09-29 00:21:18 +04:00
$: yed=(unit ,[p=hand q=code]) :: outbound
heg=(map hand code) :: proposed
2013-09-29 00:21:18 +04:00
qim=(map hand code) :: inbound
== ::
++ coal ,* :: untyped vase
++ code ,@uvI :: symmetric key
++ cone :: reconfiguration
2013-12-15 11:07:57 +04:00
$% [& p=twig] :: transform
2013-09-29 00:21:18 +04:00
[| p=(list ,@tas)] :: alter
== ::
++ chum ,@uvI :: hashed passcode
2014-07-29 02:46:03 +04:00
++ claw :: startup chain
$: joy=(unit coal) :: local context
2013-09-29 00:21:18 +04:00
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
2014-07-23 22:25:53 +04:00
++ coal ,* :: untyped vase
++ code ,@uvI :: symmetric key
++ cone :: reconfiguration
$% [& p=twig] :: transform
[| p=(list ,@tas)] :: alter
== ::
2014-07-24 06:02:50 +04:00
++ coop (unit ares) :: e2e ack
2014-07-23 22:25:53 +04:00
++ 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
== ::
2014-03-20 05:05:42 +04:00
++ cred :: credential
$: hut=hoot :: client host
2014-04-23 21:02:36 +04:00
aut=(jug ,@tas ,@t) :: client identities
2014-03-20 05:05:42 +04:00
orx=oryx :: CSRF secret
acl=(unit ,@t) :: accept-language
2014-03-20 05:05:42 +04:00
cip=(each ,@if ,@is) :: client IP
cum=(map ,@tas ,*) :: custom dirt
== ::
2014-06-02 01:07:13 +04:00
++ cuff :: permissions
$: p=(unit (set monk)) :: readers
q=(set monk) :: authors
== ::
2014-06-04 03:39:28 +04:00
++ deed ,[p=@ q=step r=?] :: sig, stage, fake?
2013-09-29 00:21:18 +04:00
++ dome :: project state
$: ang=agon :: pedigree
2014-02-14 23:29:03 +04:00
ank=ankh :: state
2014-07-28 18:25:07 +04:00
let=@ud :: top id
2014-07-22 22:56:04 +04:00
hit=(map ,@ud tako) :: changes by id
2013-09-29 00:21:18 +04:00
lab=(map ,@tas ,@ud) :: labels
== ::
2014-07-21 07:15:02 +04:00
++ dore :: foreign contact
2013-09-29 00:21:18 +04:00
$: wod=road :: connection to
wyl=will :: inferred mirror
2014-06-19 22:53:16 +04:00
caq=clot :: symmetric key state
2013-09-29 00:21:18 +04:00
== ::
++ dove ,[p=@ud q=(map ,@ud ,@)] :: count hash 13-blocks
2014-03-26 04:48:22 +04:00
++ epic :: FCGI parameters
2014-07-09 11:37:47 +04:00
$: qix=(map ,@t ,@t) :: query
2014-03-26 04:48:22 +04:00
ced=cred :: client credentials
2014-08-02 03:39:15 +04:00
bem=beam :: original path
2014-03-26 04:48:22 +04:00
but=path :: ending
== ::
2013-09-29 00:21:18 +04:00
++ flap ,@uvH :: network packet id
++ flow :: packet connection
$: rtt=@dr :: decaying avg rtt
wid=@ud :: logical wdow msgs
== ::
2014-06-27 08:02:05 +04:00
++ fort :: formal state
2014-05-31 02:04:20 +04:00
$: %0 :: version
gad=duct :: client interface
2014-05-31 02:04:20 +04:00
hop=@da :: network boot date
2014-06-27 08:02:05 +04:00
ton=town :: security
2014-01-21 01:50:54 +04:00
zac=(map ship corn) :: flows by server
2013-09-29 00:21:18 +04:00
== ::
2014-03-12 23:50:39 +04:00
++ gank (each vase (list tank)) :: abstract result
2013-09-29 00:21:18 +04:00
++ gift :: one-way effect
$% [%$ p=vase] :: trivial output
[%cc p=(unit case)] :: change case
[%ck p=@tas] :: change desk
[%cs p=path] :: change spur
[%de p=@ud q=tank] :: debug/level
[%ex p=(unit vase) q=lath] :: exec/patch
2014-02-10 21:50:20 +04:00
::[%fd p=vase] :: fundamental down
::[%fo p=vase] :: fundamental forward
::[%fu p=vase] :: fundamental up
2013-09-29 00:21:18 +04:00
[%ha p=tank] :: single error
[%ho p=(list tank)] :: multiple error
[%la p=tank] :: single statement
[%lo p=(list tank)] :: multiple statement
[%mu p=type q=(list)] :: batch emit
[%mx p=(list gift)] :: batch gift
2014-03-06 00:21:52 +04:00
[%ok p=@ta q=nori] :: save changes
2014-07-24 19:11:40 +04:00
[%og p=@ta q=mizu] :: save direct
2013-09-29 00:21:18 +04:00
[%sc p=(unit skit)] :: stack library
[%sp p=(list lark)] :: spawn task(s)
[%sq p=ship q=@tas r=path s=*] :: send request
[%sr p=ship q=path r=*] :: send response
2013-09-29 00:21:18 +04:00
[%te p=(list ,@t)] :: dump lines
[%th p=@ud q=love] :: http response
2013-10-27 07:55:53 +04:00
[%tq p=path q=hiss] :: http request
2013-09-29 00:21:18 +04:00
[%va p=@tas q=(unit vase)] :: set/clear variable
2014-06-06 03:51:59 +04:00
[%xx p=curd] :: return card
[%xy p=path q=curd] :: push card
2014-09-11 03:35:03 +04:00
[%xz p=[p=ship q=path] q=ship r=mark s=zang]
2014-07-03 02:08:02 +04:00
[%zz p=path q=path r=curd] ::
2013-09-29 00:21:18 +04:00
== ::
2014-07-03 02:08:02 +04:00
++ zang :: XX evil hack
2014-07-03 22:14:22 +04:00
$% [%backlog p=path q=?(%da %dr %ud) r=@] ::
2014-07-03 02:08:02 +04:00
[%hola p=path] ::
$: %mess p=path ::
$= q ::
$% [%do p=@t] :: act
[%exp p=@t q=tank] :: code
[%say p=@t] :: speak
2014-08-01 06:44:49 +04:00
== == ::
[%tint p=ship] ::
== ::
2013-09-29 00:21:18 +04:00
++ gilt ,[@tas *] :: presumed gift
++ gens ,[p=lang q=gcos] :: general identity
++ germ ?(%init %fine %that %this %mate %meld) :: merge style
2013-09-29 00:21:18 +04:00
++ 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
2013-09-29 00:21:18 +04:00
== ::
++ goad :: common note
$% [%eg p=riot] :: simple result
[%gr p=mark q=*] :: gall rush/rust
2013-10-27 07:55:53 +04:00
[%hp p=httr] :: http response
2014-03-12 23:50:39 +04:00
:: [%ht p=@ud q=scab r=cred s=moth] :: http request
2013-09-29 00:21:18 +04:00
[%it p=~] :: interrupt event
[%lq p=ship q=path r=*] :: client request
2013-09-29 00:21:18 +04:00
[%ly p=newt q=tape] :: lifecycle event
[%ow p=cape] :: one-way reaction
[%rt p=(unit)] :: roundtrip response
2013-09-29 00:21:18 +04:00
[%up p=@t] :: prompt response
[%wa ~] :: alarm
== ::
++ goal :: app request
$% [%$ p=type] :: open for input
[%do p=vase q=vase] :: call gate sample
[%eg p=kite] :: single request
2014-05-02 03:33:15 +04:00
[%es p=ship q=desk r=rave] :: subscription
2014-07-03 02:08:02 +04:00
[%gr ~] :: gall response
2013-09-29 00:21:18 +04:00
[%ht p=(list rout)] :: http server
2013-10-27 07:55:53 +04:00
[%hp ~] :: http response
[%lq p=@tas] :: listen for service
[%ow ~] :: one-way reaction
[%rt ~] :: roundtrip response
[%up p=prod] :: user prompt
2013-09-29 00:21:18 +04:00
[%wa p=@da] :: alarm
== ::
++ govt path :: country/postcode
++ hand ,@uvH :: hash of code
2014-04-03 05:06:45 +04:00
++ hart ,[p=? q=(unit ,@ud) r=host] :: http sec/port/host
2014-03-05 23:00:27 +04:00
++ hate ,[p=purl q=@p r=moth] :: semi-cooked request
2014-03-12 23:50:39 +04:00
++ heir ,[p=@ud q=mess r=(unit love)] :: status/headers/data
2014-02-27 05:58:40 +04:00
++ hiss ,[p=purl q=moth] :: outbound request
2013-09-29 00:21:18 +04:00
++ hist ,[p=@ud q=(list ,@t)] :: depth texts
2014-03-20 05:05:42 +04:00
++ hole ,@t :: session identity
2014-07-09 11:37:47 +04:00
++ hoot ,[p=? q=(unit ,@ud) r=host] :: secure/port/host
2013-09-29 00:21:18 +04:00
++ hort ,[p=(unit ,@ud) q=host] :: http port/host
++ host $%([& p=(list ,@t)] [| p=@if]) :: http host
2015-01-15 04:47:51 +03:00
++ hoke %+ each ,[%localhost ~] :: local host
?(%.0.0.0.0 %.127.0.0.1) ::
2013-09-29 00:21:18 +04:00
++ httq :: raw http request
2014-03-12 23:50:39 +04:00
$: p=meth :: method
2013-09-29 00:21:18 +04:00
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 ::
== ::
2014-05-02 03:33:15 +04:00
++ kite ,[p=care q=case r=ship s=desk t=spur] :: parsed global name
2014-06-19 07:27:36 +04:00
++ json :: normal json value
$| ~ :: null
2014-06-19 07:27:36 +04:00
$% [%a p=(list json)] :: array
[%b p=?] :: boolean
[%o p=(map ,@t json)] :: object
[%n p=@ta] :: number
2014-12-12 03:01:56 +03:00
[%s p=@t] :: string
2013-09-29 00:21:18 +04:00
== ::
++ lamb :: short path
$% [& p=@tas] :: auto
2013-12-15 11:07:57 +04:00
[| p=twig] :: manual
2013-09-29 00:21:18 +04:00
== ::
++ lane :: packet route
2014-06-04 01:01:40 +04:00
$% [%if p=@da q=@ud r=@if] :: IP4/public UDP/addr
2013-09-29 00:21:18 +04:00
[%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
2013-12-15 11:07:57 +04:00
[%0 p=lass q=lamb r=(list cone) s=twig] :: command
[%1 p=twig] :: generator
[%2 p=twig] :: filter
2013-09-29 00:21:18 +04:00
== ::
++ lawn (list lath) ::
++ lice ,[p=ship q=buck] :: full license
++ life ,@ud :: regime number
++ lint (list rock) :: fragment array
2014-07-17 22:27:14 +04:00
++ lobe ,@ :: blob ref
2013-09-29 00:21:18 +04:00
++ love $% :: http response
[%ham p=manx] :: html node
2014-03-13 05:04:58 +04:00
[%mid p=mite q=octs] :: mime-typed data
2013-09-29 00:21:18 +04:00
[%raw p=httr] :: raw http response
2014-03-12 23:50:39 +04:00
[%wan p=wain] :: text lines
[%zap p=@ud q=(list tank)] :: status/error
2013-09-29 00:21:18 +04:00
== ::
2014-05-20 21:33:59 +04:00
++ maki ,[p=@ta q=@ta r=@ta s=path] ::
2013-09-29 00:21:18 +04:00
++ 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
2014-07-24 06:02:50 +04:00
[%buck p=coop q=flap r=@dr] :: e2e ack
[%bond p=life q=path r=@ud s=*] :: message
2014-07-24 06:02:50 +04:00
[%bund p=life q=path r=@ud s=*] :: e2e message
2013-09-29 00:21:18 +04:00
[%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
== ::
2014-03-12 23:50:39 +04:00
++ meth :: http methods
$? %conn :: CONNECT
%delt :: DELETE
%get :: GET
%head :: HEAD
%opts :: OPTIONS
%post :: POST
%put :: PUT
%trac :: TRACE
2014-05-26 22:59:21 +04:00
== ::
2014-03-13 05:04:58 +04:00
++ mite (list ,@ta) :: mime type
2013-09-29 00:21:18 +04:00
++ miso :: ankh delta
$% [%del p=*] :: delete
[%ins p=*] :: insert
[%mut p=udon] :: mutate
== ::
2014-07-24 19:11:40 +04:00
++ mizu ,[p=@u q=(map ,@ud tako) r=rang] :: new state
2013-09-29 00:21:18 +04:00
++ moar ,[p=@ud q=@ud] :: normal change range
++ moat ,[p=case q=case r=path] :: change range
2013-09-29 00:21:18 +04:00
++ 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
++ nose :: response, kernel
2014-01-04 11:28:16 +04:00
$? [%$ p=(unit ,[p=tutu q=(list)])] :: standard input
goad ::
2013-09-29 00:21:18 +04:00
== ::
++ note :: response, user
$? [%$ p=(unit ,[p=type q=(list)])] :: standard input
[%do p=vase] :: execution result
goad ::
== ::
++ nori :: repository action
$% [& q=soba] :: delta
2013-09-29 00:21:18 +04:00
[| p=@tas] :: label
== ::
++ octs ,[p=@ud q=@t] :: octet-stream
2014-03-04 23:17:34 +04:00
++ oryx ,@t :: CSRF secret
2013-09-29 00:21:18 +04:00
++ pact path :: routed path
++ pail ?(%none %warm %cold) :: connection status
2014-05-30 02:00:13 +04:00
++ plan (trel view (pair ,@da (unit ,@dr)) path) :: subscription
2013-09-29 00:21:18 +04:00
++ plea ,[p=@ud q=[p=? q=@t]] :: live prompt
2014-03-04 02:47:59 +04:00
++ pork ,[p=(unit ,@ta) q=(list ,@t)] :: fully parsed url
2014-03-20 05:05:42 +04:00
++ pred ,[p=@ta q=@tas r=@ta ~] :: proto-path
2013-09-29 00:21:18 +04:00
++ prod ,[p=prom q=tape r=tape] :: prompt
++ prom ?(%text %pass %none) :: format type
++ 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
2013-12-15 11:07:57 +04:00
r=(map ,[p=* q=coal] coal) :: by (soft) twig
2013-09-29 00:21:18 +04:00
== ::
2014-03-12 23:50:39 +04:00
++ quay (list ,[p=@t q=@t]) :: parsed url query
2013-09-29 00:21:18 +04:00
++ quri :: request-uri
$% [& p=purl] :: absolute
[| p=pork q=quay] :: relative
== ::
++ race :: inbound stream
$: did=@ud :: filled sequence
2014-07-26 06:10:24 +04:00
dod=? :: not processing
bum=(map ,@ud ares) :: nacks
mis=(map ,@ud ,[p=cape q=lane r=flap s=(unit)]) :: misordered
== ::
2013-09-29 00:21:18 +04:00
++ rank ?(%czar %king %duke %earl %pawn) :: ship width class
2014-07-22 22:56:04 +04:00
++ rang $: hut=(map tako yaki) ::
lat=(map lobe blob) ::
== ::
2013-09-29 00:21:18 +04:00
++ rant :: namespace binding
$: p=[p=care q=case r=@tas] :: clade release book
q=path :: spur
r=* :: data
== ::
2013-09-29 00:21:18 +04:00
++ rave :: general request
$% [& p=mood] :: single request
[| p=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
2013-10-10 06:45:57 +04:00
lew=will :: will of friend
2013-09-29 00:21:18 +04:00
== ::
++ 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
2014-07-24 19:11:40 +04:00
++ saba ,[p=ship q=@tas r=moar s=dome] :: patch/merge
2014-06-26 16:18:30 +04:00
++ sack ,[p=ship q=ship] :: incoming [our his]
2014-04-10 04:28:22 +04:00
++ sufi :: domestic host
2013-09-29 00:21:18 +04:00
$: hoy=(list ship) :: hierarchy
2014-04-10 04:28:22 +04:00
val=wund :: private keys
2013-09-29 00:21:18 +04:00
law=will :: server will
seh=(map hand ,[p=ship q=@da]) :: key cache
2014-07-21 07:15:02 +04:00
hoc=(map ship dore) :: neighborhood
2013-09-29 00:21:18 +04:00
== ::
++ 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
== ::
2013-09-29 00:21:18 +04:00
++ 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
2013-10-27 07:55:53 +04:00
++ slip ,[p=path q=goal] :: traceable request
2013-09-29 00:21:18 +04:00
++ 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
2013-09-29 00:21:18 +04:00
++ soul :: packet in travel
$: gom=soup :: message identity
nux=@ud :: xmission count
liv=? :: deemed live
lys=@da :: last sent
pac=rock :: packet data
== ::
++ soba ,[p=cart q=(list ,[p=path q=miso])] :: delta
2014-06-26 16:18:30 +04:00
++ sock ,[p=ship q=ship] :: outgoing [from to]
2014-05-02 03:33:15 +04:00
++ spur path :: ship desk case spur
2013-09-29 00:21:18 +04:00
++ step ,[p=bray q=gens r=pass] :: identity stage
2014-07-17 22:27:14 +04:00
++ tako ,@ :: yaki ref
2014-01-06 05:52:37 +04:00
++ tart $+([@da path note] bowl) :: process core
2013-09-29 00:21:18 +04:00
++ tick ,@ud :: process id
2014-03-06 00:21:52 +04:00
++ toro ,[p=@ta q=nori] :: general change
2014-06-27 08:02:05 +04:00
++ town :: all security state
2013-09-29 00:21:18 +04:00
$: lit=@ud :: imperial modulus
any=@ :: entropy
2014-04-10 04:28:22 +04:00
urb=(map ship sufi) :: all keys and routes
2014-07-03 02:08:02 +04:00
fak=? ::
2013-09-29 00:21:18 +04:00
== ::
2014-03-12 23:50:39 +04:00
++ tube ,[p=@ta q=@ta r=@ta s=path] :: canonical path
2014-01-04 11:28:16 +04:00
++ tutu ,* :: presumed type
2014-07-17 22:27:14 +04:00
++ yaki ,[p=(list tako) q=(map path lobe) r=tako t=@da] :: commit
2014-05-30 02:00:13 +04:00
++ view ?(%u %v %w %x %y %z) :: view mode
++ waks (map path woof) :: list file states
2013-09-29 00:21:18 +04:00
++ what :: logical identity
$% [%anon ~] :: anonymous
[%lady p=whom] :: female person ()
[%lord p=whom] :: male person []
2013-11-08 04:34:44 +04:00
[%punk p=sect q=@t] :: opaque handle ""
2013-09-29 00:21:18 +04:00
== ::
++ 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
2013-09-29 00:21:18 +04:00
++ will (list deed) :: certificate
2015-01-27 03:25:27 +03:00
++ zuse %310 :: hoon/zuse kelvin
2013-09-29 00:21:18 +04:00
--