:::::: :: :: %ford, new execution control !? 143 :::: |= pit=vase =, ford =, format => =~ :: structures |% += heel path :: functional ending += move [p=duct q=(wind note gift:able)] :: local move += note :: out request $-> $% $: %c :: to %clay $% [%warp p=sock q=riff:clay] :: == == :: $: %f :: to %ford $% [%exec p=@p q=(unit bilk)] :: == == :: $: %g :: to %gall $% [%deal p=sock q=cush:gall] :: == == == :: += sign :: in result $<- $% $: %c :: by %clay $% [%writ p=riot:clay] :: == == :: $: %f :: by %ford $% [%made p=@uvH q=gage] :: == == :: $: %g :: by %gall $% [%unto p=cuft:gall] :: == == == :: -- :: |% :: structures += axle :: all %ford state $: %3 :: version for update pol=(map ship baby) :: == :: += baby :: state by ship $: tad=[p=@ud q=(map @ud task)] :: tasks by number dym=(map duct @ud) :: duct to task number gaf=nozzle :: product to part jav=(map * calx) :: cache deh=deps :: dephash definitions sup=(jug @uvH duct) :: hash listeners out=(set [beam care:clay]) :: listening beams == :: += deps :: $: def=(map @uvH (set dent)) :: hash obligations bak=(jug dent @uvH) :: update to hash == :: ++ bolt :: gonadic edge |* a=mold :: product clam $~ [*cafe [%0 ~ *a]] :: $: p=cafe :: cache $= q :: $% [$0 p=(set dent) q=a] :: depends+product [$1 p=(set [van=vane ren=care:clay bem=beam tan=tang])] :: blocks [$2 p=(set dent) q=tang] :: depends+error == :: == :: :: :: ++ burg :: gonadic rule |* [a=mold b=mold] :: from and to $-([c=cafe d=a] (bolt b)) :: :: :: += cafe :: live cache $~ [~ ~ [~ ~] [~ ~]] $: p=(set calx) :: used q=(map * calx) :: cache r=deps :: depends s=nozzle :: product to part == :: :: :: += calm :: cache metadata $: dep=(set dent) :: dependencies == :: += calx :: concrete cache line $% [%hood p=calm q=(pair beam cage) r=hood] :: parse [%boil p=calm q=(trel coin beam beam) r=vase] :: execute [%load p=calm q=(pair mark beam) r=(unit vase)] :: load [%path p=calm q=beam r=(unit beam)] :: -to/ transformation [%slit p=calm q=[p=type q=type] r=type] :: slam type [%slim p=calm q=[p=type q=hoon] r=(pair type nock)] :: mint [%slap p=calm q=[p=vase q=hoon] r=vase] :: compute [%slam p=calm q=[p=vase q=vase] r=vase] :: compute == :: += nozzle :: bidirectional deps $: sub=(jug dent dent) :: subcomponents sup=(jug dent dent) :: downstream builds == += dent :: individual dep $% [%beam bem=beam ren=care:clay] [%boil bem=beam bom=beam arg=coin] [%load bem=beam mar=mark] == += task :: problem in progress $: nah=duct :: cause [bek=beak kas=silk] :: problem keg=(map (pair term beam) cage) :: block results kig=(set (trel vane care:clay beam)) :: blocks == :: += gagl (list (pair gage gage)) :: += vane ?(%a %b %c %d %e %f %g) :: -- :: |% :: caching ++ ca :: |% ++ val :: reduce calx |* [sem=@tas cax=calx] ?+ sem !! :: a typesystem hack %hood ?>(?=(%hood -.cax) r.cax) %boil ?>(?=(%boil -.cax) r.cax) %load ?>(?=(%load -.cax) r.cax) %path ?>(?=(%path -.cax) r.cax) %slap ?>(?=(%slap -.cax) r.cax) %slam ?>(?=(%slam -.cax) r.cax) %slim ?>(?=(%slim -.cax) r.cax) %slit ?>(?=(%slit -.cax) r.cax) == :: ++ get :: cache lookup |= [a=cafe b=@tas c=*] :: ^- [(unit calx) cafe] :: =+ d=(~(get by q.a) [b c]) :: calx key is [- q] ?~ d [~ a] :: [d a(p (~(put in p.a) u.d))] :: :: :: ++ put :: cache install |= [a=cafe b=calx] :: ^- cafe :: a(q (~(put by q.a) [- q]:b b)) :: calx key is [- q] -- :: ++ na :: nozzle operations |_ a=nozzle :: ++ put |= [k=dent v=dent] ^+ a [(~(put ju sub.a) k v) (~(put ju sup.a) v k)] :: ++ del |= [k=dent v=dent] ^+ a [(~(del ju sub.a) k v) (~(del ju sup.a) v k)] :: ++ add-sub |= [k=dent dez=(set dent)] ^+ a =/ liz ~(tap in dez) |- ^+ a ?~ liz a $(liz t.liz, a (put k i.liz)) :: ++ downstream-dents :> obtain all dents that depend on any of the dents in the sample. :> :> traverses the nozzle. product does not include the supplied dents :> themselves. |= des=(set dent) ^- (set dent) %- ~(rep in des) |= [den=dent dos=(set dent)] ^+ des =? dos !?=(%beam -.den) (~(put in dos) den) (~(uni in dos) ^$(des (~(get ju sup.a) den))) :: ++ upstream-dents :> obtain all dents upon which any of the dents in the sample depend. :> :> traverses the nozzle, gathering all direct and indirect dependencies. :> dents in the sample may also appear in the product. |= arg=(set dent) ^- (set dent) =/ des arg |- ^- (set dent) %- ~(rep in des) |= [den=dent dos=(set dent)] ^+ des =? dos !(~(has in arg) den) (~(put in dos) den) (~(uni in dos) ^$(des (~(get ju sub.a) den))) :: ++ beam-dents-in-dir :> find all %beam dents inside the folder {bem} with care {ren}. |= folder=[%beam bem=beam ren=care:clay] ^- (set dent) ?> =(%z ren.folder) :: only %z supported :: ~? !(~(has by sup.a) folder) :: state should have bem missing-folder+[folder ~(key by sup.a)] :: =- ~? !(~(has in -) folder) :: result must keep bem result-missing-folder+[folder from=-] - :: %- silt %+ skim ~(tap in ~(key by sup.a)) |= den=dent :: :: match the dent tag and beak exactly, and match the tops of the spurs .= folder den(s.bem (flop (scag (lent s.bem.folder) (flop s.bem.den)))) -- :: ++ pin-dephash :> compute the hash of a set of dents and store it in a deps. :> :> produces a pair of the hash and mutated deps. |= [sep=(set dent) deh=deps] ^+ [*@uvH deh] ?: =(~ sep) [0v0 deh] =+ hap=(sham sep) :+ hap (~(put by def.deh) hap sep) %- ~(gas ju bak.deh) (turn ~(tap in sep) |=(a=dent [a hap])) :: ++ de-dup-subdirs :: filter out %beam dents whose paths are contained within :: other paths in the set, to reduce the number of :: %z requests and responses. |= sep/(set [beam care:clay]) ^+ sep %- silt %+ skim ~(tap in sep) |= a=[bem=beam ren=care:clay] ^- ? ?~ s.bem.a & =/ above a(s.bem t.s.bem.a, ren %z) &(!(~(has in sep) above) $(a above)) :: ++ bo :: bolt operations |% ++ to-gage :: wrap vase |= a/(bolt vase) ^- (bolt gage) (tug a (with |=(a/vase [%& %noun a]))) :: ++ to-cage :: unwrap gage to cage |= gag/(bolt gage) ^- (bolt cage) %+ tug gag |= {a/cafe b/gage} ?- -.b $tabl (err:bo a >%bad-marc< ~) %| (err:bo a p.b) %& (new:bo a p.b) == :: ++ catch-error |= a/(bolt gage) ^- (bolt gage) :: TODO: (each * tang) ?. ?=($2 -.q.a) a [p.a [%0 p.q.a `gage`[%| q.q.a]]] :: ++ new |* {a/cafe b/*} :: bolt from data [p=`cafe`a q=[%0 p=*(set dent) q=b]] :: ++ err |= {a/cafe b/tang} :: bolt from error [p=a q=[%2 p=*(set dent) q=b]] :: ++ add-dep |* {a/dent b/(bolt)} ?: ?=($1 -.q.b) b =. p.q.b (~(put in p.q.b) a) b :: ++ under-dep :: link deps with |* {a/dent b/(bolt)} :: a as current dep ?: ?=($1 -.q.b) b :: and links a to =: p.q.b (sy a ~) :: s.p.b so a depends s.p.b (~(add-sub na s.p.b) a p.q.b) == b :: ++ with |* a/_|=(* +<) :: bolt lift (fmap) |* {cafe _,.+<.a} (new +<- (a +<+)) :: ::+| :: ++ pin |* hoc/(bolt) ^+ [*@uvH hoc] ?: ?=($1 -.q.hoc) [*@uvH hoc] =^ dep r.p.hoc (pin-dephash [p.q r.p]:hoc) [dep hoc] :: ++ with-cache :: cache a result |* sem/@tas :: calx type |* {hoc/(bolt) fun/(burg)} ?- -.q.hoc $2 hoc $1 hoc $0 =^ cux p.hoc (get:ca p.hoc sem q.q.hoc) ?^ cux [p=p.hoc q=[%0 p=dep.p.u.cux q=(val:ca sem u.cux)]] =+ nuf=(tug hoc fun) ?- -.q.nuf $2 nuf $1 nuf $0 =/ inf ?+ sem [sem `@p`(mug q.q.hoc)] $boil =+ `{arg/coin bem/beam bom/beam}`q.q.hoc [%boil `@p`(mug arg) (en-beam bem) (en-beam bom)] $load =+ `{for/mark bem/beam}`q.q.hoc [%load (en-beam bem) for] == :: ~& [%caching inf] :- p=(put:ca p.nuf `calx`[sem `calm`p.q.nuf q.q.hoc q.q.nuf]) q=q.nuf == == :: ++ cell :: :: bolt together |* {hoc/(bolt) fun/(burg)} ?- -.q.hoc $0 =+ nuf=(fun p.hoc +<+.fun) :- p=p.nuf ^= q ?- -.q.nuf $0 [%0 p=(~(uni in p.q.hoc) p.q.nuf) q=[q.q.hoc q.q.nuf]] $1 q.nuf $2 q.nuf == $1 =+ nuf=(fun p.hoc +<+.fun) :- p=p.nuf ^= q ?- -.q.nuf $0 q.hoc $1 [%1 p=(~(uni in p.q.nuf) p.q.hoc)] $2 q.nuf == $2 hoc == :: ++ admit :: error caption |* {cyt/$@(term (trap tank)) hoc/(bolt)} ?. ?=($2 -.q.hoc) hoc [p=p.hoc q=[%2 p=p.q.hoc q=[?^(cyt *cyt >`@tas`cyt<) q.q.hoc]]] :: ++ tug :: bolt along |* {hoc/(bolt) fun/(burg)} ?- -.q.hoc $1 hoc $2 hoc $0 =+ nuf=(fun p.hoc q.q.hoc) :- p=p.nuf ^= q ?- -.q.nuf $1 q.nuf $2 [%2 p=(~(uni in `_p.q.nuf`p.q.hoc) p.q.nuf) q=q.q.nuf] $0 [%0 p=(~(uni in `_p.q.nuf`p.q.hoc) p.q.nuf) q=q.q.nuf] == == :: ++ catch :: bolt fallback |* {hoc/(bolt) fun/$-(cafe (bolt))} :: TODO: {cafe tang} ?- -.q.hoc :: & use ++catch-error $1 hoc $0 hoc $2 =+ nuf=(fun p.hoc) :- p=p.nuf ^= q ?- -.q.nuf $1 q.nuf $0 [%0 p=(~(uni in `_p.q.nuf`p.q.hoc) p.q.nuf) q=q.q.nuf] $2 =. q.q.nuf (welp q.q.nuf q.q.hoc) [%2 p=(~(uni in `_p.q.nuf`p.q.hoc) p.q.nuf) q=q.q.nuf] == == :: ++ from-toon :: toon to bolt |= cof/cafe |* {ton/toon fun/gate} :: TODO use tug:bo :- p=cof ^= q ?- -.ton $2 [%2 p=*(set dent) q=p.ton] $0 [%0 p=*(set dent) q=(fun p.ton)] $1 :: ~& [%from-toon:bo-need ((list path) p.ton)] =- ?- -.faw :: TODO =; %& :- %1 ^= p %- silt %+ turn p.faw |=(a/{vane care:clay beam} [-.a +<.a +>.a *tang]) %| [%2 p=*(set dent) q=p.faw] == ^= faw |- ^- (each (list (trel vane care:clay beam)) tang) ?~ p.ton [%& ~] =+ nex=$(p.ton t.p.ton) =+ err=|=(a/tape [%| leaf+a ?:(?=(%& -.nex) ~ p.nex)]) =+ pax=(path i.p.ton) ?~ pax (err "blocking empty") =+ ren=((soft care:clay) (rsh 3 1 i.pax)) ?~ ren (err "blocking not care: {}") =+ zis=(de-beam t.pax) ?~ zis (err "blocking not beam: {}") ?: ?=($g (end 3 1 i.pax)) ?- -.nex %& [%& [%g u.ren u.zis] p.nex] %| nex == ?: ?=($c (end 3 1 i.pax)) ?- -.nex %& [%& [%c u.ren u.zis] p.nex] %| nex == (err "blocking bad vane") == :: ++ from-each :: each to bolt |= cof/cafe :: move to top section |* {tod/(each * tang) fun/gate} %+ (from-toon cof) ?- -.tod %& [%0 p=p.tod] %| [%2 p=p.tod] == fun :: ++ some-in-map |* fun/(burg knot (unit)) =+ res=|=(* (need [?+(-.q !! $0 q.q)]:*fun)) =+ marv=(map knot res) |= {cof/cafe sud/(map knot ~)} ^- (bolt marv) ?~ sud (new cof ~) %. [cof sud] ;~ tug ;~ cell |=({cof/cafe _sud} ^$(cof cof, sud l)) |=({cof/cafe _sud} ^$(cof cof, sud r)) |= {cof/cafe {dir/@ta ~} ^} %+ tug (fun cof dir) (with (lift |*(* [dir +<]))) == %- with |= {lam/marv ram/marv nod/$~(~ (unit {knot res}))} ?^(nod [u.nod lam ram] (~(uni by lam) ram)) == -- :: ++ fair :: hood parsing rule |= bem/beam ?> ?=({$ud $0} r.bem) :: XX sentinel =+ vez=(vang & (en-beam bem)) =< hood |% ++ case :: %clay revision %+ sear |= a/coin ^- (unit ^case) ?. ?=({$$ ^case} a) ~ [~ u=p.a] nuck:so :: ++ mota ;~(pfix vat mota:vez) :: atom odor ++ hath (sear plex (stag %clsg poor)):vez :: hood path ++ have (sear de-beam ;~(pfix net hath)) :: hood beam ++ hith :: static path => vez (sear plex (stag %clsg (more net hasp))) :: ++ hive :: late-bound path ;~ pfix net %+ cook |=(a/hops a) => vez ;~ plug (stag ~ gash) ;~(pose (stag ~ ;~(pfix cen porc)) (easy ~)) == == :: ++ hood %+ ifix [gay gay] ;~ plug ;~ pose (ifix [;~(plug net wut gap) gap] dem) (easy zuse) == :: ;~ pose (ifix [;~(plug net hep gap) gap] (most ;~(plug com gaw) hoof)) (easy ~) == :: ;~ pose (ifix [;~(plug net lus gap) gap] (most ;~(plug com gaw) hoof)) (easy ~) == :: (star ;~(sfix horn gap)) (most gap hoop) == :: ++ hoot ;~ plug sym %- punt ;~(pfix net ;~((glue net) case ship)) == :: ++ ship ;~(pfix sig fed:ag) ++ hoof %+ cook |=(a/^hoof a) ;~ pose (stag %| ;~(pfix tar hoot)) (stag %& hoot) == :: ++ hoop ;~ pose (stag %| ;~(pfix ;~(plug net net gap) have)) (stag %& tall:vez) == :: ++ horn :: horn parser =< apex =| tol/? :: allow tall form |% ++ apex %+ knee *^horn |. ~+ ;~ pfix net ;~ pose (stag %fssg ;~(pfix sig hoon:read)) :: /~ hoon by hand (stag %fsbc ;~(pfix buc hoon:read)) :: /$ extra arguments (stag %fsbr ;~(pfix bar alts:read)) :: /| or (options) (stag %fshx ;~(pfix hax horn:read)) :: /# insert dephash (stag %fsts ;~(pfix tis name:read)) :: /= apply face (stag %fsdt ;~(pfix dot list:read)) :: /. list (stag %fscm ;~(pfix com case:read)) :: /, switch by path (stag %fscn ;~(pfix cen horn:read)) :: /% propagate args (stag %fspm ;~(pfix pad pipe:read)) :: /& translates (stag %fscb ;~(pfix cab horn:read)) :: /_ homo map (stag %fssm ;~(pfix mic gate:read)) :: /; operate on (stag %fscl ;~(pfix col path:read)) :: /: relative to (stag %fskt ;~(pfix ket cast:read)) :: /^ cast (stag %fszp ;~(pfix zap ;~(sfix sym net))) :: /!mark/ run to mark (stag %fszy ;~(sfix sym net)) :: /mark/ render file == == :: ++ rail :: wide or tall |* {wid/rule tal/rule} ?. tol wid :: !tol -> only wide ;~(pose wid tal) :: ++ read |% ++ hoon %+ rail (ifix [lac rac] (stag %cltr (most ace wide:vez))) ;~(pfix gap tall:vez) :: ++ alts %+ rail (ifix [lit rit] (most ace horn)) ;~(sfix (star horn) gap duz) :: ++ horn %+ rail apex(tol |) ;~(pfix gap apex) :: ++ name %+ rail ;~(plug sym ;~(pfix tis horn)) ;~(pfix gap ;~(plug sym horn)) :: ++ list %+ rail fail ;~(sfix (star horn) gap duz) :: ++ case %+ rail fail =- ;~(sfix (star -) gap duz) ;~(pfix gap net ;~(plug hith horn)) :: ++ pipe %+ rail ;~(plug (plus ;~(sfix sym pad)) horn) =+ (cook |=(a/term [a ~]) sym) ;~(pfix gap ;~(plug - horn)) :: ++ gate %+ rail ;~(plug ;~(sfix wide:vez mic) horn) ;~(pfix gap ;~(plug tall:vez horn)) :: ++ path %+ rail ;~(plug ;~(sfix hive col) horn) ;~(pfix gap ;~(plug hive horn)) :: ++ cast %+ rail ;~(plug ;~(sfix wide:vez ket) horn) ;~(pfix gap ;~(plug tall:vez horn)) -- -- -- :: ++ lark :: filter arch names |= {wox/$-(knot (unit @)) arc/arch} ^- (map @ knot) %- ~(gas by *(map @ knot)) =| rac/(list (pair @ knot)) |- ^+ rac ?~ dir.arc rac =. rac $(dir.arc l.dir.arc, rac $(dir.arc r.dir.arc)) =+ gib=(wox p.n.dir.arc) ?~(gib rac [[u.gib p.n.dir.arc] rac]) :: ++ tack :: fold path to term |= a/{i/term t/(list term)} ^- term (rap 3 |-([i.a ?~(t.a ~ ['-' $(a t.a)])])) :: ++ tear :: split term =- |=(a/term `(list term)`(fall (rush a (most hep sym)) /[a])) sym=(cook crip ;~(plug low (star ;~(pose low nud)))) :: ++ za :: per event =/ dbg | =| $: $: our/ship :: computation owner hen/duct :: event floor $: now/@da :: event date eny/@ :: unique entropy ska/sley :: system namespace == :: mow/(list move) :: pending actions == :: bay/baby :: all owned state == :: |% +| ++ this . ++ abet :: resolve ^- {(list move) baby} [(flop mow) bay] :: ++ exec-cancel =< abet ^+ . =+ nym=(~(get by dym.bay) hen) ?~ nym :: XX should never ~& [%ford-mystery hen] ..abet =+ tas=(need (~(get by q.tad.bay) u.nym)) abut:~(decamp zo [u.nym tas]) :: ++ exec-start |= kub/bilk =< abet ^+ +> =+ num=p.tad.bay ?< (~(has by dym.bay) hen) =: p.tad.bay +(p.tad.bay) dym.bay (~(put by dym.bay) hen num) == ~(exec zo [num `task`[hen kub ~ ~]]) :: ++ task-take |= {num/@ud {van/vane ren/care:clay bem/beam} sih/sign} =< abet ^+ +> ?: ?=({$unto $quit *} +.sih) +>.$ =+ tus=(~(get by q.tad.bay) num) ?~ tus ~& [%ford-lost van num] +>.$ (~(take zo [num u.tus]) [van ren bem] sih) :: ::+| :: ++ wasp :: get next revision ~% %ford-w ..is ~ |= {dep/@uvH ask/?} =< abet ^+ +> :: :: ?: =(`@`0 dep) :: ~&(dep-empty+hen +>.$) +>.$ ?: =(dep 0vtest) :: upstream testing +>.$(mow ?.(ask mow :_(mow [hen %give %news dep]))) :: ?. (~(has by def.deh.bay) dep) ~&([%wasp-unknown dep] this) :: ?:(ask (wasp-start dep) (wasp-cancel dep)) :: ++ wasp-start |= dep=@uvH ^+ this ?: (~(has by sup.bay) dep) :: already requested this(sup.bay (~(put ju sup.bay) dep hen)) =. sup.bay (~(put ju sup.bay) dep hen) :: =/ des (~(got by def.deh.bay) dep) %- ~(rep in (dep-beams des)) |: $:{dep=[beam care:clay] dis=_this} (maybe-warp:dis dep) :: ++ wasp-cancel |= dep=@uvH ^+ this =. sup.bay (~(del ju sup.bay) dep hen) ?: (~(has by sup.bay) dep) :: other listeners exist this :: =/ des (~(got by def.deh.bay) dep) %- ~(rep in (dep-beams des)) |: $:{dep=[beam care:clay] dis=_this} (maybe-cancel:dis dep) :: ++ maybe-warp |= dep=[beam care:clay] ^+ this ?: (~(has in out.bay) dep) this %_ this out.bay (~(put in out.bay) dep) mow :_(mow [hen (pass-warp & dep)]) == :: ++ maybe-cancel |= dep=[beam care:clay] ^+ this ?. (~(has in out.bay) dep) this :: already cancelled ?: (dent-has-subscribers [%beam dep]) this :: if any other dep cares about this beam, stay subscribed %_ $ out.bay (~(del in out.bay) dep) mow :_(mow [hen (pass-warp | dep)]) == :: ++ dent-has-subscribers :> does the dent or any dent that depends on it have subscribers? |= den/dent ^- ? ?| (~(any in (~(get ju bak.deh.bay) den)) ~(has by sup.bay)) (~(any in (~(get ju sup.gaf.bay) den)) dent-has-subscribers) == :: ++ dep-beams ::DEPRECATED only needed for @uvH handling |= des/(set dent) ^- (set {beam care:clay}) %- de-dup-subdirs %+ roll ~(tap in des) |= {den/dent bes/(set {beam care:clay})} ^+ bes ?: ?=($beam -.den) (~(put in bes) +.den) (~(uni in bes) ^$(des (~(get ju sub.gaf.bay) den))) :: ++ pass-warp |= [ask=? bem=beam ren=care:clay] :: ~& warp+[(en-beam bem) ask] :+ %pass [(scot %p our) ren (en-beam bem)] [%c [%warp [our p.bem] q.bem ?.(ask ~ `[%next ren r.bem (flop s.bem)])]] :: ++ deps-take :: take rev update |= [ren=care:clay bem=beam sih=sign] =< abet ^+ this :: :: sample destructuring and validation ?. ?=(%writ &2.sih) ~|([%bad-dep &2.sih] !!) :: dep must be a %writ ?~ p.sih this :: ack from %clay, noop :: =+ `[ren=care:clay wen=case *]`p.u.p.sih :: destructure sih ?. =(ren ^ren) ~|([%bad-care ren ^ren] !!) :: cares should match :: :: %clay subscription no longer exists for this beam =. out.bay (~(del in out.bay) bem) :: :: rebuild and promote all affected builds, :: calculating which beams resulted in new builds :: for which we should send %news updates. =/ bek -.bem(r wen) =+ [new downstreams]=(dents-to-rebuild bem ren) =^ changed this (on-update new downstreams bek) :: |^ :: =/ changed-hashes (hashes-for-dents changed) =/ downstream-hashes (hashes-for-dents downstreams) =/ sames-hashes ~(tap in (~(dif in downstream-hashes) changed-hashes)) :: :: loop over the hashes of builds whose results haven't changed and :: update our dependencies and subscriptions accordingly. =. this |- ^+ this ?~ sames-hashes this =. this $(sames-hashes t.sames-hashes) =* hax i.sames-hashes :: :: find the deps for this hash that could have changed :: as a result of this clay change. =/ dep (~(get ju def.deh.bay) hax) =/ upd (~(int in dep) downstreams) :: :: resubscribe to clay at the new revision, since :: the subscription for the old revision closed when :: clay told us something had changed. =. this %- ~(rep in (dep-beams upd)) |: $:{dep=[bem=beam care:clay] dis=_this} (maybe-warp:dis dep(r.bem wen)) :: :: make hash depend on dents at new beak %_ this deh.bay %- ~(rep in upd) |= [den=dent deh=_deh.bay] =/ new-den ((move-to bek) den) :: =. def.deh (~(del ju def.deh) hax den) =. def.deh (~(put ju def.deh) hax new-den) :: =. bak.deh (~(del ju bak.deh) den hax) =. bak.deh (~(put ju bak.deh) new-den hax) deh == :: :: for each affected build (keyed by hash), :: send %news moves to listeners and cancel listeners =/ hashes=(list @uvH) ~(tap in changed-hashes) :: :: ~& [den=den dos=dos hashes=hashes] :: |- ^+ this ?~ hashes this =. this $(hashes t.hashes) :: iterate :: =/ listeners=(set duct) (~(get ju sup.bay) i.hashes) =. sup.bay (~(del by sup.bay) i.hashes) :: close subscriptions :: =. mow :: send %news moves %- weld :_ mow %+ turn ~(tap in listeners) |=(a=duct `move`[a %give %news i.hashes]) :: (wasp-cancel i.hashes) :: ++ hashes-for-dents |= des=(set dent) ^- (set @uvH) %- ~(rep in des) |= [den=dent hashes=(set @uvH)] =/ bak (~(get ju bak.deh.bay) den) (~(uni in hashes) (~(get ju bak.deh.bay) den)) -- :: :> # TODO name this chapter +| :: ++ dents-to-rebuild |= [bem=beam ren=care:clay] ^- [(set dent) (set dent)] =/ new (~(beam-dents-in-dir na gaf.bay) %beam bem ren) =/ downstreams (~(downstream-dents na gaf.bay) new) [new downstreams] :: ++ on-update :> {bem} is at the old revision, {bek} is at the new revision. |= [new=(set dent) downstreams=(set dent) bek=beak] ^+ [*(set dent) this] =/ todo ~(tap in downstreams) =^ results this (rebuild bek new todo) =+ [changed unchanged]=results ~| unchanged=unchanged [changed (promote-unchanged unchanged bek)] :: ++ rebuild :: !. :: TODO reinstate :> rebuild all builds whose dependencies have a new %clay revision. :> :> {todo} is the set of dents that need to be built at the new beak {bek}. :> produces a pair of the unchanged builds (which should be promoted) :> and the mutated ++za core. :> :> tries to avoid rebuilding by using results of builds performed at :> the previous %clay revision, if they exist and their dependencies :> haven't changed. =| unchanged/(set dent) |= {bek/beak new/(set dent) todo/(list dent)} ^+ [[new unchanged] this] ?~ todo [[new unchanged] this] :: :: don't try to rebuild the changed files themselves. ?: (~(has in new) i.todo) ~? dbg new+i.todo $(todo t.todo) :: :: if we've already built a dent at this revision, don't build it again. ?: (~(has in unchanged) i.todo) ~? dbg unchanged+i.todo $(todo t.todo) :: :: if none of our dependencies are in new, then check whether all of them :: are unchanged. if all of them are unchanged, we can avoid rebuilding. :: otherwise, rebuild. =/ dez (~(get ju sub.gaf.bay) i.todo) ?. (~(any in dez) ~(has in new)) :: :: filter out any unchanged sub-dependencies, including :: any sub-dependency beam that isn't in new, since any changed :: beams would be in new. =. dez (~(dif in dez) unchanged) =. dez (silt (skip ~(tap in dez) |=(a=dent ?=(%beam -.a)))) :: :: if we know all sub-dependencies are unchanged, :: then mark this todo as unchanged and continue. ?: =(~ dez) ~? dbg put-in-unchanged+i.todo $(unchanged (~(put in unchanged) i.todo), todo t.todo) :: :: otherwise, build all unknown sub-dependencies first and try again. ~? dbg adding-dez+~(tap in dez) $(todo (weld ~(tap in dez) todo)) :: :: some of our sub-dependencies have been invalidated, :: so perform the rebuild at the new beak. =/ taz=task [hen [bek *silk] ~ ~] ::XX real silk? =^ bil this (~(exec-dent zo *@u taz) bek i.todo) :: :: determine what to do with the rebuilt result. ?- -.q.bil $1 ~|([%stub-block p.q.bil] !!) ::TODO store state in task $2 :: errors cannot be promoted, so consider this a new build. ~? dbg rebuilt+error+i.todo $(new (~(put in new) i.todo), todo t.todo) :: $0 =/ pre (~(get by jav.bay) (to-cache-key i.todo)) :: :: if there was no previous result, or the new result is different :: from the previous result, then consider this build new. :: otherwise, consider it unchanged. ?: |(?=(~ pre) !=(r.u.pre q.q.bil)) ~? dbg rebuilt+new+i.todo $(new (~(put in new) i.todo), todo t.todo) ~? dbg rebuilt+same+i.todo $(unchanged (~(put in unchanged) i.todo), todo t.todo) == :: ++ promote-unchanged |= {unchanged/(set dent) bek/beak} ^+ this %_ this bay %- ~(rep by unchanged) :: XX iterate per beak at least =+ [a=*dent b=bay] |. ^+ b =/ cax (~(get by jav.b) (to-cache-key a)) ?~ cax b :: ::XX only for original beak in q.q.u.cax? =. a ((move-to bek) a) =. dep.p.u.cax (sy (turn ~(tap in dep.p.u.cax) (move-to bek))) :: ?< ?=($beam -.a) :: ~& promo+a =. u.cax ?- -.a $load ?>(?=($load -.u.cax) u.cax(-.q.q bek)) $boil ?>(?=($boil -.u.cax) u.cax(-.q.q bek, -.r.q bek)) == %_ b jav :: promote cache (~(put by jav.b) [- q]:u.cax u.cax) :: gaf :: promote deps (~(add-sub na gaf.b) a dep.p.u.cax) == == :: ++ to-cache-key |= den=dent ^- [term *] ?- -.den $beam ~|(beam-dep+den !!) :: ?< because beams should never be downstream $boil [%boil arg bem bom]:den $load [%load mar bem]:den == :: ++ move-to :> replace any beaks in dent with {bek}, curried. |= bek=beak |= den=dent ^+ den =? den ?=(%boil -.den) den(-.bom bek) den(-.bem bek) :: ::+| :: ++ pass |= {wir/wire noe/note} ^+ this %_(+> mow :_(mow [hen %pass wir noe])) :: ++ zo ~% %ford-z ..is ~ =| dyv/@ :: recursion level |_ {num/@ud task} ++ abet :: store a blocked task %_(..zo q.tad.bay (~(put by q.tad.bay) num +<+)) :: ++ abut :: remove a task %_ ..zo q.tad.bay (~(del by q.tad.bay) num) dym.bay (~(del by dym.bay) nah) == :: ++ decamp :: stop requests ^+ . =+ kiz=~(tap in kig) |- ^+ +> ?~ kiz +> $(kiz t.kiz, pass (pass (cancel i.kiz))) :: ++ cancel :: stop a request |= {van/vane ren/care:clay bem/beam} ^- {wire note} ?+ van ~|(stub-cancel+van !!) $c [(camp-wire +<) van [%warp [our p.bem] q.bem ~]] $g [(camp-wire +<) van [%deal [our p.bem] q.bem [%pull ~]]] == :: ++ camp-wire :: encode block |= {van/vane ren/care:clay bem/beam} ^- wire [(scot %p our) (scot %ud num) van ren (en-beam bem)] :: ++ camp :: request data |= {van/vane ren/care:clay bem/beam} ^+ +> ~& >> [%camping van ren bem] =. kig (~(put in kig) +<) %+ pass (camp-wire +<) ?+ van ~&(%camp-stub !!) $g =/ tyl/path ?. ?=($x ren) s.bem ?> ?=(^ s.bem) t.s.bem :: [%g [%deal [our p.bem] q.bem [%peer %scry ren (flop tyl)]]] :: $c [%c [%warp [our p.bem] q.bem [~ %sing ren r.bem (flop s.bem)]]] == :: ++ take :: handle ^take |= {{van/vane ren/care:clay bem/beam} sih/sign} ^+ ..zo |^ ?- &2.sih $writ (take-writ [van ren bem] p.sih) $made (take-made [van ren bem] [p q]:sih) $unto ?+ -.p.sih ~|(ford-strange-unto+[-.p.sih] !!) $diff (take-diff [van ren bem] p.p.sih) $reap ?~ p.p.sih ..zo ((slog leaf+"ford-reap-fail" u.p.p.sih) ..zo) == == :: ++ take-diff :: %g scry result |= {{van/vane ren/care:clay bem/beam} cag/cage} ^+ ..zo ?> ?=($g van) ?: |(!?=($x ren) =(-.s.bem p.cag)) =. kig (~(del in kig) +<-.$) =. pass (pass (cancel van ren bem)) =+ (cat 3 van ren) exec(keg (~(put by keg) [- bem] cag)) %+ ^pass (camp-wire van ren bem) [%f %exec our ~ bek %cast ((hard mark) -.s.bem) %$ cag] :: ++ take-made :: %g scry translated :> %gall scry response, mark-translated by %ford |= {{van/vane ren/care:clay bem/beam} dep/@uvH gag/gage} :: XX depends? ^+ ..zo ?> ?=($g van) =. kig (~(del in kig) +<-.$) :: TODO rename kig =. pass (pass (cancel van ren bem)) ?: ?=(%| -.gag) abut:(give [%made dep %| leaf+"ford-scry-made-fail" p.gag]) ?: ?=($tabl -.gag) abut:(give [%made dep %| leaf+"ford-scry-made-strange" ~]) =+ (cat 3 van ren) exec(keg (~(put by keg) [- bem] p.gag)) :: ++ take-writ |= {{van/vane ren/care:clay bem/beam} rot/riot:clay} ^+ ..zo ?> ?=($c van) =. kig (~(del in kig) +<-.$) ?~ rot =^ dep deh.bay (pin-dephash ~ deh.bay) :: TODO: dependencies? abut:(give [%made dep %| (smyt ren (en-beam bem)) ~]) =/ req (cat 3 van ren) :: e.g. %cx exec(keg (~(put by keg) [req bem] r.u.rot)) -- :: ::+| :: ::> Exec proper :: ++ tabl-run :: apply to all elems |= fun/(burg cage gage) |= {cof/cafe gag/gage} ^- (bolt gage) ?. ?=($tabl -.gag) (tug:bo (to-cage:bo (new:bo cof gag)) fun) %+ tug:bo |- ^- (bolt (list (pair gage gage))) ?~ p.gag (new:bo cof ~) %. [cof p.gag] ;~ tug:bo ;~ cell:bo |= {cof/cafe {^ q/gage} t/gagl} (catch-error:bo ^^$(cof cof, gag q)) |= {cof/cafe ^ t/gagl} ^$(cof cof, p.gag t) == (with:bo |=({v/gage t/gagl} [[p.i.p.gag v] t])) == (with:bo |=(rex/gagl [%tabl rex])) :: ++ dash :: process cache |= cof/cafe ^+ +> %_(+> jav.bay q.cof, deh.bay r.cof, gaf.bay s.cof) :: ++ diff :: diff |= {cof/cafe kas/silk kos/silk} ^- (bolt gage) %. [cof kas kos] ;~ tug:bo ;~ cell:bo |=({cof/cafe p/silk q/silk} (to-cage:bo (make cof p))) |=({cof/cafe p/silk q/silk} (to-cage:bo (make cof q))) == |= {cof/cafe cay/cage coy/cage} ^- (bolt gage) ?. =(p.cay p.coy) %+ err:bo cof :_ ~ leaf+"diff on data of different marks: {(trip p.cay)} {(trip p.coy)}" ?: =(q.q.cay q.q.coy) (new:bo cof [%& %null [%atom %n ~] ~]) :: %+ tug:bo (fang cof p.cay) |= {cof/cafe pro/vase} ?. (slab %grad p.pro) (err:bo cof leaf+"no ++grad" ~) =+ gar=(slap pro [%limb %grad]) ?@ q.gar =+ for=((sand %tas) q.gar) ?~ for (err:bo cof leaf+"bad mark ++grad" ~) %+ make cof ^- silk :+ %diff [%cast u.for [%$ cay]] [%cast u.for [%$ coy]] ?. (slab %form p.gar) (err:bo cof leaf+"no ++form:grad" ~) ?. (slab %diff p.gar) (err:bo cof leaf+"no ++diff:grad" ~) %+ tug:bo (keel cof pro [[%& 6]~ q.cay]~) |= {cof/cafe pox/vase} %+ tug:bo %^ maul cof (slap (slap pox [%limb %grad]) [%limb %diff]) q.coy |= {cof/cafe dif/vase} =+ for=((soft @tas) q:(slap gar [%limb %form])) ?~ for (err:bo cof leaf+"bad ++form:grad" ~) (new:bo cof [%& u.for dif]) == :: ::REVIEW control flow duplication ++ exec-dent :: execute depend |= [bek=beak den=dent] ^+ [*(bolt _[r:*calx]) ..zo] =; bot/(bolt _[r:*calx]) [bot ..zo:(dash p.bot)] ::TODO abet, ie block logic =/ cof/cafe [~ jav.bay deh.bay gaf.bay] ?- -.den $beam !! ::XX syve? $boil (boil cof arg.den bem.den(- bek) bom.den(- bek)) $load (load-to-mark cof mar.den bem.den(- bek)) == :: ++ exec :: execute task ^+ ..zo ?: !=(~ kig) ..zo =/ bot/(bolt gage) (make-with-concrete-revision [~ jav.bay deh.bay gaf.bay] kas) =^ dep bot (pin:bo bot) =. ..exec (dash p.bot) ?- -.q.bot $0 abut:(give [%made dep q.q.bot]) $2 abut:(give [%made dep %| q.q.bot]) $1 =< abet %+ roll ~(tap in p.q.bot) =+ [*{van/vane ren/care:clay bem/beam tan/tang} ..exec] |. ^+ ..exec (camp van ren bem) == :: ++ give |= gef/gift:able %_(+> mow :_(mow [hen %give gef])) :: ++ pass |= {wir/wire noe/note} %_(+> mow :_(mow [hen %pass wir noe])) :: ++ compile-to-hood ~/ %compile-to-hood |= {cof/cafe bem/beam} :: ~& compile-to-hood+(en-beam bem) ^- (bolt hood) %+ admit:bo |.(leaf+"ford: compile-to-hood {<[(en-beam bem)]>}") %+ tug:bo (load-file cof %*(. bem s [%hoon s.bem])) |= {cof/cafe cay/cage} %+ (with-cache:bo %hood) (new:bo cof bem(r [%ud 0]) cay) ^- (burg (pair beam cage) hood) ~% %hood-miss ..abet ~ |= {cof/cafe bem/beam cay/cage} ?. ?=(@ q.q.cay) (err:bo cof ~) =+ vex=((full (fair bem)) [[1 1] (trip q.q.cay)]) ?~ q.vex (err:bo cof [%leaf "syntax error: {} {}"] ~) (new:bo cof p.u.q.vex) :: ++ fame :: beam with - as / ~/ %fame |= {cof/cafe bem/beam} ^- (bolt beam) =; une/(bolt (unit beam)) %+ tug:bo une |= {cof/cafe bom/(unit beam)} ^- (bolt beam) ?^ bom (new:bo cof u.bom) (err:bo cof leaf+"fame: no {<(en-beam bem)>}" ~) %+ (with-cache:bo %path) (new:bo cof bem) |= {cof/cafe bem/beam} =^ pax bem [(flop s.bem) bem(s ~)] |^ opts ++ opts :: search unless done ^- (bolt (unit beam)) ?^ pax (wide(pax t.pax) (tear i.pax)) %+ tug:bo (load-to-mark cof %hoon bem) (with:bo |=(a/(unit vase) ?~(a ~ `bem))) :: ++ wide :: match segments |= sub/(list term) ^- (bolt (unit beam)) ?~ sub opts ?~ t.sub opts(s.bem [i.sub s.bem]) => .(sub `(list term)`sub) :: TMI =- (tug:bo - flat) %^ filter-at-beam cof bem |= {cof/cafe dir/knot} ^- (bolt (unit beam)) =+ sus=(tear dir) ?. =(sus (scag (lent sus) sub)) (new:bo cof ~) %_ ^$ cof cof sub (slag (lent sus) sub) s.bem [dir s.bem] == :: ++ flat :: at most one |= {cof/cafe opt/(map term beam)} ^- (bolt (unit beam)) ?~ opt (new:bo cof ~) ?: ?=({^ ~ ~} opt) (new:bo cof `q.n.opt) =+ all=(~(run by `(map term beam)`opt) en-beam) (err:bo cof leaf+"fame: fork {}" ~) -- :: ++ fang :: protocol door |= {cof/cafe for/mark} ^- (bolt vase) :: ~& fang+for (load-core cof bek /[for]/mar) :: ++ join |= {cof/cafe for/mark kas/silk kos/silk} ^- (bolt gage) %. [cof kas kos] ;~ tug:bo ;~ cell:bo |=({cof/cafe p/silk q/silk} (to-cage:bo (make cof p))) |=({cof/cafe p/silk q/silk} (to-cage:bo (make cof q))) == |= {cof/cafe cay/cage coy/cage} ^- (bolt gage) :: %+ tug:bo (fang cof for) |= {cof/cafe pro/vase} ?. (slab %grad p.pro) (err:bo cof leaf+"no ++grad" ~) =+ gar=(slap pro [%limb %grad]) ?@ q.gar =+ too=((sand %tas) q.gar) ?~ too (err:bo cof leaf+"bad mark ++grad" ~) (make cof %join u.too [%$ cay] [%$ coy]) ?. (slab %form p.gar) (err:bo cof leaf+"no ++form:grad" ~) =+ fom=((soft @tas) q:(slap gar [%limb %form])) ?~ fom (err:bo cof leaf+"bad ++form:grad" ~) ?. &(=(u.fom p.cay) =(u.fom p.coy)) %+ err:bo cof :_ :_ ~ leaf+"join on data of bad marks: {(trip p.cay)} {(trip p.coy)}" leaf+"expected mark {(trip u.fom)}" ?: =(q.q.cay q.q.coy) (new:bo cof [%& cay]) ?. (slab %join p.gar) (err:bo cof leaf+"no ++join:grad" ~) %+ tug:bo %^ maul cof (slap (slap pro [%limb %grad]) [%limb %join]) (slop q.cay q.coy) |= {cof/cafe dif/vase} ?@ q.dif (new:bo cof [%& %null dif]) (new:bo cof [%& u.fom (slot 3 dif)]) == :: ++ mash |= {cof/cafe for/mark mas/milk mos/milk} ^- (bolt gage) %. [cof r.mas r.mos] ;~ tug:bo ;~ cell:bo |=({cof/cafe p/silk q/silk} (to-cage:bo (make cof p))) |=({cof/cafe p/silk q/silk} (to-cage:bo (make cof q))) == |= {cof/cafe cay/cage coy/cage} ^- (bolt gage) %+ tug:bo (fang cof for) |= {cof/cafe pro/vase} ?. (slab %grad p.pro) (err:bo cof leaf+"no ++grad" ~) =+ gar=(slap pro [%limb %grad]) ?@ q.gar =+ too=((sand %tas) q.gar) ?~ too (err:bo cof leaf+"bad mark ++grad" ~) %+ make cof `silk`[%mash u.too [p.mas q.mas [%$ cay]] [p.mos q.mos [%$ coy]]] ?. (slab %form p.gar) (err:bo cof leaf+"no ++form:grad" ~) =+ fom=((soft @tas) q:(slap gar [%limb %form])) ?~ fom (err:bo cof leaf+"bad ++form:grad" ~) ?. &(=(u.fom p.cay) =(u.fom p.coy)) %+ err:bo cof :_ :_ ~ leaf+"mash on data of bad marks: {(trip p.cay)} {(trip p.coy)}" leaf+"expected mark {(trip u.fom)}" ?: =(q.q.cay q.q.coy) (new:bo cof %& cay) ?. (slab %mash p.gar) (new:bo cof %& %null [%atom %n ~] ~) %+ tug:bo %^ maul cof (slap (slap pro [%limb %grad]) [%limb %mash]) %+ slop :(slop [[%atom %p ~] p.mas] [[%atom %tas ~] q.mas] q.cay) :(slop [[%atom %p ~] p.mos] [[%atom %tas ~] q.mos] q.coy) (with:bo |=(dif/vase [%& u.fom dif])) == :: ++ kale :: mutate |= {cof/cafe kas/silk muy/(list (pair wing silk))} ^- (bolt gage) %+ tug:bo |- ^- (bolt (list (pair wing vase))) ?~ muy (new:bo cof ~) %+ tug:bo (to-cage:bo (make cof q.i.muy)) |= {cof/cafe cay/cage} %+ tug:bo ^$(muy t.muy) |= {cof/cafe rex/(list (pair wing vase))} (new:bo cof [[p.i.muy q.cay] rex]) |= {cof/cafe yom/(list (pair wing vase))} %+ tug:bo (make cof kas) %- tabl-run |= {cof/cafe cay/cage} %+ tug:bo (keel cof q.cay yom) (with:bo |=(vax/vase [%& p.cay vax])) :: ++ keel :: apply mutations |= {cof/cafe suh/vase yom/(list (pair wing vase))} ^- (bolt vase) %+ admit:bo =< |. ^- tank :+ %palm [" " ~ ~ ~] ~[leaf+"ford: keel" rose+[" " ~ ~]^(murn yom +)] |= {a/wing b/type *} ^- (unit tank) =+ typ=(mule |.(p:(slap suh wing+a))) ?: ?=(%| -.typ) (some (show [%c %pull] %l a)) ?: (~(nest ut p.typ) | b) ~ %^ some %palm ["." ~ ~ ~] ~[(show [%c %mute] %l a) >[p.typ b]<] %^ wrapped-slap cof %+ slop suh |- ^- vase ?~ yom [[%atom %n ~] ~] (slop q.i.yom $(yom t.yom)) ^- hoon :+ %cncb [%& 2]~ =+ axe=3 |- ^- (list (pair wing hoon)) ?~ yom ~ :- [p.i.yom [%$ (peg axe 2)]] $(yom t.yom, axe (peg axe 3)) :: ++ lads :: possible children |= {cof/cafe bem/beam} ^- (bolt (map knot ~)) %^ filter-at-beam cof bem |= {cof/cafe dir/knot} %+ tug:bo (load-arch cof bem(s [dir s.bem])) (with:bo |=(a/arch ?~(dir.a ~ (some ~)))) :: ++ laze :: find real or virtual |= {cof/cafe bem/beam} %^ filter-at-beam cof bem |= {cof/cafe for/mark} ^- (bolt (unit ~)) ?. ((sane %tas) for) (new:bo cof ~) =. s.bem [for s.bem] %+ tug:bo (load-arch cof bem) |= {cof/cafe arc/arch} (new:bo cof (bind fil.arc |=(* ~))) :: ++ lace :: load file |= {cof/cafe for/mark bem/beam} ^- (bolt vase) %+ admit:bo |.(leaf+"ford: load {} {<(en-beam bem)>}") =. s.bem [for s.bem] %+ tug:bo (load-file cof bem) |= {cof/cafe cay/cage} ^- (bolt vase) ?. =(for p.cay) (err:bo cof leaf+"unexpected mark {}" ~) (new:bo cof q.cay) :: ++ lake :: check+coerce |= {fit/? for/mark} |= {cof/cafe sam/vase} ^- (bolt vase) %+ admit:bo |.(leaf+"ford: check {<[for bek `@p`(mug q.sam)]>}") %+ tug:bo (fang cof for) |= {cof/cafe tux/vase} =+ typ=p:(slot 6 tux) =. typ ?+(-.typ typ $face q.typ) ?: (~(nest ut typ) | p.sam) (new:bo cof typ q.sam) ?. fit (err:bo cof [%leaf "ford: invalid type: {}"]~) ?. (slob %grab p.tux) (err:bo cof [%leaf "ford: no grab: {<[for bek]>}"]~) =+ gab=(slap tux [%limb %grab]) ?. (slob %noun p.gab) (err:bo cof [%leaf "ford: no noun: {<[for bek]>}"]~) %+ tug:bo (maul cof (slap gab [%limb %noun]) [%noun q.sam]) |= {cof/cafe pro/vase} ?> (~(nest ut typ) | p.pro) ?: =(q.pro q.sam) (new:bo cof typ q.pro) (err:bo cof [%leaf "ford: invalid content: {<[for bek]>}"]~) :: ++ to-concrete-revision :: numerical r.bem |= {cof/cafe bem/beam} ^- (bolt beam) ?: ?=($ud -.r.bem) (new:bo cof bem) =+ von=(syve [151 %noun] ~ %cw bem(s ~)) ?~ von [p=cof q=[%1 [%c %w bem(s ~) ~] ~ ~]] (new:bo cof bem(r [%ud ((hard @) +.+:(need u.von))])) :: ++ infer-product-type |= {cof/cafe typ/type gen/hoon} %+ (from-each:bo cof) (mule |.((~(play ut typ) gen))) |=(ref/type ref) :: ++ filter-at-beam |* {cof/cafe bem/beam fun/(burg knot (unit))} %+ tug:bo (load-arch cof bem) |=({cof/cafe arc/arch} ((some-in-map:bo fun) cof dir.arc)) :: ++ load-core |= {cof/cafe bem/beam} ^- (bolt vase) %+ tug:bo (to-concrete-revision cof bem) |= {cof/cafe bem/beam} (boil cof many+~ bem bem) :: ++ boil ~/ %boil |= {cof/cafe arg/coin bem/beam bom/beam} ^- (bolt vase) %+ tug:bo (to-concrete-revision cof bem) |= {cof/cafe bem/beam} %+ under-dep:bo `dent`[%boil bem bom arg] %+ (with-cache:bo %boil) (new:bo cof arg bem bom) |= {cof/cafe arg/coin bem/beam bom/beam} %+ tug:bo (fame cof bem) |= {cof/cafe bem/beam} (tug:bo (compile-to-hood cof bem) (meow bom arg)) :: ++ load-arch |= {cof/cafe bem/beam} ^- (bolt arch) =+ von=(syve [151 %noun] ~ %cy bem) ?~ von [p=cof q=[%1 [%c %y bem ~] ~ ~]] ?> ?=({~ $arch ^} u.von) =+ arc=((hard arch) q.q.u.u.von) %+ tug:bo (to-concrete-revision cof bem) |= {cof/cafe bem/beam} (add-dep:bo [%beam bem %z] (new:bo cof arc)) :: ++ load-file ~/ %load-file |= {cof/cafe bem/beam} ^- (bolt cage) %+ tug:bo (add-dep:bo [%beam bem %z] (new:bo cof bem)) |= [cof=cafe bem=beam] ?: =([%ud 0] r.bem) (err:bo cof [leaf+"ford: no data: {<(en-beam bem(s ~))>}"]~) =+ von=(syve [151 %noun] ~ %cx bem) ?~ von [p=cof q=[%1 [[%c %x bem ~] ~ ~]]] ?~ u.von (err:bo cof leaf+"file not found" (smyt (en-beam bem)) ~) (new:bo cof u.u.von) :: ++ load-to-mark ~/ %load-to-mark |= {cof/cafe for/mark bem/beam} %+ under-dep:bo `dent`[%load bem for] %+ (with-cache:bo %load) (new:bo cof for bem) |= {cof/cafe for/mark bem/beam} ^- (bolt (unit vase)) %+ tug:bo (laze cof bem) |= {cof/cafe mal/(map mark ~)} ?: (~(has by mal) for) (tug:bo (lace cof for bem) (with:bo some)) =+ opt=(silt (turn ~(tap by mal) head)) :: XX asymptotics %+ tug:bo (find-translation-path cof for opt) |= {cof/cafe wuy/(list @tas)} ?~ wuy (new:bo cof ~) %+ tug:bo (lace cof i.wuy bem) |= {cof/cafe hoc/vase} (tug:bo (run-marks cof i.wuy t.wuy hoc) (with:bo some)) :: ++ render-or-load |= {cof/cafe for/mark arg/coin bem/beam} ^- (bolt vase) %+ catch:bo %+ admit:bo |.(leaf+"load: attempt renderer") (boil cof arg [-.bem /[for]/ren] bem) |= cof/cafe ^- (bolt vase) %+ admit:bo |.(leaf+"load: attempt mark") %+ tug:bo (load-to-mark cof for bem) |= {cof/cafe vux/(unit vase)} ?^ vux (new:bo cof u.vux) (err:bo cof leaf+"ford: no {} at {<(en-beam bem)>}" ~) :: ++ translate-mark ~/ %translate-mark |= {cof/cafe too/mark for/mark vax/vase} =* translate-mark-jet . :: ~$ translate-mark ^- (bolt vase) :: %+ admit:bo |.(leaf+"ford: translate-mark {} {} {}") ?: =(too for) (new:bo cof vax) ?: |(=(%noun for) =(%$ for)) ((lake & too) cof vax) %+ tug:bo (fang cof for) |= {cof/cafe pro/vase} ^- (bolt vase) ?: :: =< $ ~% %limb-grow translate-mark-jet ~ |. &((slob %grow p.pro) (slob too p:(slap pro [%limb %grow]))) :: ~$ translate-mark-grow :: =< $ ~% %grow translate-mark-jet ~ |. %+ admit:bo |.(leaf+"ford: grow {} to {}") %+ tug:bo (keel cof pro [[%& 6]~ vax]~) |= {cof/cafe pox/vase} (wrapped-slap cof pox [%tsgr [%limb %grow] [%limb too]]) %+ tug:bo (fang cof too) ~% %grab translate-mark-jet ~ |= {cof/cafe pro/vase} =+ :: =< $ ~% %limb-grab + ~ |. ^= zat ^- (unit vase) ?. (slob %grab p.pro) ~ =+ gab=(slap pro [%limb %grab]) ?. (slob for p.gab) ~ `(slap gab [%limb for]) ?~ zat :: ~$ translate-mark-miss (err:bo cof [%leaf "ford: no translate-mark: {<[for too]>}"]~) :: ~$ translate-mark-grab ~| [%translate-mark-maul for too] (maul cof u.zat vax) :: ++ translation-targets ~/ %translation-targets |= {cof/cafe for/mark} ^- (bolt (set @tas)) %+ tug:bo (catch:bo (fang cof for) |=(cof/cafe (new:bo cof %void ~))) %- with:bo |= vax/vase ^- (set mark) %- =- ~(gas in `(set mark)`-) ?. (slob %grow p.vax) ~ (silt (sloe p:(slap vax [%limb %grow]))) ?. (slob %garb p.vax) ~ =+ (slap vax [%limb %garb]) (fall ((soft (list mark)) q) ~) :: ++ find-translation-path ~/ %find-translation-path |= {cof/cafe too/mark fro/(set mark)} =* find-translation-path-jet . :: ~& find-translation-path+[too=too fro=fro] :: =- =+ (tug:bo - (with:bo |=(a/(list mark) ~&(find-translation+a ~)))) :: +< ^- (bolt (list mark)) =; gro/(burg (set mark) (list mark)) %+ catch:bo (gro cof too ~ ~) :: XX better grab layer ~% %grab find-translation-path-jet ~ |= cof/cafe %+ admit:bo |.(leaf+"cast: finding grabbable grow destinations") %+ tug:bo (fang cof too) |= {cof/cafe vax/vase} ^- (bolt (list mark)) ?. (slob %grab p.vax) (new:bo cof ~) %+ tug:bo (gro cof (silt (sloe p:(slap vax [%limb %grab])))) (with:bo |=(a/path (welp a /[too]))) |= {cof/cafe tag/(set mark)} =| $: war/(map mark (list mark)) pax/(list mark) won/{p/mark q/(qeu mark)} == %. [cof fro] |= {cof/cafe fro/(set mark)} ^- (bolt (list mark)) ?: (~(has in tag) p.won) (new:bo cof (flop pax)) =+ for=(skip ~(tap in fro) ~(has by war)) =. for (sort for aor) :: XX useful? =: q.won (~(gas to q.won) for) war (~(gas by war) (turn for |=(mark [+< pax]))) == ?: =(~ q.won) (new:bo cof ~) =. won ~(get to q.won) %+ tug:bo (translation-targets cof p.won) |= {cof/cafe fro/(set mark)} =. pax [p.won (~(got by war) p.won)] ^$(cof cof, fro fro) :: ++ run-marks |= {cof/cafe for/mark yaw/(list mark) vax/vase} ^- (bolt vase) ?~ yaw (new:bo cof vax) %+ tug:bo (translate-mark cof i.yaw for vax) |= {cof/cafe yed/vase} ^$(cof cof, for i.yaw, yaw t.yaw, vax yed) :: ++ mint-cached ~/ %mint-cached |= {cof/cafe sut/type gen/hoon} ^- (bolt (pair type nock)) %+ (with-cache:bo %slim) (new:bo cof sut gen) |= {cof/cafe sut/type gen/hoon} =+ puz=(mule |.((~(mint ut sut) [%noun gen]))) ?- -.puz %| (err:bo cof p.puz) %& (new:bo cof p.puz) == :: ++ wrapped-slap ~/ %wrapped-slap |= {cof/cafe vax/vase gen/hoon} ^- (bolt vase) %+ tug:bo (mint-cached cof p.vax gen) |= {cof/cafe typ/type fol/nock} %+ (from-toon:bo cof) (mock [q.vax fol] (sloy syve)) |=(val/* `vase`[typ val]) :: ++ make-with-concrete-revision :: numerical r.bek |= {cof/cafe kas/silk} %+ tug:bo (to-concrete-revision cof bek ~) |=({cof/cafe byk/beak *} (make(bek byk) cof kas)) :: ++ abbrev :: shorten coin |=(a/coin ?-(-.a $$ a, $blob a(p (mug p.a)), $many a(p (turn p.a ..$)))) :: ++ make :: reduce silk |= {cof/cafe kas/silk} :: =+ ^= pre :: ?+ -.kas `term`-.kas :: ^ %cell:bo :: $bake [-.kas p.kas (en-beam r.kas) ~(rent co (abbrev q.kas))] :: $core [-.kas (en-beam p.kas)] :: == :: ~? !=(%$ pre) [dyv `term`(cat 3 %make (fil 3 dyv ' ')) pre] :: =- ~? !=(%$ pre) [dyv `term`(cat 3 %made (fil 3 dyv ' ')) pre] - :: =. dyv +(dyv) :: go deeper ^- (bolt gage) ?- -.kas ^ %. [cof p.kas q.kas] ;~ tug:bo ;~ cell:bo |=({cof/cafe p/silk q/silk} (to-cage:bo ^$(cof cof, kas p.kas))) |=({cof/cafe p/silk q/silk} (to-cage:bo ^$(cof cof, kas q.kas))) == :: XX merge %tabl :: |= {cof/cafe bor/cage heg/cage} ^- (bolt gage) (to-gage:bo (new:bo cof (slop q.bor q.heg))) == :: $$ (new:bo cof %& p.kas) $alts |- ^- (bolt gage) ?~ p.kas (err:bo cof leaf+"ford: out of options" ~) %+ catch:bo (admit:bo %option ^$(cof cof, kas i.p.kas)) |= cof/cafe ^- (bolt gage) ^$(cof cof, p.kas t.p.kas) :: $bake ^- (bolt gage) %+ admit:bo |.(leaf+"ford: bake {} {<(en-beam r.kas)>} {~(rend co q.kas)}") %+ tug:bo (to-concrete-revision cof r.kas) |= {cof/cafe bem/beam} %+ tug:bo (render-or-load cof p.kas q.kas bem) |= {cof/cafe vax/vase} (new:bo cof `gage`[%& p.kas vax]) :: $bunt %+ admit:bo |.(leaf+"ford: bunt {}") %+ tug:bo (fang cof p.kas) |= {cof/cafe tux/vase} =+ [typ=p val=q]:(slot 6 tux) =. typ ?+(-.typ typ $face q.typ) (new:bo cof [%& p.kas [typ val]]) :: $call :: %+ admit:bo |.(leaf+"ford: call {<`@p`(mug kas)>}") %. [cof p.kas q.kas] ;~ tug:bo ;~ cell:bo |=({cof/cafe p/silk q/silk} (to-cage:bo ^$(cof cof, kas p))) |=({cof/cafe p/silk q/silk} ^$(cof cof, kas q)) == :: |= {cof/cafe gat/cage sam/gage} %. [cof sam] %- tabl-run |= {cof/cafe sam/cage} (to-gage:bo (maul cof q.gat q.sam)) == :: $cast %+ admit:bo |.(leaf+"ford: cast {}") %+ tug:bo $(kas q.kas) %- tabl-run |= {cof/cafe cay/cage} :: ~$ make-cast :: ~> %live. :: ~$(make-cast-{to}--{from} ~) :: (rap 3 %make-cast- p.kas '--' p.cay ~) ^- (bolt gage) %+ admit:bo |.(leaf+"ford: casting {} to {}") %+ tug:bo (find-translation-path cof p.kas p.cay `~) |= {cof/cafe wuy/(list @tas)} %+ tug:bo ?~ wuy (translate-mark cof p.kas p.cay q.cay) (run-marks cof i.wuy t.wuy q.cay) (with:bo |=(vax/vase [%& p.kas vax])) :: $core %+ admit:bo |.(leaf+"ford: core {<(en-beam p.kas)>}") :: code runtime behaviour is frequently affected by marks :: TODO: track this more formally %+ add-dep:bo [%beam [bek /mar] %z] (tug:bo (load-core cof p.kas) (with:bo |=(a/vase [%& %core a]))) :: $diff %+ admit:bo |.(leaf+"ford: diff {<`@p`(mug p.kas)>} {<`@p`(mug q.kas)>}") (diff cof p.kas q.kas) :: $dude (admit:bo p.kas $(kas q.kas)) $file %+ admit:bo |.(leaf+"ford: file {}") %+ tug:bo (load-file cof p.kas) (with:bo |=(cay/cage [%& cay])) :: $flag =+ rez=$(kas q.kas) ?: ?=($1 -.q.rez) rez =- rez(p.q -) :: TODO name p.q.rez? |- ^- (set dent) ?~ p.kas p.q.rez =. p.q.rez $(p.kas l.p.kas) =. p.q.rez $(p.kas r.p.kas) ?^ n.p.kas (~(put in p.q.rez) %beam n.p.kas %z) =/ dap=(unit (set dent)) (~(get by def.deh.bay) n.p.kas) ?~ dap ~&(flag-missed+n.p.kas p.q.rez) (~(uni in p.q.rez) u.dap) :: XX revisit ^ during dependency review $join %+ admit:bo |. leaf+"ford: join {} {<`@p`(mug q.kas)>} {<`@p`(mug r.kas)>}" (join cof p.kas q.kas r.kas) :: $mash %+ admit:bo |. leaf+"ford: mash {} {<`@p`(mug q.kas)>} {<`@p`(mug r.kas)>}" (mash cof p.kas q.kas r.kas) :: $mute (kale cof p.kas q.kas) $pact %+ admit:bo |.(leaf+"ford: pact {<`@p`(mug p.kas)>} {<`@p`(mug q.kas)>}") (pact cof p.kas q.kas) :: $plan (to-gage:bo ((meow p.kas q.kas) cof r.kas)) $reef %+ add-dep:bo [%beam [bek /arvo/hoon] %z] %+ add-dep:bo [%beam [bek /arvo/zuse] %z] :: until /? is in use, any hoon may implicitly depend on arvo types (to-gage:bo (new:bo cof pit)) :: $ride %+ admit:bo |.(leaf+"ford: build failed {}") %+ tug:bo $(kas q.kas) %- tabl-run |= {cof/cafe cay/cage} (to-gage:bo (wrapped-slap cof q.cay p.kas)) :: $tabl %+ tug:bo |- ^- (bolt (list (pair gage gage))) ?~ p.kas (new:bo cof ~) %. [cof p.kas] ;~ tug:bo ;~ cell:bo |=({cof/cafe _p.kas} (catch-error:bo ^^$(cof cof, kas p.i))) |=({cof/cafe _p.kas} (catch-error:bo ^^$(cof cof, kas q.i))) |=({cof/cafe _p.kas} ^$(cof cof, p.kas t)) == (with:bo |=({k/gage v/gage t/(list {gage gage})} [[k v] t])) == (with:bo |=(rex/(list (pair gage gage)) [%tabl rex])) :: $vale %+ admit:bo |.(leaf+"ford: vale {} {<`@p`(mug q.kas)>}") %+ tug:bo ((lake & p.kas) cof [%noun q.kas]) (with:bo |=(vax/vase `gage`[%& p.kas vax])) :: $volt %+ admit:bo |.(leaf+"ford: volt {}") %+ tug:bo $(kas [%bunt p.p.kas]) %- tabl-run |= {cof/cafe cay/cage} ^- (bolt gage) (new:bo cof [%& p.p.kas p.q.cay q.p.kas]) == :: ++ malt :: cached slit ~/ %slit |= {cof/cafe gat/type sam/type} ^- (bolt type) %+ (with-cache:bo %slit) (new:bo cof gat sam) |= {cof/cafe gat/type sam/type} %+ admit:bo |.(%.(%have ~(dunk ut sam))) %+ admit:bo |.(%.(%want ~(dunk ut (~(peek ut gat) %free 6)))) =+ top=(mule |.((slit gat sam))) ?- -.top %| (err:bo cof p.top) %& (new:bo cof p.top) == :: ++ maul :: slam ~/ %maul |= {cof/cafe gat/vase sam/vase} ^- (bolt vase) %+ tug:bo (malt cof p.gat p.sam) |= {cof/cafe typ/type} %+ (from-toon:bo cof) (mong [q.gat q.sam] (sloy syve)) |=(val/* `vase`[typ val]) :: ++ meow :: assemble :: =+ dyv=0 |= {how/beam arg/coin} =| $: rop/(map term (pair hoof hoon)) :: structures bil/(map term (pair hoof hoon)) :: libraries boy/(list hoon) :: body stack lit/? :: drop arguments == ~% %meow ..meow ~ =< abut |% ++ able :: assemble preamble ^- hoon :+ %tsgr ?: =(~ rop) [%$ 1] :+ %brcn [~ ~] =- [[0 [~ ~] -] ~ ~] (~(run by rop) |=({^ a/hoon} [~ %ash a])) ?: =(~ bil) [%$ 1] :+ %brcn [~ ~] =- [[0 [~ ~] -] ~ ~] (~(run by bil) |=({^ a/hoon} [~ %ash a])) :: ++ abut :: generate |= {cof/cafe hyd/hood} :: TODO: $ and |^ ^- (bolt vase) %+ tug:bo (apex cof hyd) |: $:{cof/cafe sel/_..abut} =. ..abut sel %+ tug:bo (to-cage:bo (make cof %reef ~)) |= {cof/cafe mark zus/vase} %+ tug:bo (wrapped-slap cof zus able) |= {cof/cafe bax/vase} %+ tug:bo (chap cof bax [%fsdt fan.hyd]) |= {cof/cafe mar/mark gox/vase} %+ tug:bo (wrapped-slap cof (slop gox bax) [%tssg (flop boy)]) |= {cof/cafe fin/vase} (new:bo cof fin) :: ~> %slog.[0 ~(duck ut p.q.cay)] :: ++ apex :: build to body |= {cof/cafe hyd/hood} ^- (bolt _..apex) %+ tug:bo (body cof src.hyd) ::=. dyv +(dyv) ::~& [`term`(cat 3 %apex (fil 4 dyv ' ')) `path`(flop s.how) libs] ::=- ~& [`term`(cat 3 %xepa (fil 4 dyv ' ')) `path`(flop s.how)] - |: $:{cof/cafe sel/_..apex} =. ..apex sel %+ tug:bo (neck cof lib.hyd) |: $:{cof/cafe sel/_..apex} =. ..apex sel(boy boy) %+ tug:bo (head cof sur.hyd) |: $:{cof/cafe sel/_..apex} (new:bo cof sel) :: ++ body :: produce functions |= {cof/cafe src/(list hoop)} ^- (bolt _..body) ?~ src (new:bo cof ..body) %+ tug:bo (wilt cof i.src) |: $:{cof/cafe sel/_..body} ^$(src t.src, ..body sel, cof cof) :: ++ chai :: atomic map |= {cof/cafe bax/vase hon/horn} ^- (bolt vase) %+ tug:bo %+ tug:bo (lads cof how) %- some-in-map:bo |= {cof/cafe dir/knot} =+ nod=(chap(s.how [dir s.how]) cof bax hon) ?: ?=($2 -.q.nod) (new:bo cof ~) (tug:bo nod (with:bo some)) %- with:bo |= doy/(map @ cage) ^- vase ?~ doy [[%atom %n `0] 0] %+ slop (slop [[%atom %ta ~] p.n.doy] q.q.n.doy) (slop $(doy l.doy) $(doy r.doy)) :: ++ chap :: produce resources |= {cof/cafe bax/vase hon/horn} ^- (bolt cage) ?- -.hon $fssg (tug:bo (wrapped-slap cof bax p.hon) (with:bo |=(a/vase [%noun a]))) :: $fsbc %+ tug:bo (wrapped-slap cof bax p.hon) |= {cof/cafe gat/vase} %+ tug:bo (wrapped-slap cof !>(~) ((jock |) arg)) |= {cof/cafe val/vase} %+ tug:bo (maul cof gat (slop !>(how) val)) (with:bo |=(a/vase noun+a)) :: $fsbr |- ^- (bolt cage) ?~ p.hon (err:bo cof leaf+"ford: out of options" ~) %+ catch:bo (admit:bo %option ^$(cof cof, hon i.p.hon)) |= cof/cafe ^- (bolt cage) ^$(cof cof, p.hon t.p.hon) :: $fshx =+ [dep bot]=(pin:bo $(hon p.hon)) :: XX review %+ tug:bo bot %- with:bo |= {mark vax/vase} [%noun (slop [atom+['uvH' ~] dep] vax)] :: $fsts %+ tug:bo $(hon q.hon) %- with:bo |= {mar/mark vax/vase} [mar [%face [~ p.hon] p.vax] q.vax] :: $fsdt %+ tug:bo %+ tug:bo |- ^- (bolt (list vase)) ?~ p.hon (new:bo cof ~) %+ tug:bo ^$(cof cof, hon i.p.hon) |= {cof/cafe mar/mark vax/vase} %+ tug:bo ^$(cof cof, p.hon t.p.hon) (with:bo |=(tev/(list vase) [vax tev])) |= {cof/cafe tev/(list vase)} %+ new:bo cof |- ^- vase ?~ tev [[%atom %n `~] 0] (slop i.tev $(tev t.tev)) (with:bo |=(a/vase noun+a)) :: $fscm =+ opt=|.(>(turn p.hon |=({a/path ^} a))<) |- ^- (bolt cage) ?~ p.hon (err:bo cof leaf+"ford: no match" >(en-beam how)< $:opt ~) ?: =(p.i.p.hon (scag (lent p.i.p.hon) (flop s.how))) ^$(hon q.i.p.hon) $(p.hon t.p.hon) :: $fscn $(hon p.hon, lit |) $fspm %+ tug:bo $(hon q.hon) |= {cof/cafe cay/cage} ^- (bolt cage) ?~ p.hon (new:bo cof cay) %+ tug:bo $(p.hon t.p.hon) |= {cof/cafe cay/cage} (to-cage:bo (make cof %cast i.p.hon $+cay)) :: $fscb %+ tug:bo (chai cof bax p.hon) (with:bo |=(a/vase noun+a)) :: $fssm %+ tug:bo $(hon q.hon) |= {cof/cafe mar/mark sam/vase} %+ tug:bo (wrapped-slap cof bax p.hon) |= {cof/cafe gat/vase} %+ tug:bo (maul cof gat sam) (with:bo |=(a/vase noun+a)) :: $fscl =+ vez=(vang & (en-beam how)) =+ tuz=(posh:vez p.hon) ?~ tuz (err:bo cof leaf+"bad tusk: {}" ~) =+ pax=(plex:vez %clsg u.tuz) ?~ pax (err:bo cof leaf+"bad path: {}" ~) =+ bem=(de-beam u.pax) ?~ bem (err:bo cof leaf+"bad beam: {}" ~) $(hon q.hon, how u.bem) :: $fskt %+ tug:bo $(hon q.hon) |= {cof/cafe mar/mark vax/vase} %+ tug:bo (wrapped-slap cof bax [%bcdt %bcmc p.hon]) |= {cof/cafe tug/vase} ?. (~(nest ut p.tug) | p.vax) (err:bo cof [%leaf "type error: {} {}"]~) (new:bo cof [mar p.tug q.vax]) :: $fszp %+ admit:bo |.(leaf+"ford: hook {} {<(en-beam how)>}") %. [cof how] ;~ tug:bo compile-to-hood (meow how arg) (lake | q.hon) (with:bo |=(a/vase [q.hon a])) == :: $fszy =. arg ?.(lit arg many+~) (to-cage:bo (make cof %bake q.hon arg how)) == :: ++ head :: consume structures |= {cof/cafe bir/(list hoof)} ^- (bolt _..head) ?~ bir (new:bo cof ..head) =. boy ?: p.i.bir boy (welp boy [[%tscm [%limb q.i.bir] [%$ 1]] ~]) =+ byf=(~(get by rop) q.i.bir) ?^ byf ?. =(+:`hoof`i.bir +:`hoof`p.u.byf) (err:bo cof [%leaf "structure mismatch: {<~[p.u.byf q.i.bir]>}"]~) $(bir t.bir) %+ tug:bo (fame cof (hone %sur i.bir)) |= {cof/cafe bem/beam} %+ tug:bo (compile-to-hood cof bem) |= {cof/cafe hyd/hood} %+ tug:bo (apex(how bem, boy ~) cof hyd) |: $:{cof/cafe sel/_..head} =. ..head %= sel boy boy how how rop %+ ~(put by (~(uni by rop) rop.sel)) q.i.bir [i.bir [%tssg (flop boy.sel)]] == ^^^$(cof cof, bir t.bir) :: ++ hone :: plant hoof |= {way/@tas huf/hoof} ^- beam ?~ r.huf how(s ~[q.huf way]) [[q.u.r.huf q.how p.u.r.huf] ~[q.huf way]] :: ++ neck :: consume libraries |= {cof/cafe bir/(list hoof)} ^- (bolt _..neck) ?~ bir (new:bo cof ..neck) =. boy ?: p.i.bir boy :: ~& ford+tscm+[q.i.bir boy] (welp boy [[%tscm [%limb q.i.bir] [%$ 1]] ~]) =+ byf=(~(get by bil) q.i.bir) ?^ byf ?. =(+:`hoof`i.bir +:`hoof`p.u.byf) (err:bo cof [%leaf "library mismatch: {<~[p.u.byf i.bir]>}"]~) $(bir t.bir) %+ tug:bo (fame cof (hone %lib i.bir)) |= {cof/cafe bem/beam} %+ tug:bo (compile-to-hood cof bem) |= {cof/cafe hyd/hood} %+ tug:bo (apex(how bem, boy ~) cof hyd) |: $:{cof/cafe sel/_..neck} =. ..neck %= sel how how bil %+ ~(put by (~(uni by bil) bil.sel)) q.i.bir [i.bir [%tssg (flop boy.sel)]] == ^^^$(cof cof, bir t.bir) :: ++ wilt :: process body entry |= {cof/cafe hop/hoop} ^- (bolt _..wilt) ?- -.hop %& (new:bo cof ..wilt(boy [p.hop boy])) %| =. r.p.hop ?:(?=({$ud $0} r.p.hop) r.how r.p.hop) %+ admit:bo |.(leaf+"ford: wilt {<[(en-beam p.hop)]>}") %+ tug:bo (load-arch cof p.hop) |= {cof/cafe arc/arch} ?: (~(has by dir.arc) %hoon) %+ tug:bo (compile-to-hood cof p.hop) |= {cof/cafe hyd/hood} %+ tug:bo (apex(boy ~) cof hyd) (with:bo |:(sel=..wilt sel(boy [[%tssg boy.sel] boy]))) =+ [all=(lark (slat %tas) arc) sel=..wilt] %+ tug:bo |- ^- (bolt (pair (map term (pair what foot)) _..wilt)) ?~ all (new:bo cof ~ ..wilt) %+ tug:bo $(all l.all) |: $:{cof/cafe lef/(map term (pair what foot)) sel/_..wilt} %+ tug:bo ^$(all r.all, cof cof, sel sel) |: $:{cof/cafe rig/(map term (pair what foot)) sel/_..wilt} %+ tug:bo %= ^^^^$ cof cof ..wilt sel(boy ~) s.p.hop [p.n.all s.p.hop] == |: $:{cof/cafe sel/_..wilt} %+ new:bo cof :_ sel ^- (map term (pair what foot)) [[p.n.all [~ %ash [%tssg boy.sel]]] lef rig] |: $:{cof/cafe mav/(map term (pair what foot)) sel/_..wilt} ?~ mav (err:bo cof [%leaf "source missing: {<(en-beam p.hop)>}"]~) (new:bo cof sel(boy [[%brcn [~ ~] [[0 [~ ~] mav] ~ ~]] boy])) == -- :: ++ pact-hoon :: .hoon special case |= {a/@t b/(urge:clay cord)} ^- @t ~| %lurk-hoon =, differ (of-wain (lurk (to-wain a) b)) :: ++ pact :: patch |= {cof/cafe kas/silk kos/silk} ^- (bolt gage) %. [cof kas kos] ;~ tug:bo ;~ cell:bo |=({cof/cafe p/silk q/silk} (to-cage:bo (make cof p))) |=({cof/cafe p/silk q/silk} (to-cage:bo (make cof q))) == |= {cof/cafe cay/cage coy/cage} ^- (bolt gage) %+ tug:bo (fang cof p.cay) |= {cof/cafe pro/vase} ?. (slab %grad p.pro) (err:bo cof leaf+"no ++grad" ~) =+ gar=(slap pro [%limb %grad]) ?@ q.gar =+ for=((sand %tas) q.gar) ?~ for (err:bo cof leaf+"bad mark ++grad" ~) (make cof `silk`[%cast p.cay %pact [%cast u.for %$ cay] %$ coy]) ?. (slab %form p.gar) (err:bo cof leaf+"no ++form:grad" ~) =+ for=((soft @tas) q:(slap gar [%limb %form])) ?~ for (err:bo cof leaf+"bad ++form:grad" ~) ?. =(u.for p.coy) %+ err:bo cof :_ ~ =< leaf+"pact on data with wrong form: {-} {+<} {+>}" [(trip p.cay) (trip u.for) (trip p.coy)] ?. (slab %pact p.gar) (err:bo cof leaf+"no ++pact:grad" ~) %+ tug:bo (keel cof pro [[%& 6]~ q.cay]~) |= {cof/cafe pox/vase} %+ tug:bo %^ maul cof (slap (slap pox [%limb %grad]) [%limb %pact]) q.coy (with:bo |=(pat/vase [%& p.cay pat])) == :: ++ syve ^- sley |= {ref/* sec/(unit (set monk)) tem/term bem/beam} ^- (unit (unit cage)) ?> =(%151 -.ref) %- %- lift |= (unit cage) :: ignore block %+ biff +< |= cay/cage ^- (unit cage) ?. -:(nets:wa +.ref `type`p.q.cay) :: error if bad type ~& :^ %ford-syve-lost `path`[tem (en-beam bem)] want=;;(type +.ref) have=p.q.cay ~ `cay ^- (unit (unit cage)) =+ (~(get by keg) tem bem) ?^ - (some -) (ska +<.$) -- -- :: -- . == =| axle =* lex - |= {now/@da eny/@ ski/sley} :: activate ^? :: opaque core ~% %ford-d ..is ~ |% :: ++ call :: request |= {hen/duct typ/* kyz/(hobo task:able)} ^+ [p=*(list move) q=..^$] =/ kis/task:able ?.(?=($soft -.kyz) kyz ((hard task:able) p.kyz)) ?: ?=($wegh -.kis) :_ ..^$ :_ ~ :^ hen %give %mass :- %ford :- %| %- |= a/(list (list mass)) ^- (list mass) :: XX single-home =+ a2=a ?~ a !! ?~ i.a ~ :_ $(a (turn a2 tail)) :- p.i.i.a ?~ -.q.i.i.a [%& (turn (turn a2 head) |=(b/mass ?~(-.q.b p.q.b !!)))] [%| $(a (turn (turn a2 head) |=(b/mass ?~(-.q.b !! p.q.b))))] %+ turn ~(tap by pol) |= {@ baby} :~ =/ caches/(jar term *) %- ~(rep by jav) |=({{* a/{term *}} b/(jar term *)} (~(add ja b) -.a +.a)) =/ cache-for |=(a/term [a %& (~(get ja caches) a)]) cache+[%| (turn `(list term)`/hood/bake/slit/slim/slap/slam cache-for)] :: :+ %depends %| :~ definitions+[%& deh] listeners+[%& sup] waiting+[%& out] == :: tasks+[%& dym tad] == =+ our=p.kis =+ ^= bay ^- baby =+ buy=(~(get by pol.lex) our) ?~(buy *baby u.buy) =^ mos bay ?- -.kis $wipe ~&(%ford-cache-wiped [~ bay(jav ~)]) $wasp (~(wasp za [our hen [now eny ski] ~] bay) q.kis) $exec ?~ q.kis ~(exec-cancel za [our hen [now eny ski] ~] bay) (~(exec-start za [our hen [now eny ski] ~] bay) u.q.kis) == [mos ..^$(pol (~(put by pol) our bay))] :: ++ doze |= {now/@da hen/duct} ^- (unit @da) ~ :: ++ load :: highly forgiving :: |=(old/axle ..^$(+>- old)) ::=. old :: ?. ?=([%0 *] old) old :: remove at 1 :: :- %1 :: |- ^- * :: ?~ +.old ~ :: ?> ?=([n=[p=* q=[tad=* dym=* deh=* jav=*]] l=* r=*] +.old) :: :- [p.n.+.old [tad.q.n.+.old dym.q.n.+.old deh.q.n.+.old ~]] :: [$(+.old l.+.old) $(+.old r.+.old)] |= old/* =+ lox=((soft axle) old) ^+ ..^$ ?~ lox ~& %ford-reset ..^$ ..^$(+>- u.lox) :: ++ scry |= {fur/(unit (set monk)) ren/@tas who/ship syd/desk lot/coin tyl/path} ^- (unit (unit cage)) [~ ~] :: ++ stay :: save w+o cache `axle`+>-.$(pol (~(run by pol) |=(a/baby a(jav ~)))) :: ++ take :: response |= {tea/wire hen/duct hin/(hypo sign)} :: TODO tea->wir ^+ [p=*(list move) q=..^$] ?> ?=({@ @ *} tea) =+ our=(slav %p i.tea) =+ bay=(~(got by pol.lex) our) =^ mos bay ~| tea =+ dep=((soft care:clay) i.t.tea) ?^ dep =+ bem=(need (de-beam t.t.tea)) (~(deps-take za [our hen [now eny ski] ~] bay) u.dep bem q.hin) :: ?> ?=({@ @ ^} t.t.tea) =+ :* num=(slav %ud i.t.tea) van=((hard vane) i.t.t.tea) ren=((hard care:clay) i.t.t.t.tea) bem=(need (de-beam t.t.t.t.tea)) == (~(task-take za [our hen [now eny ski] ~] bay) num [van ren bem] q.hin) [mos ..^$(pol (~(put by pol) our bay))] --