!: :: %gall, agent execution !? 163 :::: |= pit=vase => =~ |% :::::::::::::::::::::::::::::::::::::::::::::::::::::: rest of arvo :::::::::::::::::::::::::::::::::::::::::::::::::::::: ++ volt ?(%low %high) :: voltage ++ torc $|(?(%iron %gold) [%lead p=ship]) :: security control ++ roon :: reverse ames msg $% [%d p=mark q=*] :: diff (diff) [%x ~] :: == :: ++ rook :: forward ames msg $% [%m p=mark q=*] :: message [%s p=path] :: subscribe [%u ~] :: cancel/unsubscribe == :: -- :: |% :::::::::::::::::::::::::::::::::::::::::::::::::::::: local arvo :::::::::::::::::::::::::::::::::::::::::::::::::::::: ++ cote :: ++ap note $% [%meta p=@tas q=vase] :: [%send p=ship q=cush] :: == :: ++ cove (pair duct (mold cote cuft)) :: internal move ++ cute (pair bone (mold cote cuft)) :: internal move ++ move ,[p=duct q=(mold note-arvo gift-arvo)] :: typed move -- :: |% :::::::::::::::::::::::::::::::::::::::::::::::::::::: %gall state :::::::::::::::::::::::::::::::::::::::::::::::::::::: ++ axle :: all state $: %0 :: state version pol=(map ship mast) :: apps by ship == :: ++ gest :: subscriber data $: sup=(map bone (pair ship path)) :: subscribers pus=(jug path bone) :: srebircsbus qel=(map bone ,@ud) :: queue meter == :: ++ mast :: ship state $: sys=duct :: system duct sap=(map ship scad) :: foreign contacts bum=(map dude seat) :: running agents wub=(map dude sofa) :: waiting queue == :: ++ ffuc :: new cuff $: p=(unit (set ship)) :: disclosing to q=ship :: attributed to == :: ++ prey (pair volt ffuc) :: privilege ++ scad :: foreign connection $: p=@ud :: index q=(map duct ,@ud) :: by duct r=(map ,@ud duct) :: by index == :: ++ scar :: opaque input $: p=@ud :: bone sequence q=(map duct bone) :: by duct r=(map bone duct) :: by bone == :: ++ seat :: agent state $: mom=duct :: control duct liv=? :: unstopped toc=torc :: privilege tyc=stic :: statistics ged=gest :: subscribers hav=vase :: running state pup=scup :: update control zam=scar :: opaque ducts == :: ++ sofa :: queue for blocked $: kys=(qeu (trel duct prey club)) :: queued kisses == :: ++ stic :: statistics $: act=@ud :: change number eny=@uvI :: entropy lat=@da :: time == :: -- :: :::::::::::::::::::::::::::::::::::::::::::::::::::::: vane header :::::::::::::::::::::::::::::::::::::::::::::::::::::: . == =| all=axle :: all vane state |= $: now=@da :: urban time eny=@uvI :: entropy ska=sled :: activate == :: opaque core |% :::::::::::::::::::::::::::::::::::::::::::::::::::::: state machine :::::::::::::::::::::::::::::::::::::::::::::::::::::: ++ mo |_ $: $: our=@p hen=duct moz=(list move) == mast == ++ mo-abed :: initialize |= [our=@p hen=duct] ^+ +> %_ +> our our hen hen +<+ (~(got by pol.all) our) == :: ++ mo-abet :: resolve to ^- [(list move) _+>+] :_ +>+(pol.all (~(put by pol.all) our +<+)) %- flop %+ turn moz |= a=move ?. ?=(%pass -.q.a) a [p.a %pass [(scot %p our) p.q.a] q.q.a] :: ++ mo-conf :: configure |= [dap=dude lum=culm] (mo-boot dap ?:((~(has by bum) dap) %old %new) p.lum) :: ++ mo-pass :: standard pass |= [pax=path noh=note-arvo] %_(+> moz :_(moz [hen %pass pax noh])) :: ++ mo-give |= git=gift-gall %_(+> moz :_(moz [hen %give git])) :: ++ mo-okay :: valid agent core |= vax=vase ^- ? (~(nest ut -:!>(*hide)) %| p:(slot 12 vax)) :: ++ mo-boom :: complete new boot |= [dap=dude pup=scup dep=@uvH gux=(each gage tang)] ^+ +> ?- -.gux %| (mo-give %onto %| p.gux) %& ?> ?=(@ p.p.gux) ?. (mo-okay q.p.gux) (mo-give %onto %| [%leaf "{}: bogus core"]~) =. +> (mo-bold dap dep) =. +> (mo-born dap pup q.p.gux) =+ old=+>.$ =+ wag=(ap-prop:(ap-abed:ap dap [%high [~ our]]) ~) ?^ -.wag =. +>.$ old (mo-give %onto %| u.-.wag) =. +>.$ ap-abet:+.wag (mo-give:(mo-claw dap) %onto %& dap %boot now) == :: ++ mo-born :: new seat |= [dap=dude pup=scup hav=vase] =+ sat=*seat %_ +>.$ bum %+ ~(put by bum) dap %_ sat mom hen pup pup hav hav p.zam 1 q.zam [[[~ ~] 0] ~ ~] r.zam [[0 [~ ~]] ~ ~] == == :: ++ mo-boon :: complete old boot |= [dap=dude pup=scup dep=@uvH gux=(each gage tang)] ^+ +> ?. (~(has by bum) dap) ~& [%gall-old-boon dap] +> =. +> (mo-bold dap dep) ?- -.gux %| (mo-give %onto %| p.gux) %& ?> ?=(@ p.p.gux) ap-abet:(ap-peep:(ap-abed:ap dap [%high [~ our]]) q.p.gux) == :: ++ mo-bold :: wait for dep |= [dap=dude dep=@uvH] ^+ +> %+ mo-pass [%sys %dep dap ~] [%f %wasp our dep] :: ++ mo-boot :: create ship |= [dap=dude how=?(%new %old) pup=scup] ^+ +> :: ~& [%mo-boot dap how pup] %+ mo-pass [%sys how dap (scot %p p.pup) q.pup ~] =+ bek=[p.pup q.pup [%da now]] ^- note-arvo [%f %exec our bek `[%boil %core [bek [dap %ape ~]] ~]] :: ++ mo-away :: foreign request |= [him=ship caz=cush] :: ^+ +> :: ~& [%mo-away him caz] ?: ?=(%pump -.q.caz) :: :: you'd think this would send an ack for the diff :: that caused this pump. it would, but we already :: sent it when we got the diff in ++mo-cyst. then :: we'd have to save the network duct and connect it :: to this returning pump. :: +> =^ num +>.$ (mo-bale him) =+ ^= roc ^- rook ?- -.q.caz %poke [%m p.p.q.caz q.q.p.q.caz] %pull [%u ~] %peer [%s p.q.caz] == %+ mo-pass [%sys %way -.q.caz ~] `note-arvo`[%a %wont [our him] [%q %ge p.caz ~] [num roc]] :: ++ mo-baal :: error convert a |= art=(unit ares) ^- ares ?~(art ~ ?~(u.art `[%blank ~] u.art)) :: ++ mo-baba :: error convert b |= ars=ares ^- (unit tang) ?~ ars ~ `[[%leaf (trip p.u.ars)] q.u.ars] :: ++ mo-awed :: foreign response |= [him=ship why=?(%peer %poke %pull) art=(unit ares)] ^+ +> :: ~& [%mo-awed him why art] =+ tug=(mo-baba (mo-baal art)) ?- why %peer (mo-give %unto %reap tug) %poke (mo-give %unto %coup tug) %pull ~& [%pull-fail tug] +>.$ == :: ++ mo-bale :: assign outbone |= him=ship ^- [@ud _+>] =+ sad=(fall (~(get by sap) him) `scad`[1 ~ ~]) =+ nom=(~(get by q.sad) hen) ?^ nom [u.nom +>.$] :- p.sad %_ +>.$ sap %+ ~(put by sap) him %_ sad p +(p.sad) q (~(put by q.sad) hen p.sad) r (~(put by r.sad) p.sad hen) == == :: ++ mo-ball :: outbone by index |= [him=ship num=@ud] ^- duct (~(got by r:(~(got by sap) him)) num) :: ++ mo-come :: handle locally |= [her=ship caz=cush] ^+ +> =+ pry=`prey`[%high [~ her]] (mo-club p.caz pry q.caz) :: ++ mo-coup :: back from mo-away |= [dap=dude him=ship cup=ares] %^ mo-give %unto %coup ?~ cup ~ [~ `tang`[[%leaf (trip p.u.cup)] q.u.cup]] :: ++ mo-cyst :: take in /sys |= [pax=path sih=sign-arvo] ^+ +> ?+ -.pax !! %dep :: update ?> ?=([%f %news *] sih) ?> ?=([@ ~] t.pax) =+ sot=(~(get by bum) i.t.pax) ?~ sot ~& [%mo-cyst-none i.t.pax] +>.$ (mo-boot i.t.pax %old pup.u.sot) :: %new ?> ?=([%f %made *] sih) ?> ?=([@ @ @ ~] t.pax) (mo-boom i.t.pax [(slav %p i.t.t.pax) i.t.t.t.pax] +>.sih) :: %old :: reload old ?> ?=([%f %made *] sih) ?> ?=([@ @ @ ~] t.pax) (mo-boon i.t.pax [(slav %p i.t.t.pax) i.t.t.t.pax] +>.sih) :: %red :: diff ack ?> ?=([@ @ @ ~] t.pax) ?> ?=([%a %woot *] sih) =+ :* him=(slav %p i.t.pax) dap=i.t.t.pax num=(slav %ud i.t.t.t.pax) == => .(pax `path`[%req t.pax]) ?~ q.+>.sih (mo-pass [%sys pax] %g %deal [him our] dap %pump ~) ~& [%diff-bad-ack q.+>.sih] :: should not happen =. +>.$ (mo-pass [%sys pax] %g %deal [him our] dap %pull ~) (mo-pass [%sys pax] %a %wont [our him] [%q %gh dap ~] [num %x ~]) :: %rep :: reverse request ?> ?=([@ @ @ ~] t.pax) ?> ?=([%f %made *] sih) =+ :* him=(slav %p i.t.pax) dap=i.t.t.pax num=(slav %ud i.t.t.t.pax) == ?- -.q.+>.sih %| (mo-give %mack `p.q.+>.sih) :: XX should crash %& ?> ?=(@ p.p.q.+>.sih) =. +>.$ (mo-give %mack ~) :: XX pump should ack (mo-give(hen (mo-ball him num)) %unto %diff `cage`p.q.+>.sih) == :: %req :: inbound request ?> ?=([@ @ @ ~] t.pax) =+ :* him=(slav %p i.t.pax) dap=i.t.t.pax num=(slav %ud i.t.t.t.pax) == ?: ?=([%f %made *] sih) ?- -.q.+>.sih %| (mo-give %mack `p.q.+>.sih) :: XX should crash %& ?> ?=(@ p.p.q.+>.sih) (mo-pass [%sys pax] %g %deal [him our] i.t.t.pax %poke p.q.+>.sih) == ?: ?=([%a %woot *] sih) +>.$ :: quit ack, boring ?> ?=([%g %unto *] sih) =+ cuf=`cuft`+>.sih ?- -.cuf %coup (mo-give %mack p.cuf) %diff %+ mo-pass [%sys %red t.pax] [%a %wont [our him] [%q %gh dap ~] [num %d p.p.cuf q.q.p.cuf]] %quit %+ mo-pass [%sys pax] [%a %wont [our him] [%q %gh dap ~] [num %x ~]] %reap (mo-give %mack p.cuf) == :: %way :: outbound request ?> ?=([%a %woot *] sih) ?> ?=([@ ~] t.pax) %- mo-awed :* p.+>.sih (?(%peer %poke %pull) i.t.pax) +>+.sih == == :: ++ mo-cook :: take in /use |= [pax=path hin=(hypo sign-arvo)] ^+ +> ?. ?=([@ @ ?(%inn %out) *] pax) ~& [%mo-cook-bad-pax pax] !! =+ dap=`@tas`i.pax =+ pry=`prey`[%high [~ (slav %p i.t.pax)]] =+ pap=(ap-abed:ap dap pry) =+ vax=(slot 3 `vase`hin) ?- i.t.t.pax %inn ap-abet:(ap-pour:pap t.t.t.pax (slot 3 `vase`hin)) %out ?. ?=([%g %unto *] q.hin) ~& [%mo-cook-weird q.hin] ~& [%mo-cook-weird-path pax] +>.$ ap-abet:(ap-pout:pap t.t.t.pax +>.q.hin) == :: ++ mo-claw :: clear queue |= dap=dude ^+ +> ?. (~(has by bum) dap) +> =+ suf=(~(get by wub) dap) =+ neh=hen ?~ suf +>.$ |- ^+ +>.^$ ?: =(~ kys.u.suf) +>.^$(hen neh, wub (~(del by wub) dap)) =^ lep kys.u.suf [p q]:~(get to kys.u.suf) :: ~& [%mo-claw-play dap r.lep] $(+>.^$ ap-abet:(ap-club:(ap-abed:ap(hen p.lep) dap q.lep) r.lep)) :: ++ mo-beak :: build beak |= dap=dude ^- beak :: =+ pup=pup:(~(got by bum) dap) :: [p.pup q.pup [%da now]] :: XX this is wrong; save the build case [our %base %da now] :: XX really wrong :: ++ mo-club :: local action |= [dap=dude pry=prey cub=club] ^+ +> ?: |(!(~(has by bum) dap) (~(has by wub) dap)) :: ~& [%mo-club-qeu dap cub] =+ syf=(fall (~(get by wub) dap) *sofa) +>.$(wub (~(put by wub) dap syf(kys (~(put to kys.syf) [hen pry cub])))) ap-abet:(ap-club:(ap-abed:ap dap pry) cub) :: ++ mo-gawk :: ames forward |= [him=@p dap=dude num=@ud rok=rook] %+ mo-pass [%sys %req (scot %p him) dap (scot %ud num) ~] ^- note-arvo ?- -.rok %m [%f %exec our (mo-beak dap) ~ %vale p.rok our q.rok] %s [%g %deal [him our] dap %peer p.rok] %u [%g %deal [him our] dap %pull ~] == :: ++ mo-gawd :: ames backward |= [him=@p dap=dude num=@ud ron=roon] ?- -.ron %d %+ mo-pass [%sys %rep (scot %p him) dap (scot %ud num) ~] [%f %exec our (mo-beak dap) ~ %vale p.ron our q.ron] :: %x (mo-give(hen (mo-ball him num)) %unto %quit ~) == :: ++ ap :: agent engine |_ $: $: dap=dude pry=prey ost=bone zip=(list cute) dub=(list (each suss tang)) == seat == :: ++ ap-abed :: initialize |= [dap=dude pry=prey] ^+ +> =: ^dap dap ^pry pry +>+<+ `seat`(~(got by bum) dap) == =+ unt=(~(get by q.zam) hen) =: act.tyc +(act.tyc) eny.tyc (shax (mix (add dap act.tyc) eny)) lat.tyc now == ?^ unt +>.$(ost u.unt) %= +>.$ ost p.zam p.zam +(p.zam) q.zam (~(put by q.zam) hen p.zam) r.zam (~(put by r.zam) p.zam hen) == :: ++ ap-abet :: resolve ^+ +> => ap-abut %_ +> bum (~(put by bum) dap +<+) moz :(weld (turn zip ap-aver) (turn dub ap-avid) moz) == :: ++ ap-abut :: track queue ^+ . =+ [pyz=zip ful=*(set bone)] |- ^+ +> ?~ pyz =+ ded=(~(tap in ful) ~) |- ^+ +>.^$ ?~ ded +>.^$ $(ded t.ded, +>.^$ ap-kill(ost i.ded)) ?. ?=([%give %diff *] q.i.pyz) $(pyz t.pyz) =^ vad +> ap-fill(ost p.i.pyz) $(pyz t.pyz, ful ?:(vad ful (~(put in ful) p.i.pyz))) :: ++ ap-aver :: cute to move |= cov=cute ^- move :- (~(got by r.zam) p.cov) ?- -.q.cov ?(%slip %sick) !! %give ?<(=(0 p.cov) [%give %unto p.q.cov]) %pass :+ %pass `path`[%use dap p.q.cov] ?- -.q.q.cov %send `note-arvo`[%g %deal [our p.q.q.cov] q.q.q.cov] %meta `note-arvo`[`@tas`p.q.q.cov %meta `vase`q.q.q.cov] == == :: ++ ap-avid :: onto results |=([a=(each suss tang)] [hen %give %onto a]) :: ++ ap-call :: call into server |= [cog=term arg=vase] ^- [(unit tang) _+>] =. +> ap-hide =+ arm=(ap-farm cog) ?: ?=(%| -.arm) [`p.arm +>.$] =+ zem=(ap-slam cog p.arm arg) ?: ?=(%| -.zem) [`p.zem +>.$] (ap-sake p.zem) :: ++ ap-club :: apply effect |= cub=club ^+ +> ?- -.cub %poke (ap-poke +.cub) %peer (ap-peer +.cub) %pull ap-pull %pump ap-fall == :: ++ ap-diff :: pour a diff |= [her=ship pax=path cag=cage] =. q.cag (spec q.cag) =+ cug=(ap-find [%diff p.cag pax]) ?~ cug (ap-pump:(ap-lame %diff (ap-suck "pour: no diff")) | her pax) =+ ^= arg ^- vase %- slop ?: =(0 p.u.cug) [!>([`@ud`ost `@p`q.q.pry `path`+.pax]) !>(cag)] [!>([`@ud`ost `@p`q.q.pry (slag (dec p.u.cug) `path`+.pax)]) q.cag] =^ cam +>.$ (ap-call q.u.cug arg) ?^ cam (ap-pump:(ap-lame q.u.cug u.cam) | her pax) (ap-pump & her pax) :: ++ ap-pump :: break subscription |= [oak=? her=ship pax=path] =+ way=[(scot %p her) %out pax] :: ~& [%ap-pump-path oak pax] ?: oak (ap-pass way %send her -.pax %pump ~) (ap-pass:(ap-give %quit ~) way %send her -.pax %pull ~) :: ++ ap-fall :: drop from queue ^+ . =+ soy=(~(get by qel.ged) ost) ?: |(?=(~ soy) =(0 u.soy)) ~& [%ap-fill-under [our dap] q.q.pry ost] + =. u.soy (dec u.soy) :: ~& [%ap-fill-sub [[our dap] q.q.pry ost] u.soy] ?: =(0 u.soy) +(qel.ged (~(del by qel.ged) ost)) +(qel.ged (~(put by qel.ged) ost u.soy)) :: ++ ap-farm :: produce arm |= cog=term ^- (each vase tang) =+ puz=(mule |.((~(mint ut p.hav) [%noun [%cnzy cog]]))) ?: ?=(%| -.puz) [%| p.puz] =+ ton=(mock [q.hav q.p.puz] ap-sled) ?- -.ton %0 [%& p.p.puz p.ton] %1 [%| (turn p.ton |=(a=* (smyt (path a))))] %2 [%| p.ton] == :: ++ ap-fill :: add to queue ^- [? _.] =+ suy=(fall (~(get by qel.ged) ost) 0) ?: =(8 suy) ~& [%ap-fill-full [our dap] q.q.pry ost] [%| +] :: ~? !=(8 suy) [%ap-fill-add [[our dap] q.q.pry ost] +(suy)] [%& +(qel.ged (~(put by qel.ged) ost +(suy)))] :: ++ ap-find :: general arm |= [cog=term pax=path] =+ dep=0 |- ^- (unit (pair ,@ud term)) =+ ^= spu ?~ pax ~ $(pax t.pax, dep +(dep), cog (ap-hype cog i.pax)) ?^ spu spu ?.((ap-fond cog) ~ `[dep cog]) :: ++ ap-fond :: check for arm |= cog=term ^- ? (slob cog p.hav) :: ++ ap-give :: return result |= cit=cuft ^+ +> +>(zip :_(zip [ost %give cit])) :: ++ ap-hide :: set up hide %_ . +12.q.hav ^- hide :* :* our dap ~ == ~ sup.ged pus.ged tyc == == :: ++ ap-hype :: hyphenate |=([a=term b=term] `term`(cat 3 a (cat 3 '-' b))) :: ++ ap-move :: process each move |= vax=vase ^- (each cute tang) ?@ q.vax [%| (ap-suck "move: invalid move (atom)")] ?^ -.q.vax [%| (ap-suck "move: invalid move (bone)")] ?@ +.q.vax [%| (ap-suck "move: invalid move (card)")] =+ hun=(~(get by r.zam) -.q.vax) ?. (~(has by r.zam) -.q.vax) [%| (ap-suck "move: invalid card (bone {<-.q.vax>})")] =+ cav=(slot 3 (spec (slot 3 vax))) ?+ +<.q.vax (ap-move-pass -.q.vax +<.q.vax cav) %diff (ap-move-diff -.q.vax cav) %peer (ap-move-peer -.q.vax cav) %pull (ap-move-pull -.q.vax cav) %poke (ap-move-poke -.q.vax cav) %send (ap-move-send -.q.vax cav) %quit (ap-move-quit -.q.vax cav) == :: ++ ap-move-quit :: give quit move |= [sto=bone vax=vase] ^- (each cute tang) ?^ q.vax [%| (ap-suck "move: improper quit")] [%& `cute`[sto %give `cuft`[%quit ~]]] :: ++ ap-move-diff :: give diff move |= [sto=bone vax=vase] =. vax (spec vax) ^- (each cute tang) ?. &(?=(^ q.vax) ?=(@ -.q.vax) ((sane %tas) -.q.vax)) [%| (ap-suck "move: improper diff")] [%& sto %give %diff `cage`[-.q.vax (slot 3 (spec vax))]] :: ++ ap-move-mess :: extract path, target |= vax=vase ^- (each (trel path ship term) tang) ?. ?& ?=([p=* [q=@ r=@] s=*] q.vax) (gte 1 (met 7 q.q.vax)) == [%| (ap-suck "move: malformed target")] =+ pux=((soft path) p.q.vax) ?. &(?=(^ pux) (levy u.pux (sane %ta))) [%| (ap-suck "move: malformed path")] [%& [(scot %p q.q.vax) %out r.q.vax u.pux] q.q.vax r.q.vax] :: ++ ap-move-pass :: pass general move |= [sto=bone wut=* vax=vase] ^- (each cute tang) ?. &(?=(@ wut) ((sane %tas) wut)) [%| (ap-suck "move: malformed card")] =+ pux=((soft path) -.q.vax) ?. &(?=(^ pux) (levy u.pux (sane %ta))) [%| (ap-suck "move: malformed path")] =+ huj=(ap-vain wut) ?~ huj [%| (ap-suck "move: unknown note {<`@tas`wut>}")] :^ %& sto %pass :- [(scot %p q.q.pry) %inn u.pux] [%meta u.huj (slop (ap-term %tas wut) (slot 3 vax))] :: ++ ap-move-poke :: pass %poke |= [sto=bone vax=vase] ^- (each cute tang) =+ yep=(ap-move-mess vax) ?: ?=(%| -.yep) yep =+ gaw=(slot 7 vax) ?. &(?=([p=@ q=*] q.gaw) ((sane %tas) p.q.gaw)) [%| (ap-suck "poke: malformed cage")] :^ %& sto %pass :- p.p.yep [%send q.p.yep r.p.yep %poke p.q.gaw (slot 3 (spec gaw))] :: ++ ap-move-peer :: pass %peer |= [sto=bone vax=vase] ^- (each cute tang) =+ yep=(ap-move-mess vax) ?: ?=(%| -.yep) yep =+ pux=((soft path) +>.q.vax) ?. &(?=(^ pux) (levy u.pux (sane %ta))) [%| (ap-suck "peer: malformed path")] :^ %& sto %pass :- p.p.yep [%send q.p.yep r.p.yep %peer u.pux] :: ++ ap-move-pull :: pass %pull |= [sto=bone vax=vase] ^- (each cute tang) =+ yep=(ap-move-mess vax) ?: ?=(%| -.yep) yep ?. =(~ +>.q.vax) [%| (ap-suck "pull: malformed card")] :^ %& sto %pass :- p.p.yep [%send q.p.yep r.p.yep %pull ~] :: ++ ap-move-send :: pass gall action |= [sto=bone vax=vase] ^- (each cute tang) ?. ?& ?=([p=* [q=@ r=@] [s=@ t=*]] q.vax) (gte 1 (met 7 q.q.vax)) ((sane %tas) r.q.vax) == [%| (ap-suck "move: malformed send")] =+ pux=((soft path) p.q.vax) ?. &(?=(^ pux) (levy u.pux (sane %ta))) [%| (ap-suck "move: malformed path")] ?: ?=(%poke s.q.vax) =+ gav=(spec (slot 7 vax)) ?> =(%poke -.q.gav) ?. ?& ?=([p=@ q=*] t.q.vax) ((sane %tas) p.t.q.vax) == [%| (ap-suck "move: malformed poke")] :^ %& sto %pass :- [(scot %p q.q.vax) %out r.q.vax u.pux] ^- cote :: ~& [%ap-move-send `path`[(scot %p q.q.vax) %out r.q.vax u.pux]] [%send q.q.vax r.q.vax %poke p.t.q.vax (slot 3 (spec (slot 3 gav)))] =+ cob=((soft club) [s t]:q.vax) ?~ cob [%| (ap-suck "move: malformed club")] :^ %& sto %pass :- [(scot %p q.q.vax) %out r.q.vax u.pux] :: ~& [%ap-move-send `path`[(scot %p q.q.vax) %out r.q.vax u.pux]] [%send q.q.vax r.q.vax u.cob] :: ++ ap-pass :: request action |= [pax=path coh=cote] ^+ +> +>(zip :_(zip [ost %pass pax coh])) :: ++ ap-peep :: reinstall |= vax=vase ^+ +> (ap-prep(hav vax) `hav) :: ++ ap-peer :: apply %peer |= pax=path ^+ +> =+ cug=(ap-find %peer pax) ?~ cug (ap-peon pax) =^ cam +>.$ %+ ap-call q.u.cug !>([[`@ud`ost `@p`q.q.pry] `path`(slag p.u.cug pax)]) ?^ cam (ap-give %reap cam) (ap-give:(ap-peon pax) %reap ~) :: ++ ap-peon :: add subscriber |= pax=path %_ +>.$ sup.ged (~(put by sup.ged) ost [q.q.pry pax]) pus.ged (~(put ju pus.ged) pax ost) == :: ++ ap-poke :: apply %poke |= cag=cage ^+ +> =+ cug=(ap-find %poke p.cag ~) ?~ cug (ap-give %coup `(ap-suck "no poke arm")) :: ~& [%ap-poke dap p.cag cug] =^ tur +>.$ %+ ap-call q.u.cug %+ slop !>([`@ud`ost `@p`q.q.pry]) ?. =(0 p.u.cug) q.cag (slop (ap-term %tas p.cag) q.cag) (ap-give %coup tur) :: ++ ap-lame :: pour error |= [wut=@tas why=tang] ^+ +> =+ cug=(ap-find /lame) ?~ cug ~& [%ap-lame wut why] +>.$ =^ cam +>.$ %+ ap-call q.u.cug !>([[`@ud`ost `@p`q.q.pry] wut why]) ?^ cam ~&([%ap-lame-lame u.cam] +>.$) +>.$ :: ++ ap-pour :: generic take |= [pax=path vax=vase] ^+ +> ?. &(?=([@ *] q.vax) ((sane %tas) -.q.vax)) (ap-lame %pour (ap-suck "pour: malformed card")) =+ cug=(ap-find [-.q.vax pax]) ?~ cug (ap-lame -.q.vax (ap-suck "pour: no {(trip -.q.vax)}: {}")) =^ cam +>.$ %+ ap-call q.u.cug %+ slop !>([`@ud`ost `@p`q.q.pry `path`(slag p.u.cug pax)]) (slot 3 vax) ?^ cam (ap-lame -.q.vax u.cam) +>.$ :: ++ ap-pout :: specific take |= [pax=path cuf=cuft] ^+ +> ?- -.cuf %coup (ap-punk q.q.pry %coup +.pax `!>(p.cuf)) %diff (ap-diff q.q.pry pax p.cuf) %quit (ap-punk q.q.pry %quit +.pax ~) %reap (ap-punk q.q.pry %reap +.pax `!>(p.cuf)) == :: ++ ap-prep :: install |= vux=(unit vase) ^+ +> =^ gac +>.$ (ap-prop vux) %= +>.$ dub :_(dub ?~(gac [%& dap ?~(vux %boot %bump) now] [%| u.gac])) == :: ++ ap-prop :: install |= vux=(unit vase) ^- [(unit tang) _+>] ?. (ap-fond %prep) ?~ vux `+>.$ ?. (~(nest ut p:(slot 13 hav)) %| p:(slot 13 u.vux)) :_(+>.$ `(ap-suck "prep mismatch")) `+>.$(+13.q.hav +13.q.u.vux) =^ tur +>.$ %+ ap-call %prep %+ slop !>([`@ud`ost `@p`q.q.pry]) ?~(vux !>(~) (slop !>(~) (slot 13 u.vux))) ?~(tur `+>.$ :_(+>.$ `u.tur)) :: ++ ap-pull :: pull inbound =+ wim=(~(get by sup.ged) ost) ?~ wim ~&(%ap-pull-none +) =: sup.ged (~(del by sup.ged) ost) pus.ged (~(del ju pus.ged) q.u.wim ost) qel.ged (~(del by qel.ged) ost) == =+ cug=(ap-find %pull q.u.wim) ?~ cug +> =^ cam +> %+ ap-call q.u.cug !>([[`@ud`ost `@p`q.q.pry] (slag p.u.cug q.u.wim)]) ?^ cam (ap-lame q.u.cug u.cam) +>+ :: ++ ap-kill :: queue kill ~& [%ap-kill dap ost] (ap-give:ap-pull %quit ~) :: ++ ap-punk :: non-diff gall take |= [her=ship cog=term pax=path vux=(unit vase)] ^+ +> =+ cug=(ap-find cog pax) ?~ cug ~& [%ap-punk-none cog pax] +>.$ =^ cam +>.$ %+ ap-call q.u.cug =+ den=!>([`@ud`ost `@p`q.q.pry (slag p.u.cug pax)]) ?~(vux den (slop den u.vux)) ?^ cam (ap-lame q.u.cug u.cam) +>.$ :: ++ ap-safe :: process move list |= vax=vase ^- (each (list cute) tang) ?~ q.vax [%& ~] ?@ q.vax [%| (ap-suck "move: malformed list")] =+ sud=(ap-move (slot 2 vax)) ?: ?=(%| -.sud) sud =+ res=$(vax (slot 3 vax)) ?: ?=(%| -.res) res [%& p.sud p.res] :: ++ ap-sake :: handle result |= vax=vase ^- [(unit tang) _+>] ?: ?=(@ q.vax) [`(ap-suck "sake: invalid product (atom)") +>.$] =+ muz=(ap-safe (slot 2 vax)) ?: ?=(%| -.muz) [`p.muz +>.$] =+ sav=(ap-save (slot 3 vax)) ?: ?=(%| -.sav) [`p.sav +>.$] :- ~ %_ +>.$ zip (weld (flop p.muz) zip) hav p.sav == :: ++ ap-save :: verify core |= vax=vase ^- (each vase tang) ?. (~(nest ut p.hav) %| p.vax) [%| (ap-suck "invalid core")] [%& vax] :: ++ ap-slam :: virtual slam |= [cog=term gat=vase arg=vase] ^- (each vase tang) =+ wiz=(mule |.((slit p.gat p.arg))) ?: ?=(%| -.wiz) ~& %ap-slam-mismatch ~> %slog.[0 ~(duck ut p.arg)] ~> %slog.[0 ~(duck ut (~(peek ut p.gat) %free 6))] [%| (ap-suck "call: {}: type mismatch")] =+ ton=(mong [q.gat q.arg] ap-sled) ?- -.ton %0 [%& p.wiz p.ton] %1 [%| (turn p.ton |=(a=* (smyt (path a))))] %2 [%| p.ton] == :: ++ ap-sled (mole (slod ska)) :: namespace view ++ ap-suck :: standard tang |= msg=tape ^- tang [%leaf (weld "gall: {}: " msg)]~ :: ++ ap-term :: atomic vase |= [a=@tas b=@] ^- vase [[%cube b %atom a] b] :: ++ ap-vain :: card to vane |= sep=@tas ^- (unit ,@tas) ?+ sep ~& [%ap-vain sep] ~ %cash `%a %conf `%g %deal `%g %exec `%f %flog `%d %font `%c %info `%c %lynx `%c %merg `%c %plug `%c %them `%e %want `%a == -- -- ++ call :: request |= [hen=duct hic=(hypo (hobo kiss-gall))] ^- [p=(list move) q=_..^$] => .(q.hic ?.(?=(%soft -.q.hic) q.hic ((hard kiss-gall) p.q.hic))) ?- -.q.hic %conf ?. (~(has by pol.all) p.p.q.hic) ~& [%gall-not-ours p.p.q.hic] [~ ..^$] mo-abet:(mo-conf:(mo-abed:mo p.p.q.hic hen) q.p.q.hic q.q.hic) :: %deal =< mo-abet ?. (~(has by pol.all) q.p.q.hic) :: either to us ?> (~(has by pol.all) p.p.q.hic) :: or from us (mo-away:(mo-abed:mo p.p.q.hic hen) q.p.q.hic q.q.hic) (mo-come:(mo-abed:mo q.p.q.hic hen) p.p.q.hic q.q.hic) :: %init ~& [%gall-init p.q.hic] [~ ..^$(pol.all (~(put by pol.all) p.q.hic [hen ~ ~ ~]))] :: %rote ~& [%gall-rote p.q.hic] ?. (~(has by pol.all) p.p.q.hic) ~& [%gall-not-ours p.q.hic] [~ ..^$] ?> ?=([@ ~] q.q.hic) =+ dap=i.q.q.hic =+ our=p.p.q.hic =+ him=q.p.q.hic =+ mes=((hard ,[@ud rook]) r.q.hic) =< mo-abet (mo-gawk:(mo-abed:mo our hen) him dap mes) :: %roth :: ~& [%gall-roth p.q.hic] ?. (~(has by pol.all) p.p.q.hic) ~& [%gall-not-ours p.q.hic] [~ ..^$] ?> ?=([@ ~] q.q.hic) =+ dap=i.q.q.hic =+ our=p.p.q.hic =+ him=q.p.q.hic =+ mes=((hard ,[@ud roon]) r.q.hic) =< mo-abet (mo-gawd:(mo-abed:mo our hen) him dap mes) == :: ++ doze :: sleep until |= [now=@da hen=duct] ^- (unit ,@da) ~ :: ++ load :: recreate vane |= old=axle ^+ ..^$ ..^$(all old) :: ++ scry |= [fur=(unit (set monk)) ren=@tas who=ship syd=desk lot=coin tyl=path] ^- (unit (unit (pair mark ,*))) [~ ~] :: ++ stay :: save w/o cache `axle`all :: ++ take :: response |= [tea=wire hen=duct hin=(hypo sign-arvo)] ^- [p=(list move) q=_..^$] ~| [%gall-take tea] ?> ?=([@ ?(%sys %use) *] tea) =+ our=(need (slaw %p i.tea)) =+ mow=(mo-abed:mo our hen) ?: ?=(%sys i.t.tea) mo-abet:(mo-cyst:mow t.t.tea q.hin) ?> ?=(%use i.t.tea) mo-abet:(mo-cook:mow t.t.tea hin) --