mirror of
https://github.com/urbit/shrub.git
synced 2024-12-15 21:03:10 +03:00
2901 lines
96 KiB
Plaintext
2901 lines
96 KiB
Plaintext
!:
|
|
:: clay (4c), revision control
|
|
::
|
|
|= pit=vase
|
|
=> |%
|
|
++ cane :: change set
|
|
$: new=(map path lobe) :: new files
|
|
cal=(map path lobe) :: old diffs
|
|
can=(map path cage) :: new diffs
|
|
old=(map path ,~) :: deleted files
|
|
== ::
|
|
++ cult (map duct rove) :: subscriptions
|
|
++ dojo :: domestic desk state
|
|
$: qyx=cult :: subscribers
|
|
dom=dome :: desk data
|
|
dok=(unit dork) :: outstanding diffs
|
|
mer=(map (pair ship desk) mery) :: outstanding merges
|
|
syn=? :: sync to unix
|
|
== ::
|
|
++ gift :: out result <-$
|
|
$% [%ergo p=@p q=@tas r=@ud s=(list ,[path (unit mime)])]
|
|
:: version update
|
|
[%mass p=mass] :: memory usage
|
|
[%mere p=(each (set path) (pair term tang))] :: merge result
|
|
[%note p=@tD q=tank] :: debug message
|
|
[%writ p=riot] :: response
|
|
== ::
|
|
++ khan ::
|
|
$: fil=(unit (unit cage)) :: XX see khan-to-soba
|
|
dir=(map ,@ta khan) ::
|
|
== ::
|
|
++ kiss :: in request ->$
|
|
$% [%font p=@p q=@tas r=@p s=@tas] :: set upstream
|
|
[%info p=@p q=@tas r=nori] :: internal edit
|
|
[%init p=@p] :: report install
|
|
[%into p=@p q=@tas r=khan] :: external edit
|
|
[%lynx p=@p q=@tas r=(unit ,?)] :: sync to unix
|
|
[%merg p=@p q=@tas r=@p s=@tas t=germ] :: merge desks
|
|
[%plug p=@p q=@tas r=@p s=@tas] :: unset upstream
|
|
[%wart p=sock q=@tas r=path s=*] :: network request
|
|
[%warp p=sock q=riff] :: file request
|
|
[%wegh ~] :: report memory
|
|
== ::
|
|
++ mery ::
|
|
$: gem=germ :: strategy
|
|
cas=case :: ali's case
|
|
ali=yaki :: ali's commit
|
|
bob=yaki :: bob's commit
|
|
bas=yaki :: mergebase
|
|
dal=cane :: diff(bas,ali)
|
|
dob=cane :: diff(bas,bob)
|
|
bof=(map path (unit cage)) :: conflict diffs
|
|
bop=(map path cage) :: conflict patches
|
|
new=yaki :: merge(dal,dob)
|
|
ank=ankh :: new state
|
|
erg=(map path ,?) :: ergoable changes
|
|
gon=(each (set path) (pair term (list tank))) :: return value
|
|
== ::
|
|
++ moot ,[p=case q=case r=path s=(map path lobe)] :: stored change range
|
|
++ move ,[p=duct q=(mold note gift)] :: local move
|
|
++ nako $: gar=(map aeon tako) :: new ids
|
|
let=aeon :: next id
|
|
lar=(set yaki) :: new commits
|
|
bar=(set plop) :: new content
|
|
== ::
|
|
++ note :: out request $->
|
|
$% $: %a :: to %ames
|
|
$% [%want p=sock q=path r=*] ::
|
|
== == ::
|
|
$: %c :: to %clay
|
|
$% [%font p=@p q=@tas r=@p s=@tas] ::
|
|
[%info p=@p q=@tas r=nori] :: internal edit
|
|
[%merg p=@p q=@tas r=@p s=@tas t=germ] :: merge desks
|
|
[%warp p=sock q=riff] ::
|
|
== == ::
|
|
$: %d ::
|
|
$% [%flog p=[%crud p=@tas q=(list tank)]] :: to %dill
|
|
== == ::
|
|
$: %f ::
|
|
$% [%exec p=@p q=beak r=(unit silk)] ::
|
|
== == ::
|
|
$: %t ::
|
|
$% [%wait p=@da] ::
|
|
[%rest p=@da] ::
|
|
== == == ::
|
|
++ sign :: in result $<-
|
|
$? $: %a :: by %ames
|
|
$% [%waft p=sock q=*] ::
|
|
[%went p=ship q=cape] ::
|
|
== == ::
|
|
$: %c :: by %clay
|
|
$% [%note p=@tD q=tank] ::
|
|
[%mere p=(each (set path) (pair term tang))]
|
|
[%writ p=riot] ::
|
|
== == ::
|
|
$: %f ::
|
|
$% [%made p=@uvH q=(each gage (list tank))] ::
|
|
== == ::
|
|
$: %t ::
|
|
$% [%wake ~] :: timer activate
|
|
== == ::
|
|
$: @tas :: by any
|
|
$% [%crud p=@tas q=(list tank)] ::
|
|
== == == ::
|
|
++ silk :: construction layer
|
|
$& [p=silk q=silk] :: cons
|
|
$% [%bake p=mark q=beam r=path] :: local synthesis
|
|
[%boil p=mark q=beam r=path] :: general synthesis
|
|
[%bunt p=mark] :: example of mark
|
|
[%call p=silk q=silk] :: slam
|
|
[%cast p=mark q=silk] :: translate
|
|
[%diff p=silk q=silk] :: diff
|
|
[%done p=(set beam) q=gage] :: literal
|
|
[%dude p=tank q=silk] :: error wrap
|
|
[%dune p=(set beam) q=(unit gage)] :: unit literal
|
|
[%join p=mark q=silk r=silk] :: merge
|
|
[%mute p=silk q=(list (pair wing silk))] :: mutant
|
|
[%pact p=silk q=silk] :: patch
|
|
[%reef ~] :: kernel reef
|
|
[%ride p=twig q=silk] :: silk thru twig
|
|
[%tabl p=(list (pair silk silk))] :: list
|
|
[%vale p=mark q=ship r=*] :: validate [our his]
|
|
[%volt p=(set beam) q=(cask ,*)] :: unsafe add type
|
|
== ::
|
|
++ raft :: filesystem
|
|
$: fat=(map ship room) :: domestic
|
|
hoy=(map ship rung) :: foreign
|
|
ran=rang :: hashes
|
|
$= sor :: upstreams
|
|
(map ,[p=@p q=@tas r=@p s=@tas] ,[let=@ud hen=duct])
|
|
== ::
|
|
++ rede :: universal project
|
|
$: lim=@da :: complete to
|
|
qyx=cult :: subscribers
|
|
ref=(unit rind) :: outgoing requests
|
|
dom=dome :: revision state
|
|
dok=(unit dork) :: outstanding diffs
|
|
mer=(map (pair ship desk) mery) :: outstanding merges
|
|
syn=? :: sync to unix
|
|
== ::
|
|
++ riff ,[p=desk q=(unit rave)] :: request/desist
|
|
++ rind :: request manager
|
|
$: nix=@ud :: request index
|
|
bom=(map ,@ud ,[p=duct q=rave]) :: outstanding
|
|
fod=(map duct ,@ud) :: current requests
|
|
haw=(map mood (unit cage)) :: simple cache
|
|
nak=(unit nako) :: pending validation
|
|
== ::
|
|
++ room :: fs per ship
|
|
$: hun=duct :: terminal duct
|
|
hez=(unit duct) :: sync duct
|
|
dos=(map desk dojo) :: native desk
|
|
== ::
|
|
++ rove :: stored request
|
|
$% [%sing p=mood] :: single request
|
|
[%next p=mood q=(unit (each cage lobe))] :: next version
|
|
[%many p=? q=moot] :: change range
|
|
== ::
|
|
++ rung $: rus=(map desk rede) :: neighbor desks
|
|
== ::
|
|
++ tage ,[[%tabl p=(list (pair marc marc))] q=vase] :: %tabl gage
|
|
++ dork :: diff work
|
|
$: del=(list (pair path cage)) :: deletes
|
|
ink=(list (pair path cage)) :: hoo{n,k}
|
|
ins=(unit (list (pair path cage))) :: inserts
|
|
dig=(map path cage) :: store diffs
|
|
dif=(unit (list (trel path lobe cage))) :: changes
|
|
muc=(map path (pair cage cage)) :: store miso
|
|
muh=(map path lobe) :: store hashes
|
|
mut=(unit (list (trel path lobe cage))) :: mutations
|
|
mim=(map path mime) :: mime cache
|
|
== ::
|
|
-- =>
|
|
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
|
|
:: section 4cA, filesystem logic ::
|
|
::
|
|
::
|
|
::
|
|
|%
|
|
++ de :: per desk
|
|
|= [now=@da hen=duct hun=duct hez=(unit duct)]
|
|
|= [[who=@p for=@p] syd=@ta rede ran=rang]
|
|
=* red +<+>-
|
|
=| yel=(list ,[p=duct q=gift])
|
|
=| byn=(list ,[p=duct q=riot])
|
|
=| reg=(list ,[p=duct q=gift])
|
|
=| say=(list ,[p=duct q=path r=ship s=[p=@ud q=riff]])
|
|
=| tag=(list move)
|
|
|%
|
|
++ abet
|
|
^- [(list move) rede]
|
|
:_ red
|
|
;: weld
|
|
%+ turn (flop yel)
|
|
|=([a=duct b=gift] [hun %give b])
|
|
::
|
|
%+ turn (flop byn)
|
|
|=([a=duct b=riot] [a %give [%writ b]])
|
|
::
|
|
%+ turn (flop reg)
|
|
|=([a=duct b=gift] [a %give b])
|
|
::
|
|
%+ turn (flop say)
|
|
|= [a=duct b=path c=ship d=[p=@ud q=riff]]
|
|
:- a
|
|
[%pass b %a %want [who c] [%q %re p.q.d (scot %ud p.d) ~] q.d]
|
|
::
|
|
tag
|
|
==
|
|
::
|
|
++ aver :: read
|
|
|= mun=mood
|
|
^- (unit (unit (each cage lobe)))
|
|
=+ ezy=?~(ref ~ (~(get by haw.u.ref) mun))
|
|
?^ ezy
|
|
`(bind u.ezy (cury same %&))
|
|
=+ nao=(case-to-aeon:ze q.mun)
|
|
:: ~& [%aver-mun nao [%from syd lim q.mun]]
|
|
?~(nao ~ (read-at-aeon:ze u.nao mun))
|
|
::
|
|
++ made-to-tage
|
|
|= res=(each gage tang)
|
|
^- tage
|
|
?: ?=(%| -.res)
|
|
~| %ford-fail
|
|
|-
|
|
?~ p.res !!
|
|
~> %mean.|.(i.p.res) :: interpolate ford fail into stack trace
|
|
$(p.res t.p.res)
|
|
?@ p.p.res
|
|
~|(%bad-marc !!)
|
|
p.res
|
|
::
|
|
++ tage-to-cages
|
|
|= tab=tage
|
|
^- (list (pair cage cage))
|
|
?~ p.tab
|
|
~
|
|
:_ $(p.tab t.p.tab, q.tab (slot 3 q.tab))
|
|
~| %strange-gage
|
|
:- [?^(p.i.p.tab !! p.i.p.tab) (slot 4 q.tab)]
|
|
[?^(q.i.p.tab !! q.i.p.tab) (slot 5 q.tab)]
|
|
::
|
|
++ balk :: read and send
|
|
|= [hen=duct cay=(unit (each cage lobe)) mun=mood]
|
|
^+ +>
|
|
?~ cay (blub hen)
|
|
(blab hen mun u.cay)
|
|
::
|
|
++ bait
|
|
|= [hen=duct tym=@da]
|
|
%_(+> tag :_(tag [hen %pass /tyme %t %wait tym]))
|
|
::
|
|
++ best
|
|
|= [hen=duct tym=@da]
|
|
%_(+> tag :_(tag [hen %pass /tyme %t %rest tym]))
|
|
::
|
|
++ blab :: ship result
|
|
|= [hen=duct mun=mood dat=(each cage lobe)]
|
|
^+ +>
|
|
?: ?=(%& -.dat)
|
|
+>.$(byn [[hen ~ [p.mun q.mun syd] r.mun p.dat] byn])
|
|
=- +>.$(tag [- tag])
|
|
:* hen %pass [%blab p.mun (scot q.mun) syd r.mun]
|
|
%f %exec who [who syd q.mun] ~ (lobe-to-silk:ze r.mun p.dat)
|
|
==
|
|
::
|
|
++ bleb :: ship sequence
|
|
|= [hen=duct ins=@ud hip=(unit (pair aeon aeon))]
|
|
^+ +>
|
|
%^ blab hen [%w [%ud ins] ~]
|
|
:- %&
|
|
?~ hip
|
|
[%null [%atom %n] ~]
|
|
[%nako !>((make-nako:ze u.hip))]
|
|
::
|
|
++ blub :: ship stop
|
|
|= hen=duct
|
|
%_(+> byn [[hen ~] byn])
|
|
::
|
|
++ duce :: produce request
|
|
|= rov=rove
|
|
^+ +>
|
|
=. qyx (~(put by qyx) hen rov)
|
|
?~ ref
|
|
(mabe rov (cury bait hen))
|
|
|- ^+ +>+.$ :: XX why?
|
|
=+ rav=(reve rov)
|
|
=+ ^= vaw ^- rave
|
|
?. ?=([%sing %v *] rav) rav
|
|
[%many %| [%ud let.dom] `case`q.p.rav r.p.rav]
|
|
=+ inx=nix.u.ref
|
|
~? ?=([%sing %x *] vaw)
|
|
[%remote-x-ing vaw hen]
|
|
%= +>+.$
|
|
say [[hen [(scot %ud inx) ~] for [inx syd ~ vaw]] say]
|
|
nix.u.ref +(nix.u.ref)
|
|
bom.u.ref (~(put by bom.u.ref) inx [hen vaw])
|
|
fod.u.ref (~(put by fod.u.ref) hen inx)
|
|
==
|
|
::
|
|
++ lynx
|
|
|= sun=(unit ,?)
|
|
^+ +>
|
|
+>.$(syn ?~(sun !syn u.sun))
|
|
::
|
|
++ ease :: release request
|
|
^+ .
|
|
?~ ref
|
|
=+ rov=(~(get by qyx) hen)
|
|
?~ rov + :: XX handle?
|
|
=. qyx (~(del by qyx) hen)
|
|
(mabe u.rov (cury best hen))
|
|
=. qyx (~(del by qyx) hen)
|
|
|- ^+ +.$
|
|
=+ nux=(~(get by fod.u.ref) hen)
|
|
?~ nux +.$
|
|
%= +.$
|
|
say [[hen [(scot %ud u.nux) ~] for [u.nux syd ~]] say]
|
|
fod.u.ref (~(del by fod.u.ref) hen)
|
|
bom.u.ref (~(del by bom.u.ref) u.nux)
|
|
==
|
|
::
|
|
++ eave :: subscribe
|
|
|= rav=rave
|
|
^+ +>
|
|
?- -.rav
|
|
%sing
|
|
=+ ver=(aver p.rav)
|
|
?~ ver
|
|
(duce rav)
|
|
?~ u.ver
|
|
(blub hen)
|
|
(blab hen p.rav u.u.ver)
|
|
::
|
|
%next
|
|
=+ ver=(aver p.rav)
|
|
?~ ver
|
|
(duce [- p ~]:rav)
|
|
?~ u.ver
|
|
(blub hen)
|
|
=+ yon=+((need (case-to-aeon:ze q.p.rav)))
|
|
|- ^+ +>.^$
|
|
?: (gth yon let.dom)
|
|
(duce -.rav p.rav u.ver)
|
|
=+ var=(aver p.rav(q [%ud yon]))
|
|
?~ var
|
|
~& [%oh-no rave=rav aeon=yon letdom=let.dom]
|
|
+>.^$
|
|
?~ u.var
|
|
(blab hen p.rav %& %null [%atom %n] ~) :: only for %x
|
|
?: (equivalent-data:ze u.u.ver u.u.var)
|
|
$(yon +(yon))
|
|
(blab hen p.rav u.u.var)
|
|
::
|
|
%many
|
|
=+ nab=(case-to-aeon:ze p.q.rav)
|
|
?~ nab
|
|
?> =(~ (case-to-aeon:ze q.q.rav))
|
|
(duce (rive rav))
|
|
=+ huy=(case-to-aeon:ze q.q.rav)
|
|
?: &(?=(^ huy) |((lth u.huy u.nab) &(=(0 u.huy) =(0 u.nab))))
|
|
(blub hen)
|
|
=+ top=?~(huy let.dom u.huy)
|
|
=+ sar=(lobes-at-path:ze u.nab r.q.rav)
|
|
=+ ear=(lobes-at-path:ze top r.q.rav)
|
|
=. +>.$
|
|
?: =(sar ear) +>.$
|
|
(bleb hen u.nab ?:(p.rav ~ `[u.nab top]))
|
|
?^ huy
|
|
(blub hen)
|
|
=+ ^= ptr ^- case
|
|
[%ud +(let.dom)]
|
|
(duce `rove`[%many p.rav ptr q.q.rav r.q.rav ear])
|
|
==
|
|
::
|
|
++ echa :: announce raw
|
|
|= [wen=@da mer=mizu]
|
|
^+ +>
|
|
%= +>
|
|
reg ~& %merge-announce reg
|
|
:: ?~(hez reg :_(reg [u.hez [%ergo who syd let.dom]]))
|
|
:: yel [[hen %note '=' %leaf ~] yel] :: XX do better
|
|
==
|
|
::
|
|
++ echo :: announce changes
|
|
|= [wen=@da lem=nuri]
|
|
^+ +>
|
|
%_ +>.$
|
|
yel
|
|
=+ pre=`path`~[(scot %p for) syd (scot %ud let.dom)]
|
|
?- -.lem
|
|
| :_ yel
|
|
[hen %note '=' %leaf :(weld (trip p.lem) " " (spud pre))]
|
|
& |- ^+ yel
|
|
?~ q.p.lem yel
|
|
:_ $(q.p.lem t.q.p.lem)
|
|
:- hen
|
|
:+ %note
|
|
?-(-.q.i.q.p.lem %del '-', %ins '+', %dif ':')
|
|
[%leaf (spud (weld pre p.i.q.p.lem))]
|
|
==
|
|
==
|
|
::
|
|
++ edit :: apply changes
|
|
|= [wen=@da lem=nori]
|
|
^+ +>
|
|
?: ?=(%| -.lem)
|
|
=^ hat +>.$
|
|
(edit:ze wen lem)
|
|
?~ hat
|
|
+>.$
|
|
wake:(echo:(checkout-ankh u.hat) wen lem)
|
|
?. =(~ dok)
|
|
~& %already-applying-changes +>
|
|
=+ del=(skim q.p.lem :(corl (cury test %del) head tail))
|
|
=+ ins=(skim q.p.lem :(corl (cury test %ins) head tail))
|
|
=+ dif=(skim q.p.lem :(corl (cury test %dif) head tail))
|
|
=+ mut=(skim q.p.lem :(corl (cury test %mut) head tail))
|
|
=^ ink ins
|
|
^- [(list (pair path miso)) (list (pair path miso))]
|
|
%+ skid `(list (pair path miso))`ins
|
|
|= [pax=path mis=miso]
|
|
?> ?=(%ins -.mis)
|
|
?& ?=([?(%hoon %hook) *] (flop pax))
|
|
?=(%mime p.p.mis)
|
|
==
|
|
=- %_ +>.$
|
|
tag (welp - tag)
|
|
dok
|
|
:- ~
|
|
:* %+ turn del
|
|
|= [pax=path mis=miso]
|
|
?> ?=(%del -.mis)
|
|
[pax p.mis]
|
|
::
|
|
%+ turn ink
|
|
|= [pax=path mis=miso]
|
|
^- (pair path cage)
|
|
?> ?=(%ins -.mis)
|
|
=+ =>((flop pax) ?~(. %$ i))
|
|
[pax - [%atom %t] ((hard ,@t) +>.q.q.p.mis)]
|
|
::
|
|
~
|
|
::
|
|
%- mo
|
|
%+ turn dif
|
|
|= [pax=path mis=miso]
|
|
?> ?=(%dif -.mis)
|
|
[pax p.mis]
|
|
::
|
|
~
|
|
::
|
|
%- mo
|
|
%+ turn mut
|
|
|= [pax=path mis=miso]
|
|
?> ?=(%mut -.mis)
|
|
[pax p.mis q.mis]
|
|
::
|
|
~
|
|
::
|
|
~
|
|
::
|
|
%- mo ^- (list (pair path mime))
|
|
;: welp
|
|
^- (list (pair path mime))
|
|
%+ murn ins
|
|
|= [pax=path mis=miso]
|
|
^- (unit (pair path mime))
|
|
?> ?=(%ins -.mis)
|
|
?. ?=(%mime p.p.mis)
|
|
~
|
|
`[pax ((hard mime) q.q.p.mis)]
|
|
::
|
|
^- (list (pair path mime))
|
|
%+ murn ink
|
|
|= [pax=path mis=miso]
|
|
^- (unit (pair path mime))
|
|
?> ?=(%ins -.mis)
|
|
?> ?=(%mime p.p.mis)
|
|
`[pax ((hard mime) q.q.p.mis)]
|
|
::
|
|
^- (list (pair path mime))
|
|
%+ murn mut
|
|
|= [pax=path mis=miso]
|
|
^- (unit (pair path mime))
|
|
?> ?=(%mut -.mis)
|
|
?. ?=(%mime p.q.mis)
|
|
~
|
|
`[pax ((hard mime) q.q.q.mis)]
|
|
==
|
|
==
|
|
==
|
|
^- (list move)
|
|
:~ :* hen %pass
|
|
[%inserting (scot %p who) syd (scot %da wen) ~]
|
|
%f %exec who [who syd %da wen] ~ %tabl
|
|
^- (list (pair silk silk))
|
|
%+ turn ins
|
|
|= [pax=path mis=miso]
|
|
?> ?=(%ins -.mis)
|
|
:- [%done ~ %path -:!>(*path) pax]
|
|
=+ =>((flop pax) ?~(. %$ i))
|
|
[%cast - [%done ~ p.mis]]
|
|
==
|
|
:* hen %pass
|
|
[%diffing (scot %p who) syd (scot %da wen) ~]
|
|
%f %exec who [who syd %da wen] ~ %tabl
|
|
^- (list (pair silk silk))
|
|
%+ turn dif
|
|
|= [pax=path mis=miso]
|
|
?> ?=(%dif -.mis)
|
|
=+ (need (need (read-x:ze let.dom pax)))
|
|
?> ?=(%& -<)
|
|
:- [%done ~ %path -:!>(*path) pax]
|
|
[%pact [%done ~ p.-] [%done ~ p.mis]]
|
|
==
|
|
:* hen %pass
|
|
[%castifying (scot %p who) syd (scot %da wen) ~]
|
|
%f %exec who [who syd %da wen] ~ %tabl
|
|
^- (list (pair silk silk))
|
|
%+ turn mut
|
|
|= [pax=path mis=miso]
|
|
?> ?=(%mut -.mis)
|
|
:- [%done ~ %path -:!>(*path) pax]
|
|
[%cast p.p.mis [%done ~ q.mis]]
|
|
==
|
|
==
|
|
::
|
|
++ silkify
|
|
|= [wen=@da pax=path mis=miso]
|
|
^- [duct path note]
|
|
~| [%silkifying pax -.mis]
|
|
:- hen
|
|
?+ -.mis !!
|
|
%mut
|
|
:- [%diffing (scot %p who) syd (scot %da wen) pax]
|
|
:^ %f %exec who :+ [who syd %da wen] ~
|
|
^- silk
|
|
=+ =+ (slag (dec (lent pax)) pax)
|
|
=+ ?~(- %$ i.-)
|
|
[%cast - [%done ~ q.mis]]
|
|
[%diff [%done ~ p.mis] -]
|
|
::
|
|
%ins
|
|
:- [%casting (scot %p who) syd (scot %da wen) pax]
|
|
:^ %f %exec who :+ [who syd %da wen] ~
|
|
^- silk
|
|
=+ (slag (dec (lent pax)) pax)
|
|
=+ ?~(- %$ i.-)
|
|
[%cast - [%done ~ p.mis]]
|
|
==
|
|
::
|
|
++ apply-edit
|
|
|= wen=@da
|
|
^+ +>
|
|
=+ ^- sim=(list (pair path misu))
|
|
?~ dok
|
|
~|(%no-changes !!)
|
|
?> ?=(^ ins.u.dok)
|
|
?> ?=(^ dif.u.dok)
|
|
?> ?=(^ mut.u.dok)
|
|
;: welp
|
|
^- (list (pair path misu))
|
|
(turn del.u.dok |=([pax=path cay=cage] [pax %del cay]))
|
|
::
|
|
^- (list (pair path misu))
|
|
(turn ink.u.dok |=([pax=path cay=cage] [pax %ins cay]))
|
|
::
|
|
^- (list (pair path misu))
|
|
(turn u.ins.u.dok |=([pax=path cay=cage] [pax %ins cay]))
|
|
::
|
|
^- (list (pair path misu))
|
|
(turn u.dif.u.dok |=([pax=path cal=[lobe cage]] [pax %dif cal]))
|
|
::
|
|
^- (list (pair path misu))
|
|
(turn u.mut.u.dok |=([pax=path cal=[lobe cage]] [pax %dif cal]))
|
|
==
|
|
=+ hat=(edit:ze wen %& *cart sim)
|
|
?~ dok ~& %no-changes !!
|
|
?~ -.hat
|
|
([echo(dok ~)]:.(+>.$ +.hat) wen %& *cart sim)
|
|
(checkout-ankh(lat.ran lat.ran.+.hat) u.-.hat)
|
|
::
|
|
++ take-inserting
|
|
|= [wen=@da res=(each gage tang)]
|
|
^+ +>
|
|
?~ dok
|
|
~& %clay-take-inserting-unexpected-made +>.$
|
|
?. =(~ ins.u.dok)
|
|
~& %clay-take-inserting-redundant-made +>.$
|
|
=- =. ins.u.dok `-
|
|
?: ?& ?=(^ dif.u.dok)
|
|
?=(^ mut.u.dok)
|
|
==
|
|
(apply-edit wen)
|
|
+>.$
|
|
^- (list (pair path cage))
|
|
%+ turn (tage-to-cages (made-to-tage res))
|
|
|= [pax=cage cay=cage]
|
|
?. ?=(%path p.pax)
|
|
~|(%clay-take-inserting-strange-path-mark !!)
|
|
[((hard path) q.q.pax) cay]
|
|
::
|
|
++ take-diffing
|
|
|= [wen=@da res=(each gage tang)]
|
|
^+ +>
|
|
?~ dok
|
|
~& %clay-take-diffing-unexpected-made +>.$
|
|
?. =(~ dif.u.dok)
|
|
~& %clay-take-diffing-redundant-made +>.$
|
|
=- =. dif.u.dok `-
|
|
?: ?& ?=(^ ins.u.dok)
|
|
?=(^ mut.u.dok)
|
|
==
|
|
(apply-edit wen)
|
|
+>.$
|
|
^- (list (trel path lobe cage))
|
|
%+ turn (tage-to-cages (made-to-tage res))
|
|
|= [pax=cage cay=cage]
|
|
^- (pair path (pair lobe cage))
|
|
?. ?=(%path p.pax)
|
|
~|(%clay-take-diffing-strange-path-mark !!)
|
|
=+ paf=((hard path) q.q.pax)
|
|
[paf (page-to-lobe:ze [p q.q]:cay) (~(got by dig.u.dok) paf)]
|
|
::
|
|
++ take-castify
|
|
|= [wen=@da res=(each gage tang)]
|
|
^+ +>
|
|
?~ dok
|
|
~& %clay-take-castifying-unexpected-made +>.$
|
|
?. =(~ muh.u.dok)
|
|
~& %clay-take-castifying-redundant-made +>.$
|
|
=+ ^- cat=(list (pair path cage))
|
|
%+ turn (tage-to-cages (made-to-tage res))
|
|
|= [pax=cage cay=cage]
|
|
?. ?=(%path p.pax)
|
|
~|(%castify-bad-path-mark !!)
|
|
[((hard path) q.q.pax) cay]
|
|
=. muh.u.dok
|
|
%- mo
|
|
%+ turn cat
|
|
|= [pax=path cay=cage]
|
|
[pax (page-to-lobe:ze [p q.q]:cay)]
|
|
=- %_(+>.$ tag [- tag])
|
|
^- move
|
|
:* hen %pass
|
|
[%mutating (scot %p who) syd (scot %da wen) ~]
|
|
%f %exec who [who syd %da wen] ~ %tabl
|
|
^- (list (pair silk silk))
|
|
%+ turn cat
|
|
|= [pax=path cay=cage]
|
|
:- [%done ~ %path -:!>(*path) pax]
|
|
[%diff [%done ~ p:(~(got by muc.u.dok) pax)] [%done ~ cay]]
|
|
==
|
|
::
|
|
++ take-mutating
|
|
|= [wen=@da res=(each gage tang)]
|
|
^+ +>
|
|
?~ dok
|
|
~& %clay-take-mutating-unexpected-made +>.$
|
|
?. =(~ mut.u.dok)
|
|
~& %clay-take-mutating-redundant-made +>.$
|
|
=- =. mut.u.dok `-
|
|
?: ?& ?=(^ ins.u.dok)
|
|
?=(^ dif.u.dok)
|
|
==
|
|
(apply-edit wen)
|
|
+>.$
|
|
^- (list (trel path lobe cage))
|
|
%+ murn (tage-to-cages (made-to-tage res))
|
|
|= [pax=cage cay=cage]
|
|
^- (unit (pair path (pair lobe cage)))
|
|
?. ?=(%path p.pax)
|
|
~|(%clay-take-mutating-strange-path-mark !!)
|
|
?: ?=(%null p.cay)
|
|
~
|
|
=+ paf=((hard path) q.q.pax)
|
|
`[paf (~(got by muh.u.dok) paf) cay]
|
|
::
|
|
++ take-patch
|
|
|= res=(each gage tang)
|
|
^+ +>
|
|
:: ~& %taking-patch
|
|
?: ?=(%| -.res)
|
|
%_ +>.$
|
|
dok ~
|
|
yel
|
|
[[hen %note '!' %rose [" " "" ""] leaf/"clay patch failed" p.res] yel]
|
|
==
|
|
:: ~& %editing
|
|
=+ ^- sim=(list (pair path misu))
|
|
?~ dok
|
|
~|(%no-changes !!)
|
|
?> ?=(^ ins.u.dok)
|
|
?> ?=(^ dif.u.dok)
|
|
?> ?=(^ mut.u.dok)
|
|
;: welp
|
|
^- (list (pair path misu))
|
|
(turn del.u.dok |=([pax=path cay=cage] [pax %del cay]))
|
|
::
|
|
^- (list (pair path misu))
|
|
(turn ink.u.dok |=([pax=path cay=cage] [pax %ins cay]))
|
|
::
|
|
^- (list (pair path misu))
|
|
(turn u.ins.u.dok |=([pax=path cay=cage] [pax %ins cay]))
|
|
::
|
|
^- (list (pair path misu))
|
|
(turn u.dif.u.dok |=([pax=path cal=[lobe cage]] [pax %dif cal]))
|
|
::
|
|
^- (list (pair path misu))
|
|
(turn u.mut.u.dok |=([pax=path cal=[lobe cage]] [pax %dif cal]))
|
|
==
|
|
=^ hat +>.$ (edit:ze now %& *cart sim) :: XX we do same thing in ++apply-edit
|
|
?~ dok ~& %no-dok +>.$
|
|
=>
|
|
%= .
|
|
+>.$
|
|
?< ?=(~ hat) :: XX whut?
|
|
(echo now %& *cart sim)
|
|
==
|
|
?~ dok ~& %no-dok +>.$
|
|
=+ cay=p.res
|
|
?@ p.cay ~| %patch-bad-marc !!
|
|
:: ~& %canning
|
|
=+ ^= can
|
|
|- ^- (list ,[path cage])
|
|
?~ p.p.cay
|
|
~
|
|
:_ %_($ cay [[%tabl t.p.p.cay] (slot 3 q.cay)])
|
|
?. ?=(%path p.i.p.p.cay)
|
|
~| %patch-strange-marc-a
|
|
!!
|
|
?. ?=(@ q.i.p.p.cay)
|
|
~| %patch-strange-marc-b
|
|
!!
|
|
=+ coy=(slot 2 q.cay)
|
|
?@ q.coy
|
|
~| %patch-strange-coy
|
|
!!
|
|
:- ((hard path) -.q.coy)
|
|
[q.i.p.p.cay (slot 3 coy)]
|
|
:: ~& %canned
|
|
:: ~& %checking-out
|
|
=. ank.dom (checkout-ankh:ze (mo can))
|
|
=. +>.$ =>(wake ?>(?=(^ dok) .))
|
|
:: ~& %checked-out
|
|
?~ hez +>.$(dok ~)
|
|
?. syn +>.$(dok ~)
|
|
=+ ^= ceq
|
|
|= a=miso
|
|
?| ?=(%del -.a)
|
|
&(?=(%ins -.a) ?=(%mime -.+.a))
|
|
&(?=(%mut -.a) ?=(%mime -.+>.a))
|
|
==
|
|
:: ~& %forming-ergo
|
|
:: =- ~& %formed-ergo -
|
|
%_ +>.$
|
|
dok ~
|
|
tag :: ?~(hez reg :_(reg [u.hez [%ergo who syd let.dom]]))
|
|
:_ tag
|
|
:* hen %pass [%ergoing (scot %p who) syd ~] %f
|
|
%exec who [who syd %da now] ~ %tabl
|
|
^- (list (pair silk silk))
|
|
%+ turn sim
|
|
|= [a=path b=misu]
|
|
^- (pair silk silk)
|
|
:- [%done ~ %path !>(a)]
|
|
?: ?=(%del -.b)
|
|
[%done ~ %null !>(~)]
|
|
=+ (~(get by mim.u.dok) a)
|
|
?^ - [%done ~ %mime !>(u.-)]
|
|
:^ %cast %mime %done :- ~
|
|
(need (read:ze %x [%ud let.dom] a))
|
|
==
|
|
==
|
|
::
|
|
++ take-ergo
|
|
|= res=(each gage tang)
|
|
^+ +>
|
|
?: ?=(%| -.res)
|
|
%_ +>.$
|
|
yel
|
|
[[hen %note '!' %rose [" " "" ""] leaf/"clay ergo failed" p.res] yel]
|
|
==
|
|
?~ hez ~|(%no-sync-duct !!)
|
|
?. syn ~|(%sync-off !!)
|
|
=+ cay=p.res
|
|
?@ p.cay ~| %patch-bad-marc !!
|
|
%= +>.$
|
|
reg
|
|
:_ reg
|
|
:* u.hez %ergo who syd let.dom
|
|
|- ^- (list ,[path (unit mime)])
|
|
?~ p.p.cay
|
|
~
|
|
:_ %_($ cay [[%tabl t.p.p.cay] (slot 3 q.cay)])
|
|
?. ?=(%path p.i.p.p.cay)
|
|
~| %ergo-strange-marc-a
|
|
!!
|
|
?. ?=(@ q.i.p.p.cay)
|
|
~| %ergo-strange-marc-b
|
|
!!
|
|
=+ coy=(slot 2 q.cay)
|
|
?@ q.coy
|
|
~| %ergo-strange-coy
|
|
!!
|
|
:- ((hard path) -.q.coy)
|
|
?. ?=(%mime q.i.p.p.cay)
|
|
~
|
|
`((hard mime) q:(slot 3 coy))
|
|
==
|
|
==
|
|
::
|
|
++ checkout-ankh
|
|
|= hat=(map path lobe)
|
|
^+ +>
|
|
%_ +>.$
|
|
tag
|
|
:_ tag
|
|
:* hen %pass [%patching (scot %p who) syd ~] %f
|
|
%exec who [who syd %da now] :+ ~ %tabl
|
|
^- (list (pair silk silk))
|
|
%+ turn (~(tap by hat))
|
|
|= [a=path b=lobe]
|
|
^- (pair silk silk)
|
|
:- [%done ~ %path !>(a)]
|
|
(lobe-to-silk:ze a b)
|
|
==
|
|
==
|
|
::
|
|
++ apply-foreign-update :: apply subscription
|
|
|= $: gar=(map aeon tako) :: new ids
|
|
let=aeon :: next id
|
|
lar=(set yaki) :: new commits
|
|
bar=(set blob) :: new content
|
|
==
|
|
^+ +>
|
|
%= +>
|
|
hit.dom (~(uni by hit.dom) gar)
|
|
let.dom let
|
|
hut.ran %- ~(uni by hut.ran)
|
|
%- mo ^- (list (pair tako yaki))
|
|
%+ turn (~(tap in lar))
|
|
|= yak=yaki
|
|
[r.yak yak]
|
|
lat.ran %- ~(uni by lat.ran)
|
|
%- mo ^- (list (pair lobe blob))
|
|
%+ turn (~(tap in bar))
|
|
|= bol=blob
|
|
[p.bol bol]
|
|
==
|
|
::
|
|
++ exec :: change and update
|
|
|= [wen=@da lem=nori]
|
|
^+ +>
|
|
(edit wen lem)
|
|
::
|
|
++ exem :: execute merge
|
|
|= [wen=@da her=@p sud=@tas gem=germ] :: aka direct change
|
|
!!
|
|
:: ?. (gte p.mer let.dom) !! :: no
|
|
:: =. +>.$ %= +>.$
|
|
:: hut.ran (~(uni by hut.r.mer) hut.ran)
|
|
:: lat.ran (~(uni by lat.r.mer) lat.ran)
|
|
:: let.dom p.mer
|
|
:: hit.dom (~(uni by q.mer) hit.dom)
|
|
:: ==
|
|
:: =+ ^= hed :: head commit
|
|
:: =< q
|
|
:: %- ~(got by hut.ran)
|
|
:: %- ~(got by hit.dom)
|
|
:: let.dom
|
|
:: (echa:wake:(checkout-ankh hed))
|
|
::
|
|
++ take-foreign-update :: external change
|
|
|= [inx=@ud rut=(unit rand)]
|
|
^+ +>
|
|
?> ?=(^ ref)
|
|
|- ^+ +>+.$
|
|
=+ ruv=(~(get by bom.u.ref) inx)
|
|
?~ ruv +>+.$
|
|
=> ?. |(?=(~ rut) ?=(%sing -.q.u.ruv)) .
|
|
%_ .
|
|
bom.u.ref (~(del by bom.u.ref) inx)
|
|
fod.u.ref (~(del by fod.u.ref) p.u.ruv)
|
|
==
|
|
?~ rut
|
|
=+ rav=`rave`q.u.ruv
|
|
%= +>+.$
|
|
lim
|
|
?.(&(?=(%many -.rav) ?=(%da -.q.q.rav)) lim `@da`p.q.q.rav)
|
|
::
|
|
haw.u.ref
|
|
?. ?=(%sing -.rav) haw.u.ref
|
|
(~(put by haw.u.ref) p.rav ~)
|
|
==
|
|
?- p.p.u.rut
|
|
%u
|
|
~| %im-thinkin-its-prolly-a-bad-idea-to-request-rang-over-the-network
|
|
!!
|
|
::
|
|
%v
|
|
~| %weird-we-shouldnt-get-a-dome-request-over-the-network
|
|
!!
|
|
::
|
|
%x
|
|
=< ?> ?=(^ ref) .
|
|
(rand-to-rant u.rut)
|
|
::
|
|
%w
|
|
=. haw.u.ref
|
|
%+ ~(put by haw.u.ref)
|
|
[p.p.u.rut q.p.u.rut q.u.rut]
|
|
:+ ~
|
|
p.r.u.rut
|
|
?+ p.r.u.rut ~| %strange-w-over-nextwork !!
|
|
%aeon !>(((hard aeon) q.r.u.rut))
|
|
%null [[%atom %n] ~]
|
|
%nako !>(~|([%harding [&1 &2 &3]:q.r.u.rut] ((hard nako) q.r.u.rut)))
|
|
==
|
|
?. ?=(%nako p.r.u.rut) +>+.$
|
|
|- ^+ +>+.^$
|
|
=+ nez=[%w [%ud let.dom] ~]
|
|
=+ nex=(~(get by haw.u.ref) nez)
|
|
?~ nex +>+.^$
|
|
?~ u.nex +>+.^$ :: should never happen
|
|
=. nak.u.ref `((hard nako) q.q.u.u.nex)
|
|
=. +>+.^$
|
|
?: =(0 let.dom)
|
|
=> (apply-foreign-update (need nak.u.ref))
|
|
?>(?=(^ ref) .)
|
|
=> (validate-plops [%ud let.dom] bar:(need nak.u.ref))
|
|
?>(?=(^ ref) .)
|
|
%= $
|
|
haw.u.ref (~(del by haw.u.ref) nez)
|
|
==
|
|
::
|
|
%y
|
|
%_ +>+.$
|
|
haw.u.ref
|
|
%+ ~(put by haw.u.ref)
|
|
[p.p.u.rut q.p.u.rut q.u.rut]
|
|
`[p.r.u.rut !>(((hard arch) q.r.u.rut))]
|
|
==
|
|
::
|
|
%z
|
|
~| %its-prolly-reasonable-to-request-ankh-over-the-network-sorry
|
|
!!
|
|
==
|
|
::
|
|
++ rand-to-rant
|
|
|= rut=rand
|
|
^+ +>
|
|
~| [%x-over-network-not-implemented [p q -.r]:rut hen] !!
|
|
:: =- %_(+>.$ tag [- tag])
|
|
:: :* hen
|
|
:: [%foreign-plops (scot %p who) (scot %p for) syd ~]
|
|
:: %f %exec who ~ %tabl
|
|
:: ^- (list (pair silk silk))
|
|
:: %+ turn (~(tap in pop))
|
|
:: |= a=plop
|
|
:: ?- -.a
|
|
:: %delta
|
|
:: :- [%done ~ %blob !>([%delta p.a q.a *cage])]
|
|
:: [%vale p.r.a him q.r.a]
|
|
:: ::
|
|
:: %direct
|
|
:: :- [%done ~ %blob !>([%direct p.a *cage])]
|
|
:: [%vale p.q.a him q.q.a]
|
|
:: ::
|
|
:: %indirect ~| %foreign-indirect-not-implemented !!
|
|
:: ==
|
|
:: ==
|
|
::
|
|
++ validate-plops
|
|
|= [cas=case pop=(set plop)]
|
|
^+ +>
|
|
=- %_(+>.$ tag [- tag])
|
|
:* hen %pass
|
|
[%foreign-plops (scot %p who) (scot %p for) syd ~]
|
|
%f %exec who [for syd cas] ~ %tabl
|
|
^- (list (pair silk silk))
|
|
%+ turn (~(tap in pop))
|
|
|= a=plop
|
|
?- -.a
|
|
%delta
|
|
:- [%done ~ %blob !>([%delta p.a q.a *page])]
|
|
[%vale p.r.a for q.r.a]
|
|
::
|
|
%direct
|
|
:- [%done ~ %blob !>([%direct p.a *page])]
|
|
[%vale p.q.a for q.q.a]
|
|
::
|
|
%indirect ~| %foreign-indirect-not-implemented !!
|
|
==
|
|
==
|
|
::
|
|
++ take-foreign-plops
|
|
|= res=(each gage tang)
|
|
^+ +>
|
|
?> ?=(^ ref)
|
|
?> ?=(^ nak.u.ref)
|
|
?: ?=(%| -.res)
|
|
~| "validate foreign plops failed"
|
|
~| [%plop-fail (turn p.res |=(tank ~(ram re +<)))]
|
|
!!
|
|
=+ cay=p.res
|
|
?@ p.cay ~| %plop-bad-marc !!
|
|
=+ |- ^- lat=(list blob)
|
|
?~ p.p.cay
|
|
~
|
|
:_ %_($ cay [[%tabl t.p.p.cay] (slot 3 q.cay)])
|
|
?. ?=(%blob p.i.p.p.cay)
|
|
~| %plop-strange-marc-a
|
|
!!
|
|
?. ?=(@ q.i.p.p.cay)
|
|
~| %plop-strange-marc-b
|
|
!!
|
|
=+ coy=(slot 2 q.cay)
|
|
?@ q.coy
|
|
~| %plop-strange-coy
|
|
!!
|
|
=+ bol=((hard blob) -.q.coy)
|
|
?- -.bol
|
|
%delta [-.bol p.bol q.bol q.i.p.p.cay +.q.coy]
|
|
%direct [-.bol p.bol q.i.p.p.cay +.q.coy]
|
|
%indirect ~| %plop-indirect-not-implemented !!
|
|
==
|
|
%^ apply-foreign-update
|
|
gar.u.nak.u.ref
|
|
let.u.nak.u.ref
|
|
[lar.u.nak.u.ref (sa lat)]
|
|
::
|
|
++ mabe :: maybe fire function
|
|
|* [rov=rove fun=$+(@da _+>.^$)]
|
|
^+ +>.$
|
|
%- fall :_ +>.$
|
|
%- bind :_ fun
|
|
^- (unit ,@da)
|
|
?- -.rov
|
|
%sing
|
|
?. ?=(%da -.q.p.rov) ~
|
|
`p.q.p.rov
|
|
::
|
|
%next ~
|
|
%many
|
|
=* mot q.rov
|
|
%+ hunt
|
|
?. ?=(%da -.p.mot) ~
|
|
?.((lth now p.p.mot) ~ [~ p.p.mot])
|
|
?. ?=(%da -.q.mot) ~
|
|
?.((lth now p.q.mot) [~ now] [~ p.q.mot])
|
|
==
|
|
::
|
|
++ reve
|
|
|= rov=rove
|
|
^- rave
|
|
?- -.rov
|
|
%sing rov
|
|
%next [- p]:rov
|
|
%many [%many p.rov p.q.rov q.q.rov r.q.rov]
|
|
==
|
|
::
|
|
++ rive
|
|
|= rav=[%many p=? q=moat]
|
|
^- rove
|
|
[%many p.rav p.q.rav q.q.rav r.q.rav ~]
|
|
::
|
|
++ wake :: update subscribers
|
|
^+ .
|
|
=+ xiq=(~(tap by qyx) ~)
|
|
=| xaq=(list ,[p=duct q=rove])
|
|
|- ^+ ..wake
|
|
?~ xiq
|
|
..wake(qyx (~(gas by *cult) xaq))
|
|
?- -.q.i.xiq
|
|
%sing
|
|
=+ cas=?~(ref ~ (~(get by haw.u.ref) `mood`p.q.i.xiq))
|
|
?^ cas
|
|
%= $
|
|
xiq t.xiq
|
|
..wake ?~ u.cas (blub p.i.xiq)
|
|
(blab p.i.xiq p.q.i.xiq %& u.u.cas)
|
|
==
|
|
=+ nao=(case-to-aeon:ze q.p.q.i.xiq)
|
|
?~ nao $(xiq t.xiq, xaq [i.xiq xaq])
|
|
:: ~& %reading-at-aeon
|
|
=+ vid=(read-at-aeon:ze u.nao p.q.i.xiq)
|
|
:: ~& %red-at-aeon
|
|
?~ vid
|
|
?~ u.nao
|
|
~& [%oh-poor `path`[syd '0' r.p.q.i.xiq]]
|
|
$(xiq t.xiq)
|
|
~& [%oh-well desk=syd mood=p.q.i.xiq aeon=u.nao]
|
|
$(xiq t.xiq, xaq [i.xiq xaq])
|
|
$(xiq t.xiq, ..wake (balk p.i.xiq u.vid p.q.i.xiq))
|
|
::
|
|
%next
|
|
=* mun p.q.i.xiq
|
|
=* dat q.q.i.xiq
|
|
?~ dat
|
|
=+ ver=(aver mun)
|
|
?~ ver
|
|
$(xiq t.xiq, xaq [i.xiq xaq])
|
|
?~ u.ver
|
|
$(xiq t.xiq, ..wake (blub p.i.xiq))
|
|
$(xiq t.xiq, xaq [i.xiq(q.q u.ver) xaq])
|
|
=+ var=(aver mun(q [%ud let.dom]))
|
|
?~ var
|
|
~& [%oh-noes mood=mun letdom=let.dom]
|
|
$(xiq t.xiq)
|
|
?~ u.var
|
|
$(xiq t.xiq, ..wake (blab p.i.xiq mun %& %null [%atom %n] ~))
|
|
?: (equivalent-data:ze u.dat u.u.var)
|
|
$(xiq t.xiq, xaq [i.xiq xaq])
|
|
$(xiq t.xiq, ..wake (blab p.i.xiq mun u.u.var))
|
|
::
|
|
%many
|
|
=+ mot=`moot`q.q.i.xiq
|
|
=+ nab=(case-to-aeon:ze p.mot)
|
|
?~ nab
|
|
$(xiq t.xiq, xaq [i.xiq xaq])
|
|
=+ huy=(case-to-aeon:ze q.mot)
|
|
?~ huy
|
|
=+ ptr=[%ud +(let.dom)]
|
|
%= $
|
|
xiq t.xiq
|
|
xaq [[p.i.xiq [%many p.q.i.xiq ptr q.mot r.mot s.mot]] xaq]
|
|
..wake =+ ^= ear
|
|
(lobes-at-path:ze let.dom r.mot)
|
|
?: =(s.mot ear) ..wake
|
|
(bleb p.i.xiq let.dom ?:(p.q.i.xiq ~ `[u.nab let.dom]))
|
|
==
|
|
%= $
|
|
xiq t.xiq
|
|
..wake =- (blub:- p.i.xiq)
|
|
=+ ^= ear
|
|
(lobes-at-path:ze u.huy r.mot)
|
|
?: =(s.mot ear) (blub p.i.xiq)
|
|
(bleb p.i.xiq +(u.nab) ?:(p.q.i.xiq ~ `[u.nab u.huy]))
|
|
==
|
|
==
|
|
++ ze
|
|
|%
|
|
++ aeon-to-tako ~(got by hit.dom)
|
|
++ aeon-to-yaki (cork aeon-to-tako tako-to-yaki)
|
|
++ lobe-to-blob ~(got by lat.ran)
|
|
++ tako-to-yaki ~(got by hut.ran)
|
|
++ lobe-to-mark
|
|
|= a=lobe
|
|
=> (lobe-to-blob a)
|
|
?- -
|
|
%delta p.q
|
|
%direct p.q
|
|
%indirect p.q
|
|
==
|
|
++ lobe-to-silk :: XX maybe move hoo{n,k} stuff here
|
|
|= [pax=path lob=lobe]
|
|
^- silk
|
|
=+ ^- hat=(map path lobe)
|
|
?: =(let.dom 0)
|
|
~
|
|
q:(aeon-to-yaki let.dom)
|
|
=+ lol=`(unit lobe)`?.(=(~ ref) `0vsen.tinel (~(get by hat) pax))
|
|
|- ^- silk
|
|
?: =([~ lob] lol)
|
|
=+ (need (need (read-x let.dom pax)))
|
|
?> ?=(%& -<)
|
|
[%done ~ p.-]
|
|
=+ bol=(~(got by lat.ran) lob)
|
|
?- -.bol
|
|
%direct [%volt ~ q.bol]
|
|
%indirect [%volt ~ q.bol]
|
|
%delta [%pact $(lob q.q.bol) [%volt ~ r.bol]]
|
|
==
|
|
::
|
|
++ page-to-lobe |=(page (shax (jam +<)))
|
|
++ equivalent-data
|
|
|= [one=(each cage lobe) two=(each cage lobe)]
|
|
^- ?
|
|
?: ?=(%& -.one)
|
|
?: ?=(%& -.two)
|
|
=([p q.q]:p.one [p q.q]:p.two)
|
|
=(p.two (page-to-lobe [p q.q]:p.one))
|
|
?: ?=(%& -.two)
|
|
=(p.one (page-to-lobe [p q.q]:p.two))
|
|
=(p.one p.two)
|
|
::
|
|
++ make-direct :: make blob
|
|
|= p=page
|
|
^- blob
|
|
[%direct (page-to-lobe p) p]
|
|
::
|
|
++ make-delta :: make blob delta
|
|
|= [p=lobe q=[p=mark q=lobe] r=page]
|
|
^- blob
|
|
[%delta p q r]
|
|
::
|
|
++ make-yaki :: make yaki
|
|
|= [p=(list tako) q=(map path lobe) t=@da]
|
|
^- yaki
|
|
=+ ^= has
|
|
%^ cat 7 (sham [%yaki (roll p add) q t])
|
|
(sham [%tako (roll p add) q t])
|
|
[p q has t]
|
|
::
|
|
++ apply-changes :: apply-changes:ze
|
|
|= lar=(list ,[p=path q=misu]) :: store changes
|
|
^- (map path blob)
|
|
=+ ^= hat :: current state
|
|
?: =(let.dom 0) :: initial commit
|
|
~ :: has nothing
|
|
=< q
|
|
%- aeon-to-yaki
|
|
let.dom
|
|
=- =+ sar=(sa (turn lar |=([p=path *] p))) :: changed paths
|
|
%+ roll (~(tap by hat) ~) :: find unchanged
|
|
=< .(bat bar)
|
|
|= [[pax=path gar=lobe] bat=(map path blob)]
|
|
?: (~(has in sar) pax) :: has update
|
|
bat
|
|
%+ ~(put by bat) pax
|
|
~| [pax gar (lent (~(tap by lat.ran)))]
|
|
(lobe-to-blob gar) :: use original
|
|
^= bar ^- (map path blob)
|
|
%+ roll lar
|
|
|= [[pax=path mys=misu] bar=(map path blob)]
|
|
^+ bar
|
|
?- -.mys
|
|
%ins :: insert if not exist
|
|
?: (~(has by bar) pax) !! ::
|
|
?: (~(has by hat) pax) !! ::
|
|
%+ ~(put by bar) pax
|
|
%- make-direct
|
|
?: &(?=(%mime -.p.mys) =([%hook ~] (slag (dec (lent pax)) pax)))
|
|
`page`[%hook +.+.q.q.p.mys]
|
|
?: &(?=(%mime -.p.mys) =([%hoon ~] (slag (dec (lent pax)) pax)))
|
|
`page`[%hoon +.+.q.q.p.mys]
|
|
[p q.q]:p.mys
|
|
%del :: delete if exists
|
|
?. |((~(has by hat) pax) (~(has by bar) pax)) !!
|
|
(~(del by bar) pax)
|
|
%dif :: mutate, must exist
|
|
=+ ber=(~(get by bar) pax) :: XX typed
|
|
=+ for==>((flop pax) ?~(. %$ i))
|
|
?~ ber
|
|
=+ har=(~(get by hat) pax)
|
|
?~ har !!
|
|
%+ ~(put by bar) pax
|
|
(make-delta p.mys [(lobe-to-mark u.har) u.har] [p q.q]:q.mys)
|
|
:: XX check vase !evil
|
|
%+ ~(put by bar) pax
|
|
(make-delta p.mys [(lobe-to-mark p.u.ber) p.u.ber] [p q.q]:q.mys)
|
|
:: XX check vase !evil
|
|
==
|
|
::
|
|
++ as-arch
|
|
^- arch
|
|
:+ p.ank.dom
|
|
?~(q.ank.dom ~ [~ p.u.q.ank.dom])
|
|
|- ^- (map ,@ta ,~)
|
|
?~ r.ank.dom ~
|
|
[[p.n.r.ank.dom ~] $(r.ank.dom l.r.ank.dom) $(r.ank.dom r.r.ank.dom)]
|
|
::
|
|
++ case-to-aeon :: case-to-aeon:ze
|
|
|= lok=case :: act count through
|
|
^- (unit aeon)
|
|
?- -.lok
|
|
%da
|
|
?: (gth p.lok lim) ~
|
|
|- ^- (unit aeon)
|
|
?: =(0 let.dom) [~ 0] :: avoid underflow
|
|
?: %+ gte p.lok
|
|
=< t
|
|
~| [%letdom let=let.dom hit=hit.dom hut=(~(run by hut.ran) ,~)]
|
|
~| [%getdom (~(get by hit.dom) let.dom)]
|
|
%- aeon-to-yaki
|
|
let.dom
|
|
[~ let.dom]
|
|
$(let.dom (dec let.dom))
|
|
::
|
|
%tas (~(get by lab.dom) p.lok)
|
|
%ud ?:((gth p.lok let.dom) ~ [~ p.lok])
|
|
==
|
|
::
|
|
++ checkout-ankh
|
|
|= hat=(map path cage)
|
|
^- ankh
|
|
%- cosh
|
|
%+ roll (~(tap by hat) ~)
|
|
|= [[pat=path zar=cage] ank=ankh]
|
|
^- ankh
|
|
%- cosh
|
|
?~ pat
|
|
ank(q [~ (sham q.q.zar) zar])
|
|
=+ nak=(~(get by r.ank) i.pat)
|
|
%= ank
|
|
r %+ ~(put by r.ank) i.pat
|
|
$(pat t.pat, ank (fall nak *ankh))
|
|
==
|
|
::
|
|
++ cosh
|
|
|= ank=ankh
|
|
%_ ank
|
|
p
|
|
^- cash
|
|
%+ mix ?~(q.ank 0 p.u.q.ank)
|
|
=+ axe=1
|
|
|- ^- cash
|
|
?~ r.ank *@
|
|
;: 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))
|
|
==
|
|
==
|
|
::
|
|
++ edit :: edit:ze
|
|
|= [wen=@da lem=nuri] :: edit
|
|
^- [(unit (map path lobe)) _..ze]
|
|
?- -.lem
|
|
& =^ yak lat.ran :: merge objects
|
|
%+ forge-yaki wen
|
|
?: =(let.dom 0) :: initial import
|
|
[~ p.lem]
|
|
[(some r:(aeon-to-yaki let.dom)) p.lem]
|
|
?. ?| =(0 let.dom)
|
|
!=((lent p.yak) 1)
|
|
!(equiv q.yak q:(aeon-to-yaki let.dom))
|
|
==
|
|
`..ze :: silently ignore
|
|
=: let.dom +(let.dom)
|
|
hit.dom (~(put by hit.dom) +(let.dom) r.yak)
|
|
hut.ran (~(put by hut.ran) r.yak yak)
|
|
==
|
|
[`q.yak ..ze]
|
|
:: +>.$(ank (checkout-ankh q.yak))
|
|
| ?< (~(has by lab.dom) p.lem)
|
|
[~ ..ze(lab.dom (~(put by lab.dom) p.lem let.dom))]
|
|
==
|
|
::
|
|
++ equiv :: test paths
|
|
|= [p=(map path lobe) q=(map path lobe)]
|
|
^- ?
|
|
=- ?. qat %.n
|
|
%+ levy (~(tap by q) ~)
|
|
|= [pat=path lob=lobe]
|
|
(~(has by p) pat)
|
|
^= qat
|
|
%+ levy (~(tap by p) ~)
|
|
|= [pat=path lob=lobe]
|
|
=+ zat=(~(get by q) pat)
|
|
?~ zat %.n
|
|
=(u.zat lob)
|
|
:: =((lobe-to-cage u.zat) (lobe-to-cage lob))
|
|
::
|
|
++ forge-nori :: forge-nori:ze
|
|
|= yak=yaki :: forge nori
|
|
^- nori
|
|
!!
|
|
:: ?~ p.yak !! :: no parent, no diff
|
|
:: :+ %& *cart :: diff w/ 1st parent
|
|
:: (~(tap by (diff-yakis (tako-to-yaki i.p.yak) yak)) ~)
|
|
::
|
|
++ forge-yaki :: forge-yaki:ze
|
|
|= [wen=@da par=(unit tako) lem=suba] :: forge yaki
|
|
=+ ^= per
|
|
?~ par ~
|
|
~[u.par]
|
|
=+ gar=(update-lat (apply-changes q.lem) lat.ran)
|
|
:- (make-yaki per +.gar wen) :: from existing diff
|
|
-.gar :: fix lat
|
|
::
|
|
++ lobes-at-path :: lobes-at-path:ze
|
|
|= [yon=aeon pax=path] :: data at path
|
|
^- (map path lobe)
|
|
?: =(0 yon) ~
|
|
%- mo
|
|
%+ skim
|
|
%. ~
|
|
%~ tap by
|
|
=< q
|
|
%- aeon-to-yaki
|
|
yon
|
|
|= [p=path q=lobe]
|
|
?| ?=(~ pax)
|
|
?& !?=(~ p)
|
|
=(-.pax -.p)
|
|
$(p +.p, pax +.pax)
|
|
== ==
|
|
::
|
|
++ make-nako
|
|
|= [a=aeon b=aeon]
|
|
^- nako
|
|
:+ hit.dom
|
|
let.dom
|
|
(data-twixt-takos (~(get by hit.dom) a) (aeon-to-tako b))
|
|
::
|
|
++ query :: query:ze
|
|
|= ren=?(%u %v %x %y %z) :: endpoint query
|
|
^- (unit cage)
|
|
?- ren
|
|
%u !! :: [~ %null [%atom %n] ~]
|
|
%v [~ %dome !>(dom)]
|
|
%x !! :: ?~(q.ank.dom ~ [~ q.u.q.ank.dom])
|
|
%y !! :: [~ %arch !>(as-arch)]
|
|
%z [~ %ankh !>(ank.dom)]
|
|
==
|
|
::
|
|
++ new-lobes :: object hash set
|
|
|= [b=(set lobe) a=(set tako)] :: that aren't in b
|
|
^- (set lobe)
|
|
%+ roll (~(tap in a) ~)
|
|
|= [tak=tako bar=(set lobe)]
|
|
^- (set lobe)
|
|
=+ yak=(tako-to-yaki tak)
|
|
%+ roll (~(tap by q.yak) ~)
|
|
=< .(far bar)
|
|
|= [[path lob=lobe] far=(set lobe)]
|
|
^- (set lobe)
|
|
?~ (~(has in b) lob) :: don't need
|
|
far
|
|
=+ gar=(lobe-to-blob lob)
|
|
?- -.gar
|
|
%direct (~(put in far) lob)
|
|
%delta (~(put in $(lob q.q.gar)) lob)
|
|
%indirect (~(put in $(lob r.gar)) lob)
|
|
==
|
|
::
|
|
++ data-twixt-takos
|
|
|= [a=(unit tako) b=tako]
|
|
^- [(set yaki) (set plop)]
|
|
=+ old=?~(a ~ (reachable-takos u.a))
|
|
=+ ^- yal=(set tako)
|
|
%- sa
|
|
%+ skip
|
|
(~(tap in (reachable-takos b)))
|
|
|=(tak=tako (~(has in old) tak))
|
|
:- (sa (turn (~(tap in yal)) tako-to-yaki))
|
|
(sa (turn (~(tap in (new-lobes (new-lobes ~ old) yal))) lobe-to-blob))
|
|
::
|
|
++ reachable-takos :: reachable
|
|
|= p=tako :: XX slow
|
|
^- (set tako)
|
|
=+ y=(tako-to-yaki p)
|
|
=+ t=(~(put in *(set tako)) p)
|
|
%+ roll p.y
|
|
=< .(s t)
|
|
|= [q=tako s=(set tako)]
|
|
?: (~(has in s) q) :: already done
|
|
s :: hence skip
|
|
(~(uni in s) ^$(p q)) :: otherwise traverse
|
|
::
|
|
++ read :: read:ze
|
|
|= mun=mood :: read at point
|
|
^- (unit cage)
|
|
?: ?=(%v p.mun)
|
|
[~ %dome !>(dom)]
|
|
?: &(?=(%w p.mun) !?=(%ud -.q.mun))
|
|
?^(r.mun ~ [~ %aeon !>(let.dom)])
|
|
?: ?=(%w p.mun)
|
|
=+ ^= yak
|
|
%- aeon-to-yaki
|
|
let.dom
|
|
?^(r.mun ~ [~ %w !>([t.yak (forge-nori yak)])])
|
|
(query(ank.dom ank:(descend-path:(zu ank.dom) r.mun)) p.mun)
|
|
::
|
|
++ read-u
|
|
|= [yon=aeon pax=path]
|
|
^- (unit (unit (each ,[%null (hypo ,~)] lobe)))
|
|
=+ tak=(~(get by hit.dom) yon)
|
|
?~ tak
|
|
~
|
|
```[%null [%atom %n] ~]
|
|
::
|
|
++ read-x
|
|
|= [yon=aeon pax=path]
|
|
^- (unit (unit (each cage lobe)))
|
|
=+ tak=(~(get by hit.dom) yon)
|
|
?~ tak
|
|
~
|
|
?: &(?=(~ ref) =(yon let.dom))
|
|
`(bind q.ank:(descend-path:(zu ank.dom) pax) (corl (cury same %&) tail))
|
|
=+ yak=(tako-to-yaki u.tak)
|
|
=+ lob=(~(get by q.yak) pax)
|
|
?~ lob
|
|
[~ ~]
|
|
=+ mar=(lobe-to-mark u.lob)
|
|
?. ?=(?(%hoon %hook) mar)
|
|
[~ ~ %| u.lob]
|
|
:^ ~ ~ %&
|
|
:+ mar [%atom %t]
|
|
|- ^- @t :: (urge cord) would be faster
|
|
=+ bol=(lobe-to-blob u.lob)
|
|
?: ?=(%direct -.bol)
|
|
((hard ,@t) q.q.bol)
|
|
?: ?=(%indirect -.bol)
|
|
((hard ,@t) q.q.bol)
|
|
?> ?=(%delta -.bol)
|
|
=+ txt=$(u.lob q.q.bol)
|
|
?> ?=(%txt-diff p.r.bol)
|
|
=+ dif=((hard (urge cord)) q.r.bol)
|
|
=+ pac=(role (lurk (lore (cat 3 txt '\0a')) dif))
|
|
(end 3 (dec (met 3 pac)) pac)
|
|
::
|
|
++ read-y
|
|
|= [yon=aeon pax=path]
|
|
^- (unit (unit ,[%arch (hypo arch)]))
|
|
=+ tak=(~(get by hit.dom) yon)
|
|
?~ tak
|
|
~
|
|
=+ yak=(tako-to-yaki u.tak)
|
|
=+ len=(lent pax)
|
|
:^ ~ ~ %arch
|
|
:- -:!>(*arch)
|
|
^- arch
|
|
=+ ^- descendants=(list (pair path lobe))
|
|
:: ~& > %turning
|
|
:: =- ~& > %turned -
|
|
%+ turn
|
|
:: ~& > %skimming
|
|
:: =- ~& > %skimmed -
|
|
%+ skim (~(tap by (~(del by q.yak) pax)))
|
|
|= [paf=path lob=lobe]
|
|
=(pax (scag len paf))
|
|
|= [paf=path lob=lobe]
|
|
[(slag len paf) lob]
|
|
=+ us=(~(get by q.yak) pax)
|
|
:+ ?: &(?=(~ descendants) ?=(~ us))
|
|
*@uvI
|
|
%+ roll
|
|
^- (list (pair path lobe))
|
|
[[~ ?~(us *lobe u.us)] descendants]
|
|
|=([[path lobe] @uvI] (shax (jam +<)))
|
|
us
|
|
^- (map span ,~)
|
|
%- mo ^- (list (pair span ,~))
|
|
%+ turn descendants
|
|
|= [paf=path lob=lobe]
|
|
[?>(?=(^ paf) i.paf) ~]
|
|
::
|
|
++ read-at-aeon :: read-at-aeon:ze
|
|
|= [yon=aeon mun=mood] :: seek and read
|
|
^- (unit (unit (each cage lobe)))
|
|
?: &(?=(%w p.mun) !?=(%ud -.q.mun)) :: NB only for speed
|
|
?^(r.mun [~ ~] [~ ~ %& %aeon !>(yon)])
|
|
?: ?=(%u p.mun)
|
|
(read-u yon r.mun)
|
|
?: ?=(%x p.mun)
|
|
(read-x yon r.mun)
|
|
?: ?=(%y p.mun)
|
|
(bind (read-y yon r.mun) (curr bind (cury same %&)))
|
|
%+ bind
|
|
(rewind yon)
|
|
|= a=(unit ,_+>.$)
|
|
^- (unit (each cage lobe))
|
|
?~ a
|
|
~
|
|
`(unit (each cage lobe))`(bind (read:u.a mun) (cury same %&))
|
|
::
|
|
++ rewind :: rewind:ze
|
|
|= yon=aeon :: rewind to aeon
|
|
^- (unit (unit ,_+>))
|
|
?: =(let.dom yon) ``+>
|
|
?: (gth yon let.dom) !! :: don't have version
|
|
=+ hat=q:(aeon-to-yaki yon)
|
|
?: (~(any by hat) |=(a=lobe ?=(%delta [-:(lobe-to-blob a)])))
|
|
~
|
|
~
|
|
::=+ ^- (map path cage)
|
|
:: %- ~(run by hat)
|
|
:: |= a=lobe
|
|
:: =+ (lobe-to-blob a)
|
|
:: ?-(-.- %direct q.-, %indirect q.-, %delta !!)
|
|
::`+>.$(ank.dom (checkout-ankh -), let.dom yon)
|
|
::
|
|
++ 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) ~)
|
|
=< .(lut sta)
|
|
|= [[pat=path bar=blob] [lut=(map lobe blob) 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)
|
|
::
|
|
++ zu :: filesystem
|
|
|= ank=ankh :: filesystem state
|
|
=| ram=path :: reverse path into
|
|
|%
|
|
++ descend :: descend
|
|
|= lol=@ta
|
|
^+ +>
|
|
=+ you=(~(get by r.ank) lol)
|
|
+>.$(ram [lol ram], ank ?~(you [*cash ~ ~] u.you))
|
|
::
|
|
++ descend-path :: descend recursively
|
|
|= way=path
|
|
^+ +>
|
|
?~(way +> $(way t.way, +> (descend i.way)))
|
|
--
|
|
::
|
|
++ me :: merge ali into bob
|
|
|= [ali=(pair ship desk) alh=(unit ankh)] :: from
|
|
=+ bob=`(pair ship desk)`[who syd] :: to
|
|
=+ dat=(fall (~(get by mer) ali) *mery) :: merge data
|
|
=| don=? :: keep going
|
|
|%
|
|
++ abet
|
|
^+ ..me
|
|
?: don
|
|
..me(mer (~(put by mer) ali dat))
|
|
..me(mer (~(del by mer) ali), reg :_(reg [hen %mere gon.dat]))
|
|
::
|
|
++ route
|
|
|= [sat=term res=(each riot (each gage tang))]
|
|
^+ +>.$
|
|
?+ sat ~|((crip <[%bad-stage sat]>) !!)
|
|
%ali %- fetched-ali ?> ?=(%& -.res) p.res
|
|
%diff-ali %- diffed-ali ?> ?=(%| -.res) p.res
|
|
%diff-bob %- diffed-bob ?> ?=(%| -.res) p.res
|
|
%merge %- merged ?> ?=(%| -.res) p.res
|
|
%build %- built ?> ?=(%| -.res) p.res
|
|
%checkout %- checked-out ?> ?=(%| -.res) p.res
|
|
%ergo %- ergoed ?> ?=(%| -.res) p.res
|
|
==
|
|
::
|
|
++ start
|
|
|= gem=germ
|
|
^+ +>
|
|
?: (~(has by mer) ali)
|
|
(error:he %already-merging ~)
|
|
?: &(=(0 let.dom) !?=(?(%init %that) gem))
|
|
(error:he %no-bob-desk ~)
|
|
=. gem.dat gem
|
|
=. cas.dat [%da now]
|
|
?: =(0 let.dom)
|
|
fetch-ali(gem.dat %init)
|
|
=+ (~(get by hit.dom) let.dom)
|
|
?~ -
|
|
(error:he %no-bob--version ~)
|
|
=+ (~(get by hut.ran) u.-)
|
|
?~ -
|
|
(error:he %no-bob-commit ~)
|
|
fetch-ali(bob.dat u.-)
|
|
::
|
|
++ fetch-ali
|
|
^+ .
|
|
=- %_(+ tag [- tag])
|
|
:* hen %pass
|
|
[%merge (scot %p p.bob) q.bob (scot %p p.ali) q.ali %ali ~]
|
|
%c %warp [p.bob p.ali] q.ali
|
|
`[%sing %v cas.dat /]
|
|
==
|
|
::
|
|
++ fetched-ali
|
|
|= rot=riot
|
|
^+ +>
|
|
?~ rot
|
|
(error:he %bad-fetch-ali ~)
|
|
=+ ^= dum
|
|
%- (hard ,[ank=* let=@ud hit=(map ,@ud tako) lab=(map ,@tas ,@ud)])
|
|
q.q.r.u.rot
|
|
?: =(0 let.dum)
|
|
(error:he %no-ali-desk ~)
|
|
=+ (~(get by hit.dum) let.dum)
|
|
?~ -
|
|
(error:he %no-ali-version ~)
|
|
=+ (~(get by hut.ran) u.-)
|
|
?~ -
|
|
(error:he %no-ali-commit ~)
|
|
=. ali.dat u.-
|
|
|-
|
|
?- gem.dat
|
|
%init
|
|
?. =(let.dom 0)
|
|
(error:he %bad-init-merge ~)
|
|
:: skim hook/hoon files/
|
|
=. new.dat ali.dat
|
|
=. hut.ran (~(put by hut.ran) r.new.dat new.dat)
|
|
=. erg.dat (~(run by q.ali.dat) |=(lobe %&))
|
|
checkout
|
|
::
|
|
%fine
|
|
?: =(r.ali.dat r.bob.dat)
|
|
:: ~& [%fine-trivial ali=<ali> bob=<bob> r.ali.dat r.bob.dat]
|
|
(done:he ~)
|
|
?: (~(has in (reachable-takos r.bob.dat)) r.ali.dat)
|
|
:: ~& [%fine-mostly-trivial ali=<ali> bob=<bob>]
|
|
(done:he ~)
|
|
?. (~(has in (reachable-takos r.ali.dat)) r.bob.dat)
|
|
:: ~& [%fine-not-so-trivial ali=<ali> bob=<bob>]
|
|
(error:he %bad-fine-merge ~)
|
|
:: ~& [%fine-lets-go ali=<ali> bob=<bob>]
|
|
=. new.dat ali.dat
|
|
=. erg.dat
|
|
%- mo ^- (list ,[path ?])
|
|
%+ murn (~(tap by (~(uni by q.bob.dat) q.ali.dat)))
|
|
|= [pax=path lob=lobe]
|
|
^- (unit ,[path ?])
|
|
=+ a=(~(get by q.ali.dat) pax)
|
|
=+ b=(~(get by q.bob.dat) pax)
|
|
?: =(a b)
|
|
~
|
|
`[pax !=(~ a)]
|
|
checkout
|
|
::
|
|
%this
|
|
?: =(r.ali.dat r.bob.dat)
|
|
(done:he ~)
|
|
?: (~(has in (reachable-takos r.bob.dat)) r.ali.dat)
|
|
(done:he ~)
|
|
=. new.dat (make-yaki [r.ali.dat r.bob.dat ~] q.bob.dat now)
|
|
=. hut.ran (~(put by hut.ran) r.new.dat new.dat)
|
|
=. erg.dat ~
|
|
checkout
|
|
::
|
|
%that
|
|
?: =(r.ali.dat r.bob.dat)
|
|
(done:he ~)
|
|
?: (~(has in (reachable-takos r.bob.dat)) r.ali.dat)
|
|
(done:he ~)
|
|
=. new.dat (make-yaki [r.ali.dat r.bob.dat ~] q.ali.dat now)
|
|
=. hut.ran (~(put by hut.ran) r.new.dat new.dat)
|
|
=. erg.dat
|
|
%- mo ^- (list ,[path ?])
|
|
%+ murn (~(tap by (~(uni by q.bob.dat) q.ali.dat)))
|
|
|= [pax=path lob=lobe]
|
|
^- (unit ,[path ?])
|
|
=+ a=(~(get by q.ali.dat) pax)
|
|
=+ b=(~(get by q.bob.dat) pax)
|
|
?: =(a b)
|
|
~
|
|
`[pax !=(~ a)]
|
|
checkout
|
|
::
|
|
?(%meet %mate %meld)
|
|
?: =(r.ali.dat r.bob.dat)
|
|
(done:he ~)
|
|
?: (~(has in (reachable-takos r.bob.dat)) r.ali.dat)
|
|
(done:he ~)
|
|
?: (~(has in (reachable-takos r.ali.dat)) r.bob.dat)
|
|
$(gem.dat %fine)
|
|
=+ r=(find-merge-points:he ali.dat bob.dat)
|
|
?~ r
|
|
(error:he %merge-no-merge-base ~)
|
|
?. ?=([* ~ ~] r)
|
|
=+ (lent (~(tap in `(set yaki)`r)))
|
|
(error:he %merge-criss-cross >[-]< ~)
|
|
=. bas.dat n.r
|
|
?: ?=(?(%mate %meld) gem.dat)
|
|
diff-ali
|
|
=. new.dal.dat
|
|
%- mo
|
|
%+ skip (~(tap by q.ali.dat))
|
|
|= [pax=path lob=lobe]
|
|
(~(has by q.bas.dat) pax)
|
|
=. cal.dal.dat
|
|
%- mo
|
|
%+ skip (~(tap by q.ali.dat))
|
|
|= [pax=path lob=lobe]
|
|
=+ (~(get by q.bas.dat) pax)
|
|
|(=(~ -) =([~ lob] -))
|
|
=. can.dal.dat
|
|
~
|
|
=. old.dal.dat
|
|
%- mo ^- (list ,[path ~])
|
|
%+ murn (~(tap by q.bas.dat))
|
|
|= [pax=path lob=lobe]
|
|
^- (unit (pair path ,~))
|
|
?. =(~ (~(get by q.ali.dat) pax))
|
|
~
|
|
`[pax ~]
|
|
=. new.dob.dat
|
|
%- mo
|
|
%+ skip (~(tap by q.bob.dat))
|
|
|= [pax=path lob=lobe]
|
|
(~(has by q.bas.dat) pax)
|
|
=. cal.dob.dat
|
|
%- mo
|
|
%+ skip (~(tap by q.bob.dat))
|
|
|= [pax=path lob=lobe]
|
|
=+ (~(get by q.bas.dat) pax)
|
|
|(=(~ -) =([~ lob] -))
|
|
=. can.dob.dat
|
|
~
|
|
=. old.dob.dat
|
|
%- mo ^- (list ,[path ~])
|
|
%+ murn (~(tap by q.bas.dat))
|
|
|= [pax=path lob=lobe]
|
|
^- (unit (pair path ,~))
|
|
?. =(~ (~(get by q.bob.dat) pax))
|
|
~
|
|
`[pax ~]
|
|
=+ ^= bof
|
|
%- %~ int by
|
|
%- ~(uni by `(map path ,*)`new.dal.dat)
|
|
%- ~(uni by `(map path ,*)`cal.dal.dat)
|
|
%- ~(uni by `(map path ,*)`can.dal.dat)
|
|
`(map path ,*)`old.dal.dat
|
|
%- ~(uni by `(map path ,*)`new.dob.dat)
|
|
%- ~(uni by `(map path ,*)`cal.dob.dat)
|
|
%- ~(uni by `(map path ,*)`can.dob.dat)
|
|
`(map path ,*)`old.dob.dat
|
|
?^ bof
|
|
(error:he %meet-conflict >(~(run by `(map path ,*)`bof) ,_~)< ~)
|
|
=+ ^- old=(map path lobe)
|
|
%+ roll (~(tap by (~(uni by old.dal.dat) old.dob.dat)))
|
|
=< .(old q.bas.dat)
|
|
|= [[pax=path ~] old=(map path lobe)]
|
|
(~(del by old) pax)
|
|
=+ ^= hat
|
|
%- ~(uni by old)
|
|
%- ~(uni by new.dal.dat)
|
|
%- ~(uni by new.dob.dat)
|
|
%- ~(uni by cal.dal.dat)
|
|
cal.dob.dat
|
|
=+ ^- del=(map path ,?)
|
|
(~(run by (~(uni by old.dal.dat) old.dob.dat)) |=(~ %|))
|
|
=. new.dat
|
|
(make-yaki [r.ali.dat r.bob.dat ~] hat now)
|
|
=. hut.ran (~(put by hut.ran) r.new.dat new.dat)
|
|
=. erg.dat %- ~(uni by del)
|
|
^- (map path ,?)
|
|
%. |=(lobe %&)
|
|
~(run by (~(uni by new.dal.dat) cal.dal.dat))
|
|
checkout
|
|
==
|
|
::
|
|
++ diff-bas
|
|
|= [nam=term yak=yaki oth=(pair ship desk) yuk=yaki]
|
|
^+ +>
|
|
=- %_(+>.$ tag [- tag])
|
|
:* hen %pass
|
|
=+ (cat 3 %diff- nam)
|
|
[%merge (scot %p p.bob) q.bob (scot %p p.ali) q.ali - ~]
|
|
%f %exec p.bob [p.oth q.oth cas.dat] ~ %tabl
|
|
^- (list (pair silk silk))
|
|
%+ murn (~(tap by q.bas.dat))
|
|
|= [pax=path lob=lobe]
|
|
^- (unit (pair silk silk))
|
|
=+ a=(~(get by q.yak) pax)
|
|
?~ a
|
|
~
|
|
?: =(lob u.a)
|
|
~
|
|
=+ (~(get by q.yuk) pax)
|
|
?~ -
|
|
~
|
|
?: =(u.a u.-)
|
|
~
|
|
:- ~
|
|
:- [%done ~ %path !>(pax)]
|
|
[%diff (lobe-to-silk pax lob) (lobe-to-silk pax u.a)]
|
|
==
|
|
::
|
|
++ diff-ali
|
|
^+ .
|
|
(diff-bas %ali ali.dat ali bob.dat)
|
|
::
|
|
++ diffed-ali
|
|
|= res=(each gage tang)
|
|
^+ +>
|
|
?: ?=(%| -.res)
|
|
(error:he %diff-ali-bad-made leaf/"merge diff ali failed" p.res)
|
|
=+ cay=p.res
|
|
?@ p.cay
|
|
(error:he %diff-ali-bad-marc >p.cay< ~)
|
|
=| can=(map path cage)
|
|
=>
|
|
|- ^+ +
|
|
?~ p.p.cay
|
|
+.$(can ~)
|
|
=+ tal=%_($ cay [[%tabl t.p.p.cay] (slot 3 q.cay)])
|
|
?: ?=(%| -.gon.dat.tal)
|
|
tal
|
|
?. ?=(%path p.i.p.p.cay)
|
|
+.$(+>.$ (error:he %diff-ali-strange-marc-a >p.i.p.p.cay< ~))
|
|
?. ?=(@ q.i.p.p.cay)
|
|
+.$(+>.$ (error:he %diff-ali-strange-marc-b >q.i.p.p.cay< ~))
|
|
=+ coy=(slot 2 q.cay)
|
|
?@ q.coy
|
|
+.$(+>.$ (error:he %diff-ali-strange-coy ~))
|
|
%_ +.$
|
|
can
|
|
%+ ~(put by can:tal)
|
|
((hard path) -.q.coy)
|
|
[q.i.p.p.cay (slot 3 coy)]
|
|
==
|
|
?: ?=(%| -.gon.dat)
|
|
+>.$
|
|
=. new.dal.dat
|
|
%- mo
|
|
%+ skip (~(tap by q.ali.dat))
|
|
|= [pax=path lob=lobe]
|
|
(~(has by q.bas.dat) pax)
|
|
=. cal.dal.dat
|
|
%- mo
|
|
%+ skim (~(tap by q.bas.dat))
|
|
|= [pax=path lob=lobe]
|
|
=+ a=(~(get by q.ali.dat) pax)
|
|
=+ b=(~(get by q.bob.dat) pax)
|
|
?& ?=(^ a)
|
|
!=([~ lob] a)
|
|
=([~ lob] b)
|
|
==
|
|
=. can.dal.dat can
|
|
=. old.dal.dat
|
|
%- mo ^- (list ,[path ~])
|
|
%+ murn (~(tap by q.bas.dat))
|
|
|= [pax=path lob=lobe]
|
|
?. =(~ (~(get by q.ali.dat) pax))
|
|
~
|
|
(some pax ~)
|
|
diff-bob
|
|
::
|
|
++ diff-bob
|
|
^+ .
|
|
(diff-bas %bob bob.dat bob ali.dat)
|
|
::
|
|
++ diffed-bob
|
|
|= res=(each gage tang)
|
|
^+ +>
|
|
?: ?=(%| -.res)
|
|
(error:he %diff-bob-bad-made leaf/"merge diff bob failed" p.res)
|
|
=+ cay=p.res
|
|
?@ p.cay
|
|
(error:he %diff-bob-bad-marc >p.cay< ~)
|
|
=| can=(map path cage)
|
|
=>
|
|
|- ^+ +
|
|
?~ p.p.cay
|
|
+.$(can ~)
|
|
=+ tal=%_($ cay [[%tabl t.p.p.cay] (slot 3 q.cay)])
|
|
?: ?=(%| -.gon.dat.tal)
|
|
tal
|
|
?. ?=(%path p.i.p.p.cay)
|
|
+.$(+>.$ (error:he %diff-bob-strange-marc-a >p.i.p.p.cay< ~))
|
|
?. ?=(@ q.i.p.p.cay)
|
|
+.$(+>.$ (error:he %diff-bob-strange-marc-b >q.i.p.p.cay< ~))
|
|
=+ coy=(slot 2 q.cay)
|
|
?@ q.coy
|
|
+.$(+>.$ (error:he %diff-bob-strange-coy ~))
|
|
%_ +.$
|
|
can
|
|
%+ ~(put by can:tal)
|
|
((hard path) -.q.coy)
|
|
[q.i.p.p.cay (slot 3 coy)]
|
|
==
|
|
?: ?=(%| -.gon.dat)
|
|
+>.$
|
|
=. new.dob.dat
|
|
%- mo
|
|
%+ skip (~(tap by q.bob.dat))
|
|
|= [pax=path lob=lobe]
|
|
(~(has by q.bas.dat) pax)
|
|
=. cal.dob.dat
|
|
%- mo
|
|
%+ skim (~(tap by q.bas.dat))
|
|
|= [pax=path lob=lobe]
|
|
=+ a=(~(get by q.ali.dat) pax)
|
|
=+ b=(~(get by q.bob.dat) pax)
|
|
?& ?=(^ b)
|
|
!=([~ lob] b)
|
|
=([~ lob] a)
|
|
==
|
|
=. can.dob.dat can
|
|
=. old.dob.dat
|
|
%- mo ^- (list ,[path ~])
|
|
%+ murn (~(tap by q.bas.dat))
|
|
|= [pax=path lob=lobe]
|
|
?. =(~ (~(get by q.bob.dat) pax))
|
|
~
|
|
(some pax ~)
|
|
merge
|
|
::
|
|
++ merge
|
|
^+ .
|
|
|- ^+ +.$
|
|
?+ gem.dat ~| [%merge-weird-gem gem.dat] !!
|
|
?(%mate %meld)
|
|
=- %_(+.$ tag [- tag])
|
|
:* hen %pass
|
|
[%merge (scot %p p.bob) q.bob (scot %p p.ali) q.ali %merge ~]
|
|
%f %exec p.bob [p.bob q.bob cas.dat] ~ %tabl
|
|
^- (list (pair silk silk))
|
|
%+ turn (~(tap by (~(int by can.dal.dat) can.dob.dat)))
|
|
|= [pax=path *]
|
|
^- (pair silk silk)
|
|
=+ cal=(~(got by can.dal.dat) pax)
|
|
=+ cob=(~(got by can.dob.dat) pax)
|
|
=+ ^= for
|
|
=+ (slag (dec (lent pax)) pax)
|
|
?~(- %$ i.-)
|
|
:- [%done ~ %path !>(pax)]
|
|
[%join for [%done ~ cal] [%done ~ cob]]
|
|
==
|
|
==
|
|
::
|
|
++ merged
|
|
|= res=(each gage tang)
|
|
?: ?=(%| -.res)
|
|
(error:he %merge-bad-made leaf/"merging failed" p.res)
|
|
=+ cay=p.res
|
|
?@ p.cay
|
|
(error:he %merge-bad-marc >p.cay< ~)
|
|
=| bof=(map path (unit cage))
|
|
=>
|
|
|- ^+ +
|
|
?~ p.p.cay
|
|
+.$(bof ~)
|
|
=+ tal=%_($ cay [[%tabl t.p.p.cay] (slot 3 q.cay)])
|
|
?: ?=(%| -.gon.dat.tal)
|
|
tal
|
|
?. ?=(%path p.i.p.p.cay)
|
|
+.$(+>.$ (error:he %merge-strange-marc-a >p.i.p.p.cay< ~))
|
|
?. ?=(@ q.i.p.p.cay)
|
|
+.$(+>.$ (error:he %merge-strange-marc-b >q.i.p.p.cay< ~))
|
|
=+ coy=(slot 2 q.cay)
|
|
?@ q.coy
|
|
+.$(+>.$ (error:he %merge-strange-coy ~))
|
|
%_ +.$
|
|
bof
|
|
%+ ~(put by bof:tal)
|
|
((hard path) -.q.coy)
|
|
?: ?=(%null q.i.p.p.cay)
|
|
~
|
|
`[q.i.p.p.cay (slot 3 coy)]
|
|
==
|
|
?: ?=(%| -.gon.dat)
|
|
+>.$
|
|
=. bof.dat bof
|
|
build
|
|
::
|
|
++ build
|
|
^+ .
|
|
=- %_(+ tag [- tag])
|
|
:* hen %pass
|
|
[%merge (scot %p p.bob) q.bob (scot %p p.ali) q.ali %build ~]
|
|
%f %exec p.bob [p.bob q.bob cas.dat] ~ %tabl
|
|
^- (list (pair silk silk))
|
|
%+ murn (~(tap by bof.dat))
|
|
|= [pax=path cay=(unit cage)]
|
|
^- (unit (pair silk silk))
|
|
?~ cay
|
|
~
|
|
:- ~
|
|
:- [%done ~ %path !>(pax)]
|
|
=+ (~(get by q.bas.dat) pax)
|
|
?~ -
|
|
~| %mate-strange-diff-no-base
|
|
!!
|
|
[%pact (lobe-to-silk pax u.-) [%done ~ u.cay]]
|
|
==
|
|
|
|
::
|
|
++ built
|
|
|= res=(each gage tang)
|
|
^+ +>
|
|
?: ?=(%| -.res)
|
|
(error:he %build-bad-made leaf/"delta building failed" p.res)
|
|
=+ cay=p.res
|
|
?@ p.cay
|
|
(error:he %build-bad-marc >p.cay< ~)
|
|
=| bop=(map path cage)
|
|
=>
|
|
|- ^+ +
|
|
?~ p.p.cay
|
|
+.$(bop ~)
|
|
=+ tal=%_($ cay [[%tabl t.p.p.cay] (slot 3 q.cay)])
|
|
?: ?=(%| -.gon.dat.tal)
|
|
tal
|
|
?. ?=(%path p.i.p.p.cay)
|
|
+.$(+>.$ (error:he %build-strange-marc-a >p.i.p.p.cay< ~))
|
|
?. ?=(@ q.i.p.p.cay)
|
|
+.$(+>.$ (error:he %build-strange-marc-b >q.i.p.p.cay< ~))
|
|
=+ coy=(slot 2 q.cay)
|
|
?@ q.coy
|
|
+.$(+>.$ (error:he %build-strange-coy ~))
|
|
%_ +.$
|
|
bop
|
|
%+ ~(put by bop:tal)
|
|
((hard path) -.q.coy)
|
|
[q.i.p.p.cay (slot 3 coy)]
|
|
==
|
|
?: ?=(%| -.gon.dat)
|
|
+>.$
|
|
=. bop.dat bop
|
|
=+ ^- con=(map path ,*) :: 2-change conflict
|
|
%- mo
|
|
%+ skim (~(tap by bof.dat))
|
|
|=([pax=path cay=(unit cage)] ?=(~ cay))
|
|
=+ ^- cas=(map path lobe) :: conflict base
|
|
%- ~(urn by con)
|
|
|= [pax=path *]
|
|
(~(got by q.bas.dat) pax)
|
|
=. con :: add/del conflict
|
|
%- ~(uni by con)
|
|
%- mo ^- (list ,[path *])
|
|
%+ skim (~(tap by old.dal.dat))
|
|
|= [pax=path ~]
|
|
?: (~(has by new.dob.dat) pax)
|
|
~| %strange-add-and-del
|
|
!!
|
|
(~(has by can.dob.dat) pax)
|
|
=. con :: add/del conflict
|
|
%- ~(uni by con)
|
|
%- mo ^- (list ,[path *])
|
|
%+ skim (~(tap by old.dob.dat))
|
|
|= [pax=path ~]
|
|
?: (~(has by new.dal.dat) pax)
|
|
~| %strange-del-and-add
|
|
!!
|
|
(~(has by can.dal.dat) pax)
|
|
=. con :: add/add conflict
|
|
%- ~(uni by con)
|
|
%- mo ^- (list ,[path *])
|
|
%+ skip (~(tap by (~(int by new.dal.dat) new.dob.dat)))
|
|
|= [pax=path *]
|
|
=((~(got by new.dal.dat) pax) (~(got by new.dob.dat) pax))
|
|
?: &(?=(%mate gem.dat) ?=(^ con))
|
|
=+ (turn (~(tap by `(map path ,*)`con)) |=([path *] >[+<-]<))
|
|
(error:he %mate-conflict -)
|
|
=+ ^- old=(map path lobe) :: oldies but goodies
|
|
%+ roll (~(tap by (~(uni by old.dal.dat) old.dob.dat)))
|
|
=< .(old q.bas.dat)
|
|
|= [[pax=path ~] old=(map path lobe)]
|
|
(~(del by old) pax)
|
|
=+ ^- can=(map path cage) :: content changes
|
|
%- mo
|
|
^- (list (pair path cage))
|
|
%+ murn (~(tap by bof.dat))
|
|
|= [pax=path cay=(unit cage)]
|
|
^- (unit (pair path cage))
|
|
?~ cay
|
|
~
|
|
`[pax u.cay]
|
|
=^ hat lat.ran :: new content
|
|
^- [(map path lobe) (map lobe blob)]
|
|
%+ roll (~(tap by can))
|
|
=< .(lat lat.ran)
|
|
|= [[pax=path cay=cage] hat=(map path lobe) lat=(map lobe blob)]
|
|
=+ ^= bol
|
|
=+ (~(get by q.bas.dat) pax)
|
|
?~ -
|
|
~| %mate-strange-diff-no-base
|
|
!!
|
|
%^ make-delta
|
|
(page-to-lobe [p q.q]:(~(got by bop.dat) pax))
|
|
[(lobe-to-mark u.-) u.-]
|
|
[p q.q]:cay
|
|
[(~(put by hat) pax p.bol) (~(put by lat) p.bol bol)]
|
|
=. hat :: all the content
|
|
%- ~(uni by old)
|
|
%- ~(uni by new.dal.dat)
|
|
%- ~(uni by new.dob.dat)
|
|
%- ~(uni by cal.dal.dat)
|
|
%- ~(uni by cal.dob.dat)
|
|
%- ~(uni by hat)
|
|
cas
|
|
=+ ^- del=(map path ,?)
|
|
(~(run by (~(uni by old.dal.dat) old.dob.dat)) |=(~ %|))
|
|
=. gon.dat [%& (sa (turn (~(tap by con)) |=([path *] +<-)))]
|
|
=. new.dat
|
|
(make-yaki [r.ali.dat r.bob.dat ~] hat now)
|
|
=. hut.ran (~(put by hut.ran) r.new.dat new.dat)
|
|
=. erg.dat %- ~(uni by del)
|
|
`(map path ,?)`(~(run by hat) |=(lobe %&))
|
|
checkout
|
|
::
|
|
++ checkout
|
|
^+ .
|
|
=- %_(+ tag [- tag])
|
|
=+ val=?:(?=(%init gem.dat) ali bob)
|
|
:* hen %pass
|
|
[%merge (scot %p p.bob) q.bob (scot %p p.ali) q.ali %checkout ~]
|
|
%f %exec p.bob [p.val q.val cas.dat] ~ %tabl
|
|
^- (list (pair silk silk))
|
|
%+ murn (~(tap by q.new.dat))
|
|
|= [pax=path lob=lobe]
|
|
^- (unit (pair silk silk))
|
|
?: (~(has by bop.dat) pax)
|
|
~
|
|
`[[%done ~ %path !>(pax)] (merge-lobe-to-silk:he pax lob)]
|
|
==
|
|
::
|
|
++ checked-out
|
|
|= res=(each gage tang)
|
|
^+ +>
|
|
?: ?=(%| -.res)
|
|
(error:he %checkout-bad-made leaf/"merge checkout failed" p.res)
|
|
=+ cay=p.res
|
|
?@ p.cay
|
|
(error:he %patch-bad-marc >p.cay< ~)
|
|
=| can=(list ,[path cage])
|
|
=>
|
|
|- ^+ +
|
|
?~ p.p.cay
|
|
+.$(can ~)
|
|
=+ tal=%_($ cay [[%tabl t.p.p.cay] (slot 3 q.cay)])
|
|
?: ?=(%| -.gon.dat.tal)
|
|
tal
|
|
?. ?=(%path p.i.p.p.cay)
|
|
+.$(+>.$ (error:he %patch-strange-marc-a >p.i.p.p.cay< ~))
|
|
?. ?=(@ q.i.p.p.cay)
|
|
+.$(+>.$ (error:he %patch-strange-marc-b >q.i.p.p.cay< ~))
|
|
=+ coy=(slot 2 q.cay)
|
|
?@ q.coy
|
|
+.$(+>.$ (error:he %patch-strange-coy ~))
|
|
%_ +.$
|
|
can
|
|
:_ can:tal
|
|
:- ((hard path) -.q.coy)
|
|
[q.i.p.p.cay (slot 3 coy)]
|
|
==
|
|
?: ?=(%| -.gon.dat)
|
|
+>.$
|
|
=. let.dom +(let.dom)
|
|
=. hit.dom (~(put by hit.dom) let.dom r.new.dat)
|
|
=. ank.dat (checkout-ankh:ze (~(uni by bop.dat) (mo can)))
|
|
=. ank.dom ank.dat
|
|
?~ hez
|
|
(done:he ~)
|
|
?. syn
|
|
(done:he ~)
|
|
ergo
|
|
::
|
|
++ ergo
|
|
^+ .
|
|
=- %_(+ tag [- tag])
|
|
=+ zez=ze(ank.dom ank.dat)
|
|
=+ val=?:(?=(%init gem.dat) ali bob)
|
|
:* hen %pass
|
|
[%merge (scot %p p.bob) q.bob (scot %p p.ali) q.ali %ergo ~]
|
|
%f %exec p.bob [p.val q.val cas.dat] ~ %tabl
|
|
^- (list (pair silk silk))
|
|
%+ turn (~(tap by erg.dat))
|
|
|= [a=path b=?]
|
|
^- (pair silk silk)
|
|
:- [%done ~ %path !>(a)]
|
|
?. b
|
|
[%done ~ %null !>(~)]
|
|
:+ %cast %mime
|
|
(lobe-to-silk:zez a (~(got by q.new.dat) a))
|
|
==
|
|
::
|
|
++ ergoed
|
|
|= res=(each gage tang)
|
|
^+ +>
|
|
?: ?=(%| -.res)
|
|
(error:he %ergo-bad-made leaf/"merge ergo failed" p.res)
|
|
=+ cay=p.res
|
|
?@ p.cay ~| %patch-bad-marc !!
|
|
=| can=(list ,[path (unit mime)])
|
|
=>
|
|
|- ^+ +
|
|
?~ p.p.cay
|
|
+.$(can ~)
|
|
=+ tal=%_($ cay [[%tabl t.p.p.cay] (slot 3 q.cay)])
|
|
?: ?=(%| -.gon.dat.tal)
|
|
tal
|
|
?. ?=(%path p.i.p.p.cay)
|
|
+.$(+>.$ (error:he %patch-strange-marc-a >p.i.p.p.cay< ~))
|
|
?. ?=(@ q.i.p.p.cay)
|
|
+.$(+>.$ (error:he %patch-strange-marc-b >p.i.p.p.cay< ~))
|
|
=+ coy=(slot 2 q.cay)
|
|
?@ q.coy
|
|
+.$(+>.$ (error:he %patch-strange-coy ~))
|
|
%_ +.$
|
|
can
|
|
:_ can:tal
|
|
:- ((hard path) -.q.coy)
|
|
?. ?=(%mime q.i.p.p.cay)
|
|
~
|
|
`((hard mime) q:(slot 3 coy))
|
|
==
|
|
?~ hez
|
|
(error:he %ergo-no-hez ~)
|
|
?. syn
|
|
(error:he %ergo-sync-off ~)
|
|
?: ?=(%| -.gon.dat)
|
|
+>.$
|
|
%= +>.$
|
|
don %|
|
|
reg [[u.hez %ergo who syd let.dom can] reg]
|
|
==
|
|
::
|
|
++ he
|
|
|%
|
|
++ done
|
|
|= con=(set path)
|
|
^+ ..he
|
|
..he(don |, gon.dat [%& con])
|
|
++ error
|
|
|= [err=term tan=(list tank)]
|
|
^+ ..he
|
|
..he(don |, gon.dat [%| err >ali< >bob< tan])
|
|
::
|
|
++ find-merge-points
|
|
|= [p=yaki q=yaki] :: maybe need jet
|
|
^- (set yaki)
|
|
%- reduce-merge-points
|
|
=+ r=(reachable-takos r.p)
|
|
|- ^- (set yaki)
|
|
?: (~(has in r) r.q) (~(put in *(set yaki)) q)
|
|
%+ roll p.q
|
|
|= [t=tako s=(set yaki)]
|
|
?: (~(has in r) t)
|
|
(~(put in s) (tako-to-yaki t)) :: found
|
|
(~(uni in s) ^$(q (tako-to-yaki t))) :: traverse
|
|
::
|
|
++ merge-lobe-to-silk
|
|
|= [pax=path lob=lobe]
|
|
^- silk
|
|
=+ hat=q.ali.dat
|
|
=+ hot=q.bob.dat
|
|
=+ ^= lal
|
|
%+ biff alh
|
|
|= hal=ankh
|
|
(~(get by hat) pax)
|
|
=+ lol=(~(get by hot) pax)
|
|
|- ^- silk
|
|
?: =([~ lob] lol)
|
|
=+ (need (need (read-x let.dom pax)))
|
|
?> ?=(%& -<)
|
|
[%done ~ p.-]
|
|
?: =([~ lob] lal)
|
|
:+ %done ~
|
|
(need (bind q.ank:(descend-path:(zu (need alh)) pax) tail))
|
|
=+ bol=(~(got by lat.ran) lob)
|
|
?- -.bol
|
|
%direct [%volt ~ q.bol]
|
|
%indirect [%volt ~ q.bol]
|
|
%delta [%pact $(lob q.q.bol) [%volt ~ r.bol]]
|
|
==
|
|
::
|
|
++ reduce-merge-points
|
|
|= 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))]
|
|
(~(put by qar) r.yak (reachable-takos r.yak))
|
|
|-
|
|
^- (set yaki)
|
|
?~ unk gud
|
|
=+ bun=(~(del in `(set yaki)`unk) n.unk)
|
|
?: %+ levy (~(tap by (~(uni in gud) bun)) ~)
|
|
|= yak=yaki
|
|
!(~(has in (~(got by zar) r.yak)) r.n.unk)
|
|
$(gud (~(put in gud) n.unk), unk bun)
|
|
$(unk bun)
|
|
--
|
|
--
|
|
--
|
|
--
|
|
::
|
|
++ do
|
|
|= [now=@da hen=duct [who=ship him=ship] syd=@tas ruf=raft]
|
|
=+ ^= rug ^- rung
|
|
=+ rug=(~(get by hoy.ruf) him)
|
|
?^(rug u.rug *rung)
|
|
=+ ^= red ^- rede
|
|
=+ yit=(~(get by rus.rug) syd)
|
|
?^(yit u.yit `rede`[~2000.1.1 ~ [~ *rind] *dome ~ ~ %|])
|
|
((de now hen ~ ~) [who him] syd red ran.ruf)
|
|
::
|
|
++ posh
|
|
|= [him=ship syd=desk red=rede ruf=raft]
|
|
^- raft
|
|
=+ ^= rug ^- rung
|
|
=+ rug=(~(get by hoy.ruf) him)
|
|
?^(rug u.rug *rung)
|
|
ruf(hoy (~(put by hoy.ruf) him rug(rus (~(put by rus.rug) syd red))))
|
|
::
|
|
++ un :: domestic ship
|
|
|= [who=@p now=@da hen=duct ruf=raft]
|
|
=+ ^= yar ^- room
|
|
=+ yar=(~(get by fat.ruf) who)
|
|
?~(yar *room u.yar)
|
|
|%
|
|
++ abet ruf(fat (~(put by fat.ruf) who yar))
|
|
++ pish
|
|
|= [syd=@ta red=rede run=rang]
|
|
%_ +>
|
|
ran.ruf run
|
|
dos.yar
|
|
(~(put by dos.yar) syd [qyx.red dom.red dok.red mer.red syn.red])
|
|
==
|
|
::
|
|
++ wake
|
|
=+ saz=(turn (~(tap by dos.yar) ~) |=([a=@tas b=*] a))
|
|
=| moz=(list move)
|
|
=< [moz ..wake]
|
|
|- ^+ +
|
|
?~ saz +
|
|
=+ sog=abet:wake:(di i.saz)
|
|
$(saz t.saz, moz (weld moz -.sog), ..wake (pish i.saz +.sog ran.ruf))
|
|
::
|
|
++ di
|
|
|= syd=@ta
|
|
=+ ^= saq ^- dojo
|
|
=+ saq=(~(get by dos.yar) syd)
|
|
?~(saq *dojo u.saq)
|
|
%^ (de now hen hun.yar hez.yar)
|
|
[who who]
|
|
syd
|
|
[[now qyx.saq ~ dom.saq dok.saq mer.saq syn.saq] ran.ruf]
|
|
--
|
|
--
|
|
::::::::::::::::::::::::::::::::::::::::::::::::::::::::
|
|
:: section 4cA, filesystem vane ::
|
|
:: ::
|
|
=| :: instrument state
|
|
$: %0 :: vane version
|
|
ruf=raft :: revision tree
|
|
== ::
|
|
|= [now=@da eny=@ ski=sled] :: activate
|
|
^? :: opaque core
|
|
|% ::
|
|
++ call :: handle request
|
|
|= $: hen=duct
|
|
hic=(hypo (hobo kiss))
|
|
==
|
|
=> %= . :: XX temporary
|
|
q.hic
|
|
^- kiss
|
|
?: ?=(%soft -.q.hic)
|
|
=+
|
|
~|([%bad-soft (,@t -.p.q.hic)] ((soft kiss) p.q.hic))
|
|
?~ -
|
|
~& [%bad-softing (,@t -.p.q.hic)] !!
|
|
u.-
|
|
?: (~(nest ut -:!>(*kiss)) | p.hic) q.hic
|
|
~& [%clay-call-flub (,@tas `*`-.q.hic)]
|
|
((hard kiss) q.hic)
|
|
==
|
|
^- [p=(list move) q=_..^$]
|
|
?- -.q.hic
|
|
%font
|
|
?: (~(has by sor.ruf) +.q.hic) `..^$
|
|
:_ ..^$(sor.ruf (~(put by sor.ruf) +.q.hic [0 hen]))
|
|
:~ ^- move
|
|
:* hen %pass
|
|
/auto/(scot %p p.q.hic)/[q.q.hic]/(scot %p r.q.hic)/[s.q.hic]
|
|
%c %warp [p.q.hic r.q.hic] s.q.hic ~ %sing
|
|
%w [%da now] /
|
|
==
|
|
==
|
|
::
|
|
%init
|
|
:_ ..^$(fat.ruf (~(put by fat.ruf) p.q.hic [hen ~ ~]))
|
|
=+ bos=(sein p.q.hic)
|
|
~& [%bos bos p.q.hic]
|
|
?: =(bos p.q.hic) ~
|
|
[hen %pass / %c %font p.q.hic %base bos %kids]~
|
|
::
|
|
%info
|
|
?: =(%$ q.q.hic)
|
|
[~ ..^$]
|
|
=^ mos ruf
|
|
=+ une=(un p.q.hic now hen ruf)
|
|
=+ ^= zat
|
|
(exec:(di:une q.q.hic) now r.q.hic)
|
|
=+ zot=abet.zat
|
|
:- -.zot
|
|
=. une (pish:une q.q.hic +.zot ran.zat)
|
|
abet:une
|
|
:: ~& :+ %infoed
|
|
:: len=(lent mos)
|
|
:: %+ turn mos
|
|
:: |= move
|
|
:: ^- [duct (unit path) term term]
|
|
:: :- p
|
|
:: ^- [(unit path) term term]
|
|
:: ?+ -.q [~ *term *term]
|
|
:: %pass
|
|
:: ^- [(unit path) term term]
|
|
:: [`p.q [- +<]:q.q]
|
|
:: %give
|
|
:: ^- [(unit path) term term]
|
|
:: [~ %give -.p.q]
|
|
:: ==
|
|
[mos ..^$]
|
|
::
|
|
%into
|
|
=+ yar=(~(got by fat.ruf) p.q.hic)
|
|
:_ ..^$(fat.ruf (~(put by fat.ruf) p.q.hic yar(hez [~ hen])))
|
|
^- (list move)
|
|
?: =(%$ q.q.hic)
|
|
~
|
|
=+ dos=(~(get by dos.yar) q.q.hic)
|
|
?: &(?=(^ dos) !=(0 +>-.+<.+.dos)) :: ank.s.u.dos
|
|
?: =(ank.dom.u.dos q.q.hic)
|
|
~
|
|
:_ ~
|
|
:* hen %pass / %c %info p.q.hic q.q.hic %&
|
|
(khan-to-soba `ank.dom.u.dos `r.q.hic)
|
|
==
|
|
=+ cos=(khan-to-soba ~ `r.q.hic)
|
|
=+ ^- [one=(list ,[path miso]) two=(list ,[path miso])]
|
|
%+ skid q.cos
|
|
|= [a=path b=miso]
|
|
?& ?=(%ins -.b)
|
|
?=(%mime p.p.b)
|
|
=+ (slag (dec (lent a)) a)
|
|
?| =([%hook ~] -)
|
|
=([%hoon ~] -)
|
|
== ==
|
|
:~ [hen %pass /one %c %info p.q.hic q.q.hic %& p.cos one]
|
|
[hen %pass /two %c %info p.q.hic q.q.hic %& p.cos two]
|
|
==
|
|
::
|
|
%lynx
|
|
?: =(%$ q.q.hic)
|
|
[~ ..^$]
|
|
=^ mos ruf
|
|
=+ une=(un p.q.hic now hen ruf)
|
|
=+ ^= zat
|
|
(lynx:(di:wake:une q.q.hic) r.q.hic)
|
|
=+ zot=abet.zat
|
|
:- -.zot
|
|
=. une (pish:une q.q.hic +.zot ran.zat)
|
|
abet:une
|
|
[mos ..^$]
|
|
::
|
|
%merg :: direct state up
|
|
?: =(%$ q.q.hic)
|
|
[~ ..^$]
|
|
=^ mos ruf
|
|
=+ une=(un p.q.hic now hen ruf)
|
|
=+ ^= zat
|
|
abet:(start:(me:ze:(di:wake:une q.q.hic) [r.q.hic s.q.hic] ~) t.q.hic)
|
|
=+ zot=abet.zat
|
|
:- -.zot
|
|
=. une (pish:une q.q.hic +.zot ran.zat)
|
|
abet:une
|
|
[mos ..^$]
|
|
::
|
|
%plug
|
|
?. (~(has by sor.ruf) +.q.hic) `..^$
|
|
:_ ..^$(sor.ruf (~(del by sor.ruf) +.q.hic))
|
|
=+ hyn=hen:(~(got by sor.ruf) +.q.hic)
|
|
:~ :* hyn %pass
|
|
/auto/(scot %p p.q.hic)/[q.q.hic]/(scot %p r.q.hic)/[s.q.hic]
|
|
%c %warp [p.q.hic r.q.hic] s.q.hic ~
|
|
==
|
|
==
|
|
::
|
|
%warp
|
|
=^ mos ruf
|
|
?: =(p.p.q.hic q.p.q.hic)
|
|
=+ une=(un p.p.q.hic now hen ruf)
|
|
=+ wex=(di:une p.q.q.hic)
|
|
=+ ^= wao
|
|
?~ q.q.q.hic
|
|
ease:wex
|
|
(eave:wex u.q.q.q.hic)
|
|
=+ ^= woo
|
|
abet:wao
|
|
[-.woo abet:(pish:une p.q.q.hic +.woo ran.wao)]
|
|
=+ wex=(do now hen p.q.hic p.q.q.hic ruf)
|
|
=+ ^= woo
|
|
?~ q.q.q.hic
|
|
abet:ease:wex
|
|
abet:(eave:wex u.q.q.q.hic)
|
|
[-.woo (posh q.p.q.hic p.q.q.hic +.woo ruf)]
|
|
[mos ..^$]
|
|
::
|
|
%wart
|
|
?> ?=(%re q.q.hic)
|
|
=+ ryf=((hard riff) s.q.hic)
|
|
:_ ..^$
|
|
:~ :- hen
|
|
:^ %pass [(scot %p p.p.q.hic) (scot %p q.p.q.hic) r.q.hic]
|
|
%c
|
|
[%warp [p.p.q.hic p.p.q.hic] ryf]
|
|
==
|
|
::
|
|
%wegh
|
|
:_ ..^$ :_ ~
|
|
:^ hen %give %mass
|
|
:- %|
|
|
:~ ruf/`ruf
|
|
:: cor/`..^$
|
|
==
|
|
==
|
|
::
|
|
++ doze
|
|
|= [now=@da hen=duct]
|
|
^- (unit ,@da)
|
|
~
|
|
::
|
|
++ load
|
|
|= old=[%0 ruf=raft]
|
|
^+ ..^$
|
|
..^$(ruf ruf.old)
|
|
::
|
|
++ scry :: inspect
|
|
|= [fur=(unit (set monk)) ren=@tas his=ship syd=desk lot=coin tyl=path]
|
|
^- (unit (unit cage))
|
|
:: ~& scry/[ren `path`[(scot %p his) syd ~(rent co lot) tyl]]
|
|
:: =- ~& %scry-done -
|
|
=+ got=(~(has by fat.ruf) his)
|
|
=+ luk=?.(?=(%$ -.lot) ~ ((soft case) p.lot))
|
|
?~ luk [~ ~]
|
|
?: =(%$ ren)
|
|
[~ ~]
|
|
=+ run=((soft care) ren)
|
|
?~ run [~ ~]
|
|
=+ %. [u.run u.luk tyl]
|
|
=< aver
|
|
?: got
|
|
(di:(un his now ~ ruf) syd)
|
|
(do now ~ [his his] syd ruf)
|
|
?~ - -
|
|
?~ u.- -
|
|
?: ?=(%& -.u.u.-) ``p.u.u.-
|
|
~
|
|
::
|
|
++ stay [%0 ruf]
|
|
++ take :: accept response
|
|
|= [tea=wire hen=duct hin=(hypo sign)]
|
|
^- [p=(list move) q=_..^$]
|
|
?: ?=([%merge @ @ @ @ @ ~] tea)
|
|
?> ?=(?(%writ %made) +<.q.hin)
|
|
=+ our=(slav %p i.t.tea)
|
|
=* syd i.t.t.tea
|
|
=+ her=(slav %p i.t.t.t.tea)
|
|
=* sud i.t.t.t.t.tea
|
|
=* sat i.t.t.t.t.t.tea
|
|
=+ une=(un our now hen ruf)
|
|
=+ wak=wake:une
|
|
=+ wex=(di:wak syd)
|
|
=+ dat=?-(+<.q.hin %writ [%& p.q.hin], %made [%| q.q.hin])
|
|
=+ ^- kan=(unit ankh)
|
|
%+ biff (~(get by fat.ruf) her)
|
|
|= room
|
|
%+ bind (~(get by dos) sud)
|
|
|= dojo
|
|
ank.dom
|
|
=+ wao=abet:(route:(me:ze:wex [her sud] kan) sat dat)
|
|
=+ woo=abet:wao
|
|
[(weld -.wak -.woo) ..^$(ruf abet:(pish:une syd +.woo ran.wao))]
|
|
?: ?=([%auto @ @ @ @ ~] tea)
|
|
=+ our=(slav %p i.t.tea)
|
|
=* syd i.t.t.tea
|
|
=+ her=(slav %p i.t.t.t.tea)
|
|
=* sud i.t.t.t.t.tea
|
|
?+ +<.q.hin ~|(%weird-auto !!)
|
|
%mere
|
|
=+ nex=+(let:(~(got by sor.ruf) our syd her sud))
|
|
=. sor.ruf (~(put by sor.ruf) [our syd her sud] [nex hen])
|
|
=+ `move`[hen %pass tea %c %warp [our her] sud ~ %sing %y [%ud nex] /]
|
|
?: ?=(%& -.p.+.q.hin)
|
|
~& ['merge succeeded' p.p.+.q.hin]
|
|
[[- ~] ..^$]
|
|
~& :^ "merge failed"
|
|
"please manually merge the desks with"
|
|
":helm+merge %{(trip syd)} {(scow %p her)} %{(trip sud)}"
|
|
:- p.p.p.+.q.hin
|
|
(turn q.p.p.+.q.hin |=(tank ~(ram re +<)))
|
|
[[- ~] ..^$]
|
|
::
|
|
%writ
|
|
?~ p.q.hin
|
|
~& "bad %writ response on autosync"
|
|
[~ ..^$]
|
|
=. sor.ruf
|
|
?. ?=(%w p.p.u.p.q.hin)
|
|
sor.ruf
|
|
%+ ~(put by sor.ruf)
|
|
[our syd her sud]
|
|
[((hard ,@ud) q.q.r.u.p.q.hin) hen]
|
|
=+ nex=let:(~(got by sor.ruf) our syd her sud)
|
|
=+ (~(get by fat.ruf) our)
|
|
?~ -
|
|
~& [%autsync-no-local-ship our]
|
|
[~ ..^$]
|
|
=+ (~(get by dos.u.-) syd)
|
|
=+ ^= sar
|
|
?~ -
|
|
%init
|
|
?: =(0 let.dom.u.-)
|
|
%init
|
|
%mate
|
|
[[hen %pass tea %c %merg our syd her sud sar]~ ..^$]
|
|
:: %c %merg [p q r s %init]:q.hic
|
|
==
|
|
?: ?=([%blab care @ @ *] tea)
|
|
?> ?=(%made +<.q.hin)
|
|
?: ?=(%| -.q.q.hin)
|
|
~| %blab-fail
|
|
~> %mean.|.(p.q.q.hin) :: interpolate ford fail into stack trace
|
|
!!
|
|
?^ p.p.q.q.hin
|
|
~|(%bad-marc !!)
|
|
:_ ..^$ :_ ~
|
|
:* hen %give %writ ~
|
|
`[care case @tas]`[i.t.tea ((hard case) +>:(slay i.t.t.tea)) i.t.t.t.tea]
|
|
`path`t.t.t.t.tea `cage`p.q.q.hin
|
|
==
|
|
?- -.+.q.hin
|
|
%crud
|
|
[[[hen %slip %d %flog +.q.hin] ~] ..^$]
|
|
::
|
|
%made
|
|
?~ tea !!
|
|
?+ -.tea !!
|
|
%inserting
|
|
?> ?=([@ @ @ ~] t.tea)
|
|
=+ who=(slav %p i.t.tea)
|
|
=+ syd=(slav %tas i.t.t.tea)
|
|
=+ wen=(slav %da i.t.t.t.tea)
|
|
=^ mos ruf
|
|
=+ une=(un who now hen ruf)
|
|
=+ ^= zat
|
|
(take-inserting:(di:une syd) wen q.q.hin)
|
|
=+ zot=abet.zat
|
|
[-.zot abet:(pish:une syd +.zot ran.zat)]
|
|
[mos ..^$]
|
|
::
|
|
%diffing
|
|
?> ?=([@ @ @ ~] t.tea)
|
|
=+ who=(slav %p i.t.tea)
|
|
=+ syd=(slav %tas i.t.t.tea)
|
|
=+ wen=(slav %da i.t.t.t.tea)
|
|
=^ mos ruf
|
|
=+ une=(un who now hen ruf)
|
|
=+ ^= zat
|
|
(take-diffing:(di:une syd) wen q.q.hin)
|
|
=+ zot=abet.zat
|
|
[-.zot abet:(pish:une syd +.zot ran.zat)]
|
|
[mos ..^$]
|
|
::
|
|
%castifying
|
|
?> ?=([@ @ @ ~] t.tea)
|
|
=+ who=(slav %p i.t.tea)
|
|
=+ syd=(slav %tas i.t.t.tea)
|
|
=+ wen=(slav %da i.t.t.t.tea)
|
|
=^ mos ruf
|
|
=+ une=(un who now hen ruf)
|
|
=+ ^= zat
|
|
(take-castify:(di:une syd) wen q.q.hin)
|
|
=+ zot=abet.zat
|
|
[-.zot abet:(pish:une syd +.zot ran.zat)]
|
|
[mos ..^$]
|
|
::
|
|
%mutating
|
|
?> ?=([@ @ @ ~] t.tea)
|
|
=+ who=(slav %p i.t.tea)
|
|
=+ syd=(slav %tas i.t.t.tea)
|
|
=+ wen=(slav %da i.t.t.t.tea)
|
|
=^ mos ruf
|
|
=+ une=(un who now hen ruf)
|
|
=+ ^= zat
|
|
(take-mutating:(di:une syd) wen q.q.hin)
|
|
=+ zot=abet.zat
|
|
[-.zot abet:(pish:une syd +.zot ran.zat)]
|
|
[mos ..^$]
|
|
::
|
|
%patching
|
|
?> ?=([@ @ ~] t.tea)
|
|
=+ who=(slav %p i.t.tea)
|
|
=+ syd=(slav %tas i.t.t.tea)
|
|
=^ mos ruf
|
|
?: (~(has by fat.ruf) who)
|
|
=+ une=(un who now hen ruf)
|
|
=+ zat=(take-patch:(di:une syd) q.q.hin)
|
|
=+ zot=abet.zat
|
|
[-.zot abet:(pish:une syd +.zot ran.zat)]
|
|
=+ zax=(do now hen [who who] syd ruf)
|
|
=+ zat=(take-patch:zax q.q.hin)
|
|
=+ zot=abet.zat
|
|
[-.zot (posh who syd +.zot ruf)]
|
|
[mos ..^$]
|
|
::
|
|
%ergoing
|
|
?> ?=([@ @ ~] t.tea)
|
|
=+ who=(slav %p i.t.tea)
|
|
=+ syd=(slav %tas i.t.t.tea)
|
|
=^ mos ruf
|
|
=+ une=(un who now hen ruf)
|
|
=+ ^= zat
|
|
(take-ergo:(di:une syd) q.q.hin)
|
|
=+ zot=abet.zat
|
|
[-.zot abet:(pish:une syd +.zot ran.zat)]
|
|
[mos ..^$]
|
|
::
|
|
%foreign-plops
|
|
?> ?=([@ @ @ ~] t.tea)
|
|
=+ our=(slav %p i.t.tea)
|
|
=+ her=(slav %p i.t.t.tea)
|
|
=* syd i.t.t.t.tea
|
|
=+ zax=(do now hen [our her] syd ruf)
|
|
=+ zat=(take-foreign-plops:zax q.q.hin)
|
|
=^ mos ruf
|
|
=+ zot=abet.zat
|
|
[-.zot (posh her syd +.zot ruf)]
|
|
[mos ..^$(ran.ruf ran.zat)]
|
|
==
|
|
::
|
|
%mere !!
|
|
%note [[hen %give +.q.hin]~ ..^$]
|
|
%waft
|
|
?> ?=([@ @ ~] tea)
|
|
=+ syd=(slav %tas i.tea)
|
|
=+ inx=(slav %ud i.t.tea)
|
|
=+ ^= zat
|
|
=< wake
|
|
%- take-foreign-update:(do now hen p.+.q.hin syd ruf)
|
|
[inx ((hard (unit rand)) q.+.q.hin)]
|
|
=^ mos ruf
|
|
=+ zot=abet.zat
|
|
[-.zot (posh q.p.+.q.hin syd +.zot ruf)]
|
|
[mos ..^$(ran.ruf ran.zat)] :: merge in new obj
|
|
::
|
|
%wake
|
|
=+ dal=(turn (~(tap by fat.ruf) ~) |=([a=@p b=room] a))
|
|
=| mos=(list move)
|
|
|- ^- [p=(list move) q=_..^^$]
|
|
?~ dal [mos ..^^$]
|
|
=+ une=(un i.dal now hen ruf)
|
|
=^ som une wake:une
|
|
$(dal t.dal, ruf abet:une, mos (weld som mos))
|
|
::
|
|
%writ
|
|
?> ?=([@ @ *] tea)
|
|
~| i=i.tea
|
|
~| it=i.t.tea
|
|
=+ our=(slav %p i.tea)
|
|
=+ him=(slav %p i.t.tea)
|
|
:_ ..^$
|
|
:~ :* hen %pass ~ %a
|
|
%want [our him] [%r %re %c t.t.tea]
|
|
(bind p.+.q.hin rant-to-rand)
|
|
==
|
|
==
|
|
::
|
|
%went
|
|
?: =(%good q.+.q.hin) [~ ..^$]
|
|
~& [%clay-lost p.+.q.hin tea]
|
|
[~ ..^$]
|
|
==
|
|
::
|
|
++ rant-to-rand
|
|
|= rant
|
|
^- rand
|
|
[p q [p q.q]:r]
|
|
::
|
|
:: XX perhaps fil.khan should be (unit (unit mime)) and !>
|
|
++ khan-to-soba
|
|
|= [ank=(unit ankh) kan=(unit khan)]
|
|
^- soba
|
|
:- *cart
|
|
=| pax=path
|
|
|- ^- (list ,[p=path q=miso])
|
|
?~ ank
|
|
?~ kan
|
|
~
|
|
=+ =+ (~(tap by dir.u.kan))
|
|
|-(?~(+< ~ (weld ^$(pax [p.i pax], kan `q.i) $(+< t))))
|
|
?~ fil.u.kan
|
|
-
|
|
?~ u.fil.u.kan
|
|
-
|
|
[[(flop pax) %ins u.u.fil.u.kan] -]
|
|
?~ kan
|
|
=+ =+ (~(tap by r.u.ank))
|
|
|-(?~(+< ~ (weld ^$(pax [p.i pax], ank `q.i) $(+< t))))
|
|
?~ q.u.ank
|
|
-
|
|
[[(flop pax) %del q.u.q.u.ank] -]
|
|
=+ %+ weld
|
|
=+ (~(tap by r.u.ank))
|
|
|- ^- (list ,[p=path q=miso])
|
|
?~ +< ~
|
|
%- weld :_ $(+< t)
|
|
^$(pax [p.i pax], ank `q.i, kan (~(get by dir.u.kan) p.i))
|
|
=+ (~(tap by dir.u.kan))
|
|
|- ^- (list ,[p=path q=miso])
|
|
?~ +< ~
|
|
?: (~(has by r.u.ank) p.i) $(+< t)
|
|
%- weld :_ $(+< t)
|
|
^$(pax [p.i pax], kan `q.i, ank ~)
|
|
?~ q.u.ank
|
|
?~ fil.u.kan
|
|
-
|
|
?~ u.fil.u.kan
|
|
-
|
|
[[(flop pax) %ins u.u.fil.u.kan] -]
|
|
?~ fil.u.kan
|
|
-
|
|
?~ u.fil.u.kan
|
|
[[(flop pax) %del q.u.q.u.ank] -]
|
|
[[(flop pax) %mut q.u.q.u.ank u.u.fil.u.kan] -]
|
|
--
|