urbit/arvo/ford.hoon

1824 lines
64 KiB
Plaintext
Raw Normal View History

!:::::
2015-04-23 01:55:46 +03:00
:: :: %ford, new execution control
2014-04-23 21:02:36 +04:00
!? 164
::::
2015-12-20 23:50:45 +03:00
|= pit/vase
2014-04-23 21:02:36 +04:00
=> =~
2014-06-03 09:07:32 +04:00
:: structures
|%
++ gift gift-ford :: out result <-$
2014-07-21 07:15:02 +04:00
++ heel path :: functional ending
++ kiss kiss-ford :: in request ->$
2015-12-20 23:50:45 +03:00
++ move {p/duct q/(mold note gift)} :: local move
2014-06-03 09:07:32 +04:00
++ note :: out request $->
2015-12-14 10:58:14 +03:00
$% $: $c :: to %clay
2015-12-20 23:50:45 +03:00
$% {$warp p/sock q/riff} ::
2014-06-22 06:51:12 +04:00
== == == ::
2014-06-22 09:49:10 +04:00
++ sign :: in result $<-
2015-12-14 10:58:14 +03:00
$% $: $c :: by %clay
2015-12-20 23:50:45 +03:00
$% {$writ p/riot} ::
2014-06-22 06:51:12 +04:00
== == == ::
2014-06-03 09:07:32 +04:00
-- ::
2014-04-23 21:02:36 +04:00
|% :: structures
++ axle :: all %ford state
$: $2 :: version for update
2015-12-20 23:50:45 +03:00
pol/(map ship baby) ::
2014-05-14 04:04:23 +04:00
== ::
++ baby :: state by ship
2015-12-20 23:50:45 +03:00
$: tad/{p/@ud q/(map @ud task)} :: tasks by number
dym/(map duct @ud) :: duct to task number
deh/(map @uvH deps) :: depends by hash
jav/(map * calx) :: cache
2014-04-23 21:02:36 +04:00
== ::
2014-05-07 21:42:31 +04:00
++ bolt :: gonadic edge
2016-02-04 10:12:23 +03:00
|* a/$-(* *) :: product clam
2015-12-20 23:50:45 +03:00
$: p/cafe :: cache
2014-05-14 04:04:23 +04:00
$= q ::
2015-12-21 00:16:39 +03:00
$% {$0 p/(set beam) q/a} :: depends+product
2015-12-20 23:50:45 +03:00
{$1 p/(set {p/care q/beam r/tang})} :: blocks
2015-12-21 00:16:39 +03:00
{$2 p/(set beam) q/tang} :: depends+error
2014-05-14 04:04:23 +04:00
== ::
2014-04-23 21:02:36 +04:00
== ::
2014-05-07 21:42:31 +04:00
:: ::
++ burg :: gonadic rule
2016-02-04 10:12:23 +03:00
|* {a/$-(* *) b/$-(* *)} :: from and to
$-({c/cafe d/a} (bolt b)) ::
2014-05-07 21:42:31 +04:00
:: ::
2014-05-14 04:04:23 +04:00
++ cafe :: live cache
2015-12-20 23:50:45 +03:00
$: p/(set calx) :: used
q/(map * calx) :: cache
r/(map @uvH deps) :: dependss
2014-05-14 04:04:23 +04:00
== ::
:: ::
2014-05-14 21:32:00 +04:00
++ calm :: cache metadata
2015-12-20 23:50:45 +03:00
$: laz/@da :: last accessed
dep/(set beam) :: dependencies
2014-05-14 21:32:00 +04:00
== ::
2014-05-14 04:04:23 +04:00
++ calx :: concrete cache line
2016-02-19 23:00:35 +03:00
$% {$hood p/calm q/(trel beam beam cage) r/hood} :: compile
{$bake p/calm q/(trel mark coin beam) r/(unit vase)} :: load
{$slit p/calm q/{p/span q/span} r/span} :: slam type
2015-12-26 13:07:50 +03:00
{$slim p/calm q/{p/span q/twig} r/(pair span nock)}:: mint
2015-12-20 23:50:45 +03:00
{$slap p/calm q/{p/vase q/twig} r/vase} :: compute
{$slam p/calm q/{p/vase q/vase} r/vase} :: compute
2014-05-14 04:04:23 +04:00
== ::
2015-04-29 03:43:23 +03:00
++ deps :: depend state
2015-12-20 23:50:45 +03:00
$% {$init p/(set beam)} :: given out
{$sent p/(set duct) q/(set beam)} :: listener exists
2015-12-07 03:46:01 +03:00
{$done $~} :: change seen
2015-04-29 03:43:23 +03:00
== ::
2014-04-30 21:04:07 +04:00
++ task :: problem in progress
2015-12-20 23:50:45 +03:00
$: nah/duct :: cause
{bek/beak kas/silk} :: problem
keg/(map (pair term beam) cage) :: block results
kig/{p/@ud q/(map @ud {p/care q/beam})} :: blocks
2014-04-23 21:02:36 +04:00
== ::
2015-06-04 04:03:35 +03:00
++ gagl (list (pair gage gage))
2014-05-07 21:42:31 +04:00
-- ::
2014-04-30 21:04:07 +04:00
|% ::
2014-05-16 04:46:48 +04:00
++ calf :: reduce calx
2015-12-26 13:07:50 +03:00
|* sem/* :: a spansystem hack
2015-12-20 23:50:45 +03:00
|= cax/calx
2014-05-16 04:46:48 +04:00
?+ sem !!
2015-12-07 03:46:01 +03:00
$hood ?>(?=($hood -.cax) r.cax)
$bake ?>(?=($bake -.cax) r.cax)
$slap ?>(?=($slap -.cax) r.cax)
$slam ?>(?=($slam -.cax) r.cax)
$slim ?>(?=($slim -.cax) r.cax)
$slit ?>(?=($slit -.cax) r.cax)
2014-05-16 04:46:48 +04:00
==
::
2014-05-14 04:04:23 +04:00
++ calk :: cache lookup
2015-12-20 23:50:45 +03:00
|= a/cafe ::
|= {b/@tas c/*} ::
2015-12-07 03:46:01 +03:00
^- {(unit calx) cafe} ::
2014-05-14 04:04:23 +04:00
=+ d=(~(get by q.a) [b c]) ::
?~ d [~ a] ::
2014-05-14 06:44:44 +04:00
[d a(p (~(put in p.a) u.d))] ::
2014-05-14 04:04:23 +04:00
:: ::
2014-05-14 21:32:00 +04:00
++ came ::
2015-12-20 23:50:45 +03:00
|= {a/cafe b/calx} :: cache install
2014-05-14 04:04:23 +04:00
^- cafe ::
a(q (~(put by q.a) [-.b q.b] b)) ::
:: ::
2015-12-20 23:50:45 +03:00
++ faun (flux |=(a/vase [%& %noun a])) :: vase to gage
++ feel (flux |=(a/cage q.a)) :: cage to vase
2015-05-26 04:17:59 +03:00
++ furl :: unwrap gage to cage
2015-12-20 23:50:45 +03:00
|= {a/cafe b/gage} ^- (bolt cage)
2015-05-26 04:17:59 +03:00
?- -.b
2015-12-07 03:46:01 +03:00
$tabl (flaw a >%bad-marc< ~)
$| (flaw a p.b)
$& (fine a p.b)
2015-05-26 04:17:59 +03:00
==
::
++ fret :: lift error
2015-12-20 23:50:45 +03:00
|= a/(bolt gage) ^- (bolt gage)
2015-12-07 03:46:01 +03:00
?. ?=($2 -.q.a) a
2015-05-26 04:17:59 +03:00
[p.a [%0 p.q.a `gage`[%| q.q.a]]]
::
2015-12-20 23:50:45 +03:00
++ fine |* {a/cafe b/*} :: bolt from data
2014-06-07 22:36:31 +04:00
[p=`cafe`a q=[%0 p=*(set beam) q=b]] ::
2015-12-20 23:50:45 +03:00
++ flaw |= {a/cafe b/tang} :: bolt from error
2015-02-13 00:03:54 +03:00
[p=a q=[%2 p=*(set beam) q=b]] ::
2015-02-13 02:06:45 +03:00
++ flag :: beam into deps
2015-12-20 23:50:45 +03:00
|* {a/beam b/(bolt)} ::
2015-12-07 03:46:01 +03:00
?: ?=($1 -.q.b) b
2015-02-13 02:06:45 +03:00
=. p.q.b (~(put in p.q.b) a)
b
2015-02-13 00:03:54 +03:00
:: ::
2015-12-20 23:50:45 +03:00
++ flue |=(a/cafe (fine a ~)) :: cafe to empty
++ flux |* a/_* :: bolt lift (fmap)
|* {cafe _,.+<.a}
(fine +<- (a +<+))
2014-05-07 21:42:31 +04:00
::
2014-07-24 03:23:53 +04:00
++ lark :: filter arch names
2016-02-04 10:12:23 +03:00
|= {wox/$-(knot (unit @)) arc/arch}
^- (map @ knot)
%- ~(gas by *(map @ knot))
=| rac/(list (pair @ knot))
2014-07-24 03:23:53 +04:00
|- ^+ rac
2015-09-06 04:14:00 +03:00
?~ 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])
2014-07-24 03:23:53 +04:00
::
2015-06-24 01:59:48 +03:00
++ tack :: fold path to term
2015-12-20 23:50:45 +03:00
|= a/{i/term t/(list term)} ^- term
2015-06-24 01:59:48 +03:00
(rap 3 |-([i.a ?~(t.a ~ ['-' $(a t.a)])]))
::
++ tear :: split term
2015-12-20 23:50:45 +03:00
=- |=(a/term (rush a (most hep sym)))
2015-06-24 01:59:48 +03:00
sym=(cook crip ;~(plug low (star ;~(pose low nud))))
::
2014-04-30 21:04:07 +04:00
++ za :: per event
2015-12-20 23:50:45 +03:00
=| $: $: our/ship :: computation owner
hen/duct :: event floor
$: now/@da :: event date
eny/@ :: unique entropy
ska/sley :: system namespace
== ::
2015-12-20 23:50:45 +03:00
mow/(list move) :: pending actions
== ::
2015-12-20 23:50:45 +03:00
bay/baby :: all owned state
== ::
|%
2014-06-03 09:07:32 +04:00
++ abet :: resolve
2015-12-07 03:46:01 +03:00
^- {(list move) baby}
2014-05-14 04:04:23 +04:00
[(flop mow) bay]
2014-04-30 21:04:07 +04:00
::
2015-07-10 21:49:03 +03:00
++ apax :: call
^+ ..apax
=+ nym=(~(get by dym.bay) hen)
?~ nym :: XX should never
~& [%ford-mystery hen]
..apax
=+ tas=(need (~(get by q.tad.bay) u.nym))
amok:~(camo zo [u.nym tas])
::
++ apex
2015-12-20 23:50:45 +03:00
|= kub/bilk
2014-06-03 09:07:32 +04:00
^+ +>
2014-05-22 21:39:51 +04:00
=+ num=p.tad.bay
2014-09-24 05:03:20 +04:00
?< (~(has by dym.bay) hen)
2014-05-22 21:39:51 +04:00
=: p.tad.bay +(p.tad.bay)
dym.bay (~(put by dym.bay) hen num)
==
2015-07-10 21:49:03 +03:00
~(exec zo [num `task`[hen kub ~ 0 ~]])
2014-06-03 09:07:32 +04:00
::
++ axon :: take
2015-12-20 23:50:45 +03:00
|= {num/@ud tik/@ud sih/sign}
2014-06-03 09:07:32 +04:00
^+ +>
2014-06-22 06:51:12 +04:00
?- -.+.sih
2015-12-07 03:46:01 +03:00
$writ
2014-06-03 09:07:32 +04:00
=+ tus=(~(get by q.tad.bay) num)
?~ tus
~& [%ford-lost num]
+>.$
2014-06-22 06:51:12 +04:00
(~(resp zo [num u.tus]) tik p.+.sih)
2014-06-03 09:07:32 +04:00
==
::
2015-02-19 00:35:22 +03:00
++ axun :: take rev update
2015-12-20 23:50:45 +03:00
|= {tea/wire dep/@uvH bem/beam sih/sign}
2015-02-19 00:35:22 +03:00
^+ +>
?- -.+.sih
2015-12-07 03:46:01 +03:00
$writ
2015-04-29 03:43:23 +03:00
?~ p.sih +>.$
2015-12-21 00:16:39 +03:00
:: ~& writ+tea
2015-07-10 21:49:03 +03:00
=+ dap=(~(got by deh.bay) dep)
2015-12-01 02:52:18 +03:00
=- +>.$(mow mow, deh.bay ?~(dop deh.bay (~(put by deh.bay) dep dop)))
2015-12-20 23:50:45 +03:00
^- {dop/$@($~ _dap) mow/_mow}
2015-04-29 03:43:23 +03:00
?- -.dap
2015-12-07 03:46:01 +03:00
$done `mow :: writ redundant
2015-12-21 00:16:39 +03:00
$init ~|(never-subscribed+dep !!)
2015-12-07 03:46:01 +03:00
$sent
2015-12-01 02:52:18 +03:00
:- [%done ~]
;: weld
(axap dep (~(del in q.dap) bem)) :: cancel outstanding
2015-12-20 23:50:45 +03:00
(turn (~(tap in p.dap)) |=(hen/duct [hen %give %news dep]))
2015-12-01 02:52:18 +03:00
mow
== ==
2015-04-29 03:43:23 +03:00
==
2015-12-01 02:52:18 +03:00
::
++ axap :: unsubscribe beams
2015-12-20 23:50:45 +03:00
|= {dep/@uvH dap/(set beam)}
2015-12-01 02:52:18 +03:00
%+ turn (~(tap in dap))
2015-12-20 23:50:45 +03:00
|= bem/beam
2015-12-01 02:52:18 +03:00
:^ hen %pass [(scot %p our) (scot %uv dep) (tope bem)]
[%c %warp [our p.bem] q.bem ~]
2015-02-19 00:35:22 +03:00
::
++ awap :: get next revision
2015-02-21 00:42:57 +03:00
~% %ford-w ..is ~
2015-12-20 23:50:45 +03:00
|= {dep/@uvH ask/?}
2016-01-25 06:37:41 +03:00
?: =(`@`0 dep)
2015-12-21 00:16:39 +03:00
~&(dep-empty+hen +>.$)
2015-05-18 23:44:10 +03:00
?: =(dep 0vtest) :: upstream testing
2015-12-01 02:52:18 +03:00
+>.$(mow ?.(ask mow :_(mow [hen %give %news dep])))
2015-05-01 22:03:02 +03:00
=+ dap=(~(get by deh.bay) dep)
2015-12-21 00:16:39 +03:00
?~ dap ~&(dep-missed+dep +>.$) :: XX ~| !!
:: ~& awap+[dep u.dap]
2015-05-01 22:03:02 +03:00
?- -.u.dap
2015-12-07 03:46:01 +03:00
$done +>.$(mow ?.(ask mow :_(mow [hen %give %news dep])))
$sent
2015-12-01 02:52:18 +03:00
=. p.u.dap
?: ask (~(put in p.u.dap) hen)
(~(del in p.u.dap) hen)
?^ p.u.dap
+>.$(deh.bay (~(put by deh.bay) dep u.dap))
=. mow (weld (axap dep q.u.dap) mow)
+>.$(deh.bay (~(put by deh.bay) dep [%init q.u.dap]))
::
2015-12-07 03:46:01 +03:00
$init
2015-12-21 00:16:39 +03:00
?. ask ~&(awap-kill-empty+dep +>.$) :: crash?
2015-04-29 03:43:23 +03:00
%_ +>.$
2015-04-29 22:43:14 +03:00
deh.bay
2015-05-01 22:03:02 +03:00
(~(put by deh.bay) dep [%sent [hen ~ ~] p.u.dap])
2015-04-29 03:43:23 +03:00
::
mow
2015-05-01 22:03:02 +03:00
=< (welp :_(mow (turn (~(tap in p.u.dap)) .)))
2015-12-20 23:50:45 +03:00
|= bem/beam
2015-04-29 03:43:23 +03:00
:^ hen %pass [(scot %p our) (scot %uv dep) (tope bem)]
2016-01-08 02:54:42 +03:00
[%c [%warp [our p.bem] q.bem ~ [%next %z r.bem (flop s.bem)]]]
2015-04-29 03:43:23 +03:00
== ==
2015-02-19 00:35:22 +03:00
::
2014-04-30 21:04:07 +04:00
++ zo
~% %ford-z ..is ~
2016-02-20 00:20:06 +03:00
:: =| dyv/@
2015-12-20 23:50:45 +03:00
|_ {num/@ud task}
2014-05-14 04:04:23 +04:00
++ abet %_(..zo q.tad.bay (~(put by q.tad.bay) num +<+))
2014-10-02 23:46:00 +04:00
++ amok
%_ ..zo
2014-06-04 14:40:09 +04:00
q.tad.bay (~(del by q.tad.bay) num)
dym.bay (~(del by dym.bay) nah)
==
2014-05-16 04:46:48 +04:00
++ camo :: stop requests
^+ .
2015-12-20 23:50:45 +03:00
=+ kiz=(~(tap by q.kig) *(list {p/@ud q/{p/care q/beam}}))
2014-05-16 04:46:48 +04:00
|- ^+ +>
?~ kiz +>
%= $
kiz t.kiz
2015-03-12 03:37:37 +03:00
mow
:_ mow
2014-05-24 00:46:43 +04:00
:- hen
2015-03-12 03:37:37 +03:00
:^ %pass
2015-07-10 21:49:03 +03:00
[(scot %p our) (scot %ud num) (scot %ud p.i.kiz) ~]
2014-06-21 22:42:34 +04:00
%c
2014-12-10 01:59:31 +03:00
[%warp [our p.q.q.i.kiz] q.q.q.i.kiz ~]
2014-05-16 04:46:48 +04:00
==
::
2014-04-30 21:04:07 +04:00
++ camp :: request a file
2015-12-20 23:50:45 +03:00
|= {ren/care bem/beam}
2014-04-30 21:04:07 +04:00
^+ +>
2014-07-03 02:08:02 +04:00
%= +>
2014-12-10 01:59:31 +03:00
kig [+(p.kig) (~(put by q.kig) p.kig [ren bem])]
2015-03-12 03:37:37 +03:00
mow
:_ mow
2014-05-24 00:46:43 +04:00
:- hen
2015-03-12 03:37:37 +03:00
:^ %pass
2015-07-10 21:49:03 +03:00
[(scot %p our) (scot %ud num) (scot %ud p.kig) ~]
2014-06-21 22:42:34 +04:00
%c
2015-09-08 23:15:40 +03:00
~& >> [%camping ren bem]
2015-03-27 02:26:39 +03:00
[%warp [our p.bem] q.bem [~ %sing ren r.bem (flop s.bem)]]
2014-04-30 21:04:07 +04:00
==
2014-05-07 21:42:31 +04:00
::
2016-02-10 01:38:23 +03:00
++ clad :: hash dependencies
|* hoc/(bolt) ^+ [*@uvH hoc]
?: ?=($1 -.q.hoc) [*@uvH hoc]
2016-02-10 01:38:23 +03:00
=^ dep r.p.hoc (daze [p.q r.p]:hoc)
[dep hoc]
::
2014-05-14 21:32:00 +04:00
++ clef :: cache a result
2015-12-20 23:50:45 +03:00
|* sem/*
|* {hoc/(bolt) fun/(burg)}
2014-05-14 21:32:00 +04:00
?- -.q.hoc
2015-12-07 03:46:01 +03:00
$2 hoc
$1 hoc
$0
2014-05-14 21:32:00 +04:00
=^ cux p.hoc ((calk p.hoc) sem q.q.hoc)
?^ cux
2015-05-09 03:13:10 +03:00
[p=p.hoc q=[%0 p=dep.p.u.cux q=((calf sem) u.cux)]]
=+ nuf=(cope hoc fun)
?- -.q.nuf
2015-12-07 03:46:01 +03:00
$2 nuf
$1 nuf
$0
2015-06-12 00:42:05 +03:00
:: ~& :- %clef-new
2016-02-13 01:24:17 +03:00
:: ?+ sem `term`sem
:: $hood [%hood (tope &1.q.q.hoc)]
:: $bake [%bake `mark`&1.q.q.hoc (tope |2.q.q.hoc)]
2015-06-12 00:42:05 +03:00
:: ==
:- p=(came p.nuf `calx`[sem `calm`[now p.q.nuf] q.q.hoc q.q.nuf])
q=q.nuf
==
2014-05-14 21:32:00 +04:00
==
::
2015-08-27 21:47:45 +03:00
++ coax !. :: bolt across
2015-12-20 23:50:45 +03:00
|* {hoc/(bolt) fun/(burg)}
2014-05-14 04:04:23 +04:00
?- -.q.hoc
$0 =+ nuf=$:fun(,.+<- p.hoc)
2014-05-16 00:17:54 +04:00
:- p=p.nuf
2014-05-14 04:04:23 +04:00
^= q
?- -.q.nuf
$0 [%0 p=(~(uni in p.q.hoc) p.q.nuf) q=[q.q.hoc q.q.nuf]]
2015-12-07 03:46:01 +03:00
$1 q.nuf
$2 q.nuf
2014-05-07 21:42:31 +04:00
==
$1 =+ nuf=$:fun(,.+<- p.hoc)
2014-05-16 00:17:54 +04:00
:- p=p.nuf
2014-05-14 04:04:23 +04:00
^= q
?- -.q.nuf
2015-12-07 03:46:01 +03:00
$0 q.hoc
$1 [%1 p=(~(uni in p.q.nuf) p.q.hoc)]
2015-12-07 03:46:01 +03:00
$2 q.nuf
2014-05-07 21:42:31 +04:00
==
2015-12-07 03:46:01 +03:00
$2 hoc
2014-05-07 21:42:31 +04:00
==
::
2014-07-08 03:17:21 +04:00
++ cool :: error caption
2015-12-20 23:50:45 +03:00
|* {cyt/$@(term (trap tank)) hoc/(bolt)}
2015-12-07 03:46:01 +03:00
?. ?=($2 -.q.hoc) hoc
2015-07-06 22:48:16 +03:00
[p=p.hoc q=[%2 p=p.q.hoc q=[?^(cyt *cyt [>`@tas`cyt<]~) q.q.hoc]]]
::
2014-05-07 21:42:31 +04:00
++ cope :: bolt along
2015-12-20 23:50:45 +03:00
|* {hoc/(bolt) fun/(burg)}
2014-05-14 04:04:23 +04:00
?- -.q.hoc
2015-12-07 03:46:01 +03:00
$1 hoc
$2 hoc
$0 =+ nuf=(fun p.hoc q.q.hoc)
2014-05-16 00:17:54 +04:00
:- p=p.nuf
2014-05-14 04:04:23 +04:00
^= q
?- -.q.nuf
2015-12-07 03:46:01 +03:00
$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]
2015-06-08 22:48:35 +03:00
== ==
2014-05-07 21:42:31 +04:00
::
2015-06-24 01:59:48 +03:00
++ coop :: bolt alter
|* {hoc/(bolt) fun/$-(cafe (bolt))}
2015-06-24 01:59:48 +03:00
?- -.q.hoc
2015-12-07 03:46:01 +03:00
$1 hoc
$0 hoc
$2 =+ nuf=(fun p.hoc)
2015-06-24 01:59:48 +03:00
:- p=p.nuf
^= q
?- -.q.nuf
2015-12-07 03:46:01 +03:00
$1 q.nuf
$0 [%0 p=(~(uni in `_p.q.nuf`p.q.hoc) p.q.nuf) q=q.q.nuf]
2015-12-07 03:46:01 +03:00
$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]
2015-06-24 01:59:48 +03:00
== ==
::
2014-05-07 21:42:31 +04:00
++ coup :: toon to bolt
2015-12-20 23:50:45 +03:00
|= cof/cafe
2016-02-04 10:12:23 +03:00
|* {ton/toon fun/$-(* *)}
2014-05-16 00:17:54 +04:00
:- p=cof
2014-05-14 04:04:23 +04:00
^= q
2014-05-07 21:42:31 +04:00
?- -.ton
2015-12-07 03:46:01 +03:00
$2 [%2 p=*(set beam) q=p.ton]
$0 [%0 p=*(set beam) q=(fun p.ton)]
$1 :: ~& [%coup-need ((list path) p.ton)]
2014-10-02 22:53:53 +04:00
=- ?- -.faw
$& :- %1
^= p
2016-01-02 03:19:06 +03:00
%- silt
%+ turn p.faw
2015-12-20 23:50:45 +03:00
|=(a/{care beam} [-.a +.a *tang])
$| [%2 p=*(set beam) q=p.faw]
2014-05-07 21:42:31 +04:00
==
^= faw
2015-02-12 00:10:07 +03:00
|- ^- (each (list (pair care beam)) tang)
2014-05-07 21:42:31 +04:00
?~ p.ton [%& ~]
=+ nex=$(p.ton t.p.ton)
2015-12-21 00:16:39 +03:00
=+ err=|=(a/tape [%| leaf+a ?:(?=($& -.nex) ~ p.nex)])
2014-05-07 21:42:31 +04:00
=+ pax=(path i.p.ton)
2015-02-12 00:10:07 +03:00
?~ pax (err "blocking empty")
2015-12-07 03:46:01 +03:00
?. ?=($c (end 3 1 i.pax))
2015-02-12 00:10:07 +03:00
(err "blocking not clay")
2014-12-10 01:59:31 +03:00
=+ ren=((soft care) (rsh 3 1 i.pax))
?~ ren
2015-02-12 00:10:07 +03:00
(err "blocking not care")
2014-10-02 23:27:15 +04:00
=+ zis=(tome t.pax)
2014-05-07 21:42:31 +04:00
?~ zis
2015-02-12 00:10:07 +03:00
(err "blocking not beam")
2014-05-07 21:42:31 +04:00
?- -.nex
$& [%& [u.ren u.zis] p.nex]
$| nex
2014-05-07 21:42:31 +04:00
==
2014-04-30 21:04:07 +04:00
==
2014-05-07 21:42:31 +04:00
::
2014-07-26 04:29:01 +04:00
++ cowl :: each to bolt
2015-12-20 23:50:45 +03:00
|= cof/cafe
2016-02-04 10:12:23 +03:00
|* {tod/(each * tang) fun/$-(* *)}
2014-07-26 04:29:01 +04:00
%+ (coup cof)
?- -.tod
$& [%0 p=p.tod]
$| [%2 p=p.tod]
2014-07-26 04:29:01 +04:00
==
fun
::
2015-05-26 04:17:59 +03:00
++ tabl-run :: apply to all elems
2015-12-20 23:50:45 +03:00
|= fun/(burg cage gage)
|= {cof/cafe gag/gage}
2015-05-26 04:17:59 +03:00
^- (bolt gage)
2015-12-07 03:46:01 +03:00
?. ?=($tabl -.gag)
2015-05-26 04:17:59 +03:00
(cope (furl cof gag) fun)
%+ cope
|- ^- (bolt (list (pair gage gage)))
?~ p.gag (fine cof ~)
%. [cof p.gag]
;~ cope
;~ coax
|=({cof/cafe {^ q/gage} t/gagl} (fret ^^$(cof cof, gag q)))
|=({cof/cafe ^ t/gagl} ^$(cof cof, p.gag t))
==
(flux |=({v/gage t/gagl} [[p.i.p.gag v] t]))
2015-07-06 22:48:16 +03:00
==
(flux |=(rex/gagl [%tabl rex]))
2015-05-26 04:17:59 +03:00
::
2015-07-31 00:28:42 +03:00
++ some-in-map
|* fun/(burg knot (unit))
2015-12-15 01:21:10 +03:00
=+ res=_(need [?+(-.q !! $0 q.q)]:*fun)
=+ marv=(map knot res)
|= {cof/cafe sud/(map knot $~)} ^- (bolt marv)
2015-07-31 00:28:42 +03:00
?~ sud (flue cof)
%. [cof sud]
;~ cope
;~ coax
2015-12-20 23:50:45 +03:00
|=({cof/cafe _sud} ^$(cof cof, sud l))
|=({cof/cafe _sud} ^$(cof cof, sud r))
|= {cof/cafe {dir/@ta $~} ^}
2015-07-31 00:28:42 +03:00
%+ cope (fun cof dir)
(flux (lift |*(* [dir +<])))
==
%- flux
|= {lam/marv ram/marv nod/(unit {knot res})}
2015-07-31 00:28:42 +03:00
?^(nod [u.nod lam ram] (~(uni by lam) ram))
==
++ dash :: process cache
2015-12-20 23:50:45 +03:00
|= cof/cafe
2014-05-16 04:46:48 +04:00
^+ +>
2016-02-10 01:38:23 +03:00
%_(+> jav.bay q.cof, deh.bay r.cof)
2014-05-16 04:46:48 +04:00
::
2015-02-27 09:35:41 +03:00
++ diff :: diff
2015-12-20 23:50:45 +03:00
|= {cof/cafe kas/silk kos/silk}
2015-02-27 09:35:41 +03:00
^- (bolt gage)
%. [cof kas kos]
;~ cope
;~ coax
2015-12-20 23:50:45 +03:00
|=({cof/cafe p/silk q/silk} (cope (make cof p) furl))
|=({cof/cafe p/silk q/silk} (cope (make cof q) furl))
2015-02-27 09:35:41 +03:00
==
2015-12-20 23:50:45 +03:00
|= {cof/cafe cay/cage coy/cage} ^- (bolt gage)
2015-02-27 09:35:41 +03:00
?. =(p.cay p.coy)
%+ flaw cof :_ ~
2015-12-21 00:16:39 +03:00
leaf+"diff on data of different marks: {(trip p.cay)} {(trip p.coy)}"
2015-02-27 09:35:41 +03:00
?: =(q.q.cay q.q.coy)
2016-02-01 09:16:26 +03:00
(fine cof [%& %null [%atom %n ~] ~])
2015-07-06 22:48:16 +03:00
::
2015-03-12 03:37:37 +03:00
%+ cope (fang cof p.cay)
2015-12-20 23:50:45 +03:00
|= {cof/cafe pro/vase}
2015-02-27 09:35:41 +03:00
?. (slab %grad p.pro)
2015-12-21 00:16:39 +03:00
(flaw cof leaf+"no ++grad" ~)
2015-12-21 08:05:19 +03:00
=+ gar=(slap pro [%limb %grad])
2015-07-08 01:22:32 +03:00
?@ q.gar
=+ for=((sand %tas) q.gar)
2015-12-21 00:16:39 +03:00
?~ for (flaw cof leaf+"bad mark ++grad" ~)
2016-01-07 10:08:09 +03:00
%+ make cof ^- silk
:+ %diff
[%cast u.for [%$ cay]]
2015-12-29 01:01:44 +03:00
[%cast u.for [%$ coy]]
2015-07-08 01:22:32 +03:00
?. (slab %form p.gar)
2015-12-21 00:16:39 +03:00
(flaw cof leaf+"no ++form:grad" ~)
2015-02-27 09:35:41 +03:00
?. (slab %diff p.gar)
2015-12-21 00:16:39 +03:00
(flaw cof leaf+"no ++diff:grad" ~)
2015-02-27 09:35:41 +03:00
%+ cope (keel cof pro [[%& 6]~ q.cay]~)
2015-12-20 23:50:45 +03:00
|= {cof/cafe pox/vase}
2015-02-27 09:35:41 +03:00
%+ cope
%^ maul cof
2015-12-21 08:05:19 +03:00
(slap (slap pox [%limb %grad]) [%limb %diff])
2015-02-27 09:35:41 +03:00
q.coy
2015-12-20 23:50:45 +03:00
|= {cof/cafe dif/vase}
2015-12-21 08:05:19 +03:00
=+ for=((soft @tas) q:(slap gar [%limb %form]))
2015-02-27 09:35:41 +03:00
?~ for
2015-12-21 00:16:39 +03:00
(flaw cof leaf+"bad ++form:grad" ~)
2016-02-01 09:16:26 +03:00
(fine cof [%& u.for dif])
2015-02-27 09:35:41 +03:00
==
::
2015-02-19 00:35:22 +03:00
++ daze :: remember depends
|= {dep/(set beam) deh/(map @uvH deps)}
2015-02-19 02:15:27 +03:00
^+ [*@uvH deh.bay]
2015-06-04 04:03:35 +03:00
=. dep
2016-01-02 03:19:06 +03:00
=< (silt (skip (~(tap in dep)) .))
2015-12-20 23:50:45 +03:00
|= dap/beam ^- ?
2015-06-04 04:03:35 +03:00
?~ s.dap |
=>(.(s.dap t.s.dap) |((~(has in dep) dap) $))
2016-02-10 01:38:23 +03:00
?~ dep [0v0 deh]
2015-02-19 00:35:22 +03:00
=+ hap=(sham dep)
2016-02-10 01:38:23 +03:00
?: (~(has by deh) hap)
[hap deh]
[hap (~(put by deh) hap [%init dep])]
2015-01-08 04:49:57 +03:00
::
2014-05-07 21:42:31 +04:00
++ exec :: execute app
2014-04-30 21:04:07 +04:00
^+ ..zo
2014-05-09 04:34:57 +04:00
?: !=(~ q.kig) ..zo
2016-02-13 01:34:21 +03:00
=+ bot=(make-norm-bek [~ jav.bay deh.bay] kas)
2016-02-10 01:38:23 +03:00
=^ dep bot (clad bot)
2014-05-16 04:46:48 +04:00
=. ..exec (dash p.bot)
2014-05-14 04:04:23 +04:00
?- -.q.bot
$0 amok:(expo [%made dep q.q.bot])
$2 amok:(expo [%made dep %| q.q.bot])
2015-12-07 03:46:01 +03:00
$1 =+ zuk=(~(tap by p.q.bot) ~)
2014-05-09 04:34:57 +04:00
=< abet
|- ^+ ..exec
?~ zuk ..exec
2015-12-15 01:21:10 +03:00
$(zuk t.zuk, ..exec `_..exec`(camp p.i.zuk q.i.zuk))
==
2014-05-07 21:42:31 +04:00
::
2014-06-03 09:07:32 +04:00
++ expo :: return gift
2015-12-20 23:50:45 +03:00
|= gef/gift
2014-06-03 09:07:32 +04:00
%_(+> mow :_(mow [hen %give gef]))
2014-05-09 04:34:57 +04:00
::
++ fade :: compile to hood
2015-12-20 23:50:45 +03:00
|= {cof/cafe for/mark bem/beam}
^- (bolt hood)
2016-02-09 23:06:41 +03:00
(fape cof for bem bem)
::
++ fape :: XX compile at path
|= {cof/cafe for/mark bem/beam bim/beam}
2016-02-09 23:06:41 +03:00
^- (bolt hood)
2015-12-21 00:16:39 +03:00
%+ cool |.(leaf+"ford: fade {<[(tope bem)]>}")
%+ cope (liar cof %*(. bem s [for s.bem]))
2015-12-20 23:50:45 +03:00
|= {cof/cafe cay/cage}
2016-02-19 23:00:35 +03:00
%+ (clef %hood) (fine cof bem(r [%ud 0]) bim(r [%ud 0]) cay)
^- (burg (trel beam beam cage) hood)
|= {cof/cafe bem/beam bim/beam cay/cage}
2014-07-19 04:51:22 +04:00
?. ?=(@ q.q.cay)
(flaw cof ~)
2016-02-19 23:00:35 +03:00
=+ vex=((full (fair bem)) [[1 1] (trip q.q.cay)])
2014-07-19 04:51:22 +04:00
?~ q.vex
(flaw cof [%leaf "syntax error: {<p.p.vex>} {<q.p.vex>}"] ~)
(fine cof p.u.q.vex)
::
++ fame :: beam with - as /
|= {cof/cafe bem/beam}
2015-07-08 03:05:25 +03:00
^- (bolt beam)
%+ cope
?~ s.bem (flue cof)
=+ opt=`(list term)`(fall (tear i.s.bem) ~)
?~ opt (flue cof)
|- ^- (bolt (unit beam))
=. i.s.bem (tack opt)
%+ cope (lima cof %hoon many+~ bem)
|= {cof/cafe vax/(unit vase)} ^- (bolt (unit beam))
?^ vax (fine cof `bem)
?~ t.opt (flue cof)
%+ cope ^$(opt t.opt, t.s.bem :_(t.s.bem i.opt), cof cof)
|= {cof/cafe bem/(unit beam)} ^- (bolt (unit beam))
?^ bem (fine cof bem)
^$(opt :_(t.t.opt (tack i.opt i.t.opt ~)), cof cof)
(flux |=(a/(unit beam) (fall a bem)))
2015-07-08 03:05:25 +03:00
::
2014-07-29 02:46:03 +04:00
++ fang :: protocol door
2015-12-20 23:50:45 +03:00
|= {cof/cafe for/mark} ^- (bolt vase)
2016-02-13 01:34:21 +03:00
(lear cof bek /[for]/mar)
2014-07-29 02:46:03 +04:00
::
2014-07-19 04:51:22 +04:00
++ fair :: hood parsing rule
2015-12-20 23:50:45 +03:00
|= bem/beam
2016-02-19 23:00:35 +03:00
?> ?=({$ud $0} r.bem) :: XX sentinel
2015-09-02 01:20:17 +03:00
=+ vez=(vang & (tope bem))
2014-07-19 04:51:22 +04:00
=< hood
2014-10-02 23:46:00 +04:00
|%
2014-07-19 04:51:22 +04:00
++ case
%+ sear
|= a/coin
?. ?=({$$ ?($da $ud $tas) *} a) ~
[~ u=(^case a)]
nuck:so
2014-07-19 04:51:22 +04:00
::
2016-02-19 23:00:35 +03:00
++ hath (sear plex (stag %conl poor)):vez :: hood path
2014-08-04 21:18:26 +04:00
++ have (sear tome ;~(pfix fas hath)) :: hood beam
2016-02-19 23:00:35 +03:00
++ hith :: static path
=> vez
(sear plex (stag %conl (more fas hasp)))
::
++ hive :: late-bound path
;~ pfix fas
%+ cook |=(a/hops a)
=> vez
;~ plug
(stag ~ gash)
;~(pose (stag ~ ;~(pfix cen porc)) (easy ~))
==
==
::
2014-07-19 04:51:22 +04:00
++ hood
2014-07-21 07:15:02 +04:00
%+ ifix [gay gay]
2014-07-19 04:51:22 +04:00
;~ plug
2014-07-21 07:15:02 +04:00
;~ pose
(ifix [;~(plug fas wut gap) gap] dem)
2014-07-21 07:15:02 +04:00
(easy zuse)
==
::
;~ pose
(ifix [;~(plug fas hep gap) gap] (most ;~(plug com gaw) hoof))
(easy ~)
==
::
;~ pose
(ifix [;~(plug fas lus gap) gap] (most ;~(plug com gaw) hoof))
(easy ~)
==
::
2014-08-02 03:39:15 +04:00
(star ;~(sfix horn gap))
(most gap hoop)
2014-07-19 04:51:22 +04:00
==
::
++ hoof
2015-12-20 23:50:45 +03:00
%+ cook |=(a/^hoof a)
2014-07-22 05:55:40 +04:00
;~ plug
sym
;~ pose
%+ stag ~
;~(plug ;~(pfix fas case) ;~(pfix ;~(plug fas sig) fed:ag))
(easy ~)
==
2014-07-19 04:51:22 +04:00
==
::
++ hoop
;~ pose
2014-08-04 21:18:26 +04:00
(stag %| ;~(pfix ;~(plug fas fas gap) have))
(stag %& tall:vez)
==
::
++ horn
=< apex
2015-12-20 23:50:45 +03:00
=| tol/?
|%
++ apex
%+ knee *^horn |. ~+
;~ pfix fas
;~ pose
2014-08-06 04:17:36 +04:00
(stag %ape ;~(pfix sig ape:read))
(stag %arg ;~(pfix buc ape:read))
(stag %alt ;~(pfix bar alt:read))
2016-02-10 02:06:30 +03:00
(stag %dep ;~(pfix hax day:read))
2014-08-06 04:17:36 +04:00
(stag %dub ;~(pfix tis dub:read))
(stag %fan ;~(pfix dot fan:read))
(stag %for ;~(pfix com for:read))
(stag %hel ;~(pfix cen day:read))
(stag %lin ;~(pfix pam lin:read))
2014-08-06 04:17:36 +04:00
(stag %man ;~(pfix tar man:read))
2015-01-13 01:40:50 +03:00
(stag %nap ;~(pfix cab day:read))
(stag %now ;~(pfix pat day:read))
2014-08-06 04:17:36 +04:00
(stag %saw ;~(pfix sem saw:read))
(stag %see ;~(pfix col see:read))
(stag %sic ;~(pfix ket sic:read))
(stag %toy ;~(sfix toy:read fas))
==
==
::
++ rail
2015-12-20 23:50:45 +03:00
|* {wid/rule tal/rule}
?. tol wid
;~(pose wid tal)
::
++ read
|% ++ ape
%+ rail
2016-02-09 05:17:17 +03:00
(ifix [sel ser] (stag %conp (most ace wide:vez)))
;~(pfix gap tall:vez)
2015-12-23 04:11:05 +03:00
::
++ alt
%+ rail (ifix [pel per] (most ace day))
;~(sfix (star day) gap duz)
::
2014-10-02 23:46:00 +04:00
++ day
%+ rail
2014-10-02 23:46:00 +04:00
apex(tol |)
;~(pfix gap apex)
::
++ dub
2014-10-02 23:46:00 +04:00
%+ rail
2015-12-23 04:11:05 +03:00
;~(plug sym ;~(pfix tis day))
;~(pfix gap ;~(plug sym day))
::
++ fan
2014-10-02 23:46:00 +04:00
%+ rail fail
2015-12-23 04:11:05 +03:00
;~(sfix (star day) gap duz)
::
++ for
%+ rail fail
=- ;~(sfix (star -) gap duz)
2016-02-19 23:00:35 +03:00
;~(pfix gap fas ;~(plug hith day))
2015-02-03 21:41:17 +03:00
::
++ lin
2015-02-03 21:41:17 +03:00
%+ rail
;~(plug (plus ;~(sfix sym pam)) day)
=+ (cook |=(a/term [a ~]) sym)
;~(pfix gap ;~(plug - day))
::
++ man
%+ rail fail
2015-12-23 04:11:05 +03:00
%+ cook ~(gas by *(map term ^horn))
=< ;~(sfix (star (sear . day)) gap duz)
|= a/^horn ^- (unit {term ^horn})
?+(-.a ~ $dub `[p.a q.a])
::
++ saw
%+ rail
2015-12-23 04:11:05 +03:00
;~(plug ;~(sfix wide:vez sem) day)
;~(pfix gap ;~(plug tall:vez day))
2014-09-24 05:03:20 +04:00
::
++ see
2014-10-02 23:46:00 +04:00
%+ rail
2016-02-19 23:00:35 +03:00
;~(plug ;~(sfix hive col) day)
;~(pfix gap ;~(plug hive day))
::
++ sic
2014-10-02 23:46:00 +04:00
%+ rail
;~(plug ;~(sfix wide:vez ket) day)
;~(pfix gap ;~(plug tall:vez day))
::
++ toy ;~(plug ;~(pose (cold | zap) (easy &)) sym)
--
::
--
2014-07-19 04:51:22 +04:00
--
::
2015-02-27 09:35:41 +03:00
++ join
2015-12-20 23:50:45 +03:00
|= {cof/cafe for/mark kas/silk kos/silk}
2015-02-27 09:35:41 +03:00
^- (bolt gage)
%. [cof kas kos]
;~ cope
;~ coax
2015-12-20 23:50:45 +03:00
|=({cof/cafe p/silk q/silk} (cope (make cof p) furl))
|=({cof/cafe p/silk q/silk} (cope (make cof q) furl))
2015-02-27 09:35:41 +03:00
==
2015-12-20 23:50:45 +03:00
|= {cof/cafe cay/cage coy/cage} ^- (bolt gage)
2015-07-06 22:48:16 +03:00
::
2015-03-12 03:37:37 +03:00
%+ cope (fang cof for)
2015-12-20 23:50:45 +03:00
|= {cof/cafe pro/vase}
2015-02-27 09:35:41 +03:00
?. (slab %grad p.pro)
2015-12-21 00:16:39 +03:00
(flaw cof leaf+"no ++grad" ~)
2015-12-21 08:05:19 +03:00
=+ gar=(slap pro [%limb %grad])
2015-07-08 01:22:32 +03:00
?@ q.gar
=+ too=((sand %tas) q.gar)
2015-12-21 00:16:39 +03:00
?~ too (flaw cof leaf+"bad mark ++grad" ~)
2015-12-29 01:01:44 +03:00
(make cof %join u.too [%$ cay] [%$ coy])
2015-07-08 01:22:32 +03:00
?. (slab %form p.gar)
2015-12-21 00:16:39 +03:00
(flaw cof leaf+"no ++form:grad" ~)
2015-12-21 08:05:19 +03:00
=+ fom=((soft @tas) q:(slap gar [%limb %form]))
2015-02-27 09:35:41 +03:00
?~ fom
2015-12-21 00:16:39 +03:00
(flaw cof leaf+"bad ++form:grad" ~)
2015-02-27 09:35:41 +03:00
?. &(=(u.fom p.cay) =(u.fom p.coy))
%+ flaw cof :_ :_ ~
2015-12-21 00:16:39 +03:00
leaf+"join on data of bad marks: {(trip p.cay)} {(trip p.coy)}"
leaf+"expected mark {(trip u.fom)}"
2015-02-27 09:35:41 +03:00
?: =(q.q.cay q.q.coy)
2016-02-01 09:16:26 +03:00
(fine cof [%& cay])
2015-02-27 09:35:41 +03:00
?. (slab %join p.gar)
2015-12-21 00:16:39 +03:00
(flaw cof leaf+"no ++join:grad" ~)
2015-02-27 09:35:41 +03:00
%+ cope
%^ maul cof
2015-12-21 08:05:19 +03:00
(slap (slap pro [%limb %grad]) [%limb %join])
2015-02-27 09:35:41 +03:00
(slop q.cay q.coy)
2015-12-20 23:50:45 +03:00
|= {cof/cafe dif/vase}
2015-02-27 09:35:41 +03:00
?@ q.dif
2016-02-01 09:16:26 +03:00
(fine cof [%& %null dif])
(fine cof [%& u.fom (slot 3 dif)])
2015-02-27 09:35:41 +03:00
==
::
2015-04-04 04:31:57 +03:00
++ mash
2015-12-20 23:50:45 +03:00
|= {cof/cafe for/mark mas/milk mos/milk}
2015-04-04 04:31:57 +03:00
^- (bolt gage)
2015-04-14 00:29:39 +03:00
%. [cof r.mas r.mos]
2015-04-04 04:31:57 +03:00
;~ cope
;~ coax
2015-12-20 23:50:45 +03:00
|=({cof/cafe p/silk q/silk} (cope (make cof p) furl))
|=({cof/cafe p/silk q/silk} (cope (make cof q) furl))
2015-04-04 04:31:57 +03:00
==
2015-12-20 23:50:45 +03:00
|= {cof/cafe cay/cage coy/cage} ^- (bolt gage)
2015-04-04 04:31:57 +03:00
%+ cope (fang cof for)
2015-12-20 23:50:45 +03:00
|= {cof/cafe pro/vase}
2015-04-04 04:31:57 +03:00
?. (slab %grad p.pro)
2015-12-21 00:16:39 +03:00
(flaw cof leaf+"no ++grad" ~)
2015-12-21 08:05:19 +03:00
=+ gar=(slap pro [%limb %grad])
2015-07-08 01:22:32 +03:00
?@ q.gar
=+ too=((sand %tas) q.gar)
2015-12-21 00:16:39 +03:00
?~ too (flaw cof leaf+"bad mark ++grad" ~)
2015-04-14 00:29:39 +03:00
%+ make cof
2016-01-07 10:08:09 +03:00
`silk`[%mash u.too [p.mas q.mas [%$ cay]] [p.mos q.mos [%$ coy]]]
2015-07-08 01:22:32 +03:00
?. (slab %form p.gar)
2015-12-21 00:16:39 +03:00
(flaw cof leaf+"no ++form:grad" ~)
2015-12-21 08:05:19 +03:00
=+ fom=((soft @tas) q:(slap gar [%limb %form]))
2015-04-04 04:31:57 +03:00
?~ fom
2015-12-21 00:16:39 +03:00
(flaw cof leaf+"bad ++form:grad" ~)
2015-04-04 04:31:57 +03:00
?. &(=(u.fom p.cay) =(u.fom p.coy))
%+ flaw cof :_ :_ ~
2015-12-21 00:16:39 +03:00
leaf+"mash on data of bad marks: {(trip p.cay)} {(trip p.coy)}"
leaf+"expected mark {(trip u.fom)}"
2015-04-04 04:31:57 +03:00
?: =(q.q.cay q.q.coy)
2015-05-26 04:17:59 +03:00
(fine cof %& cay)
2015-04-04 04:31:57 +03:00
?. (slab %mash p.gar)
(fine cof %& %null [%atom %n ~] ~)
2015-04-04 04:31:57 +03:00
%+ cope
%^ maul cof
2015-12-21 08:05:19 +03:00
(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)
2015-12-20 23:50:45 +03:00
(flux |=(dif/vase [%& u.fom dif]))
2015-04-04 04:31:57 +03:00
==
::
2014-05-31 16:52:06 +04:00
++ kale :: mutate
2015-12-20 23:50:45 +03:00
|= {cof/cafe kas/silk muy/(list (pair wing silk))}
2015-02-27 09:35:41 +03:00
^- (bolt gage)
2014-05-31 16:52:06 +04:00
%+ cope
|- ^- (bolt (list (pair wing vase)))
2015-02-13 00:03:54 +03:00
?~ muy (flue cof)
2015-05-26 04:17:59 +03:00
%+ cope (cope (make cof q.i.muy) furl)
2015-12-20 23:50:45 +03:00
|= {cof/cafe cay/cage}
2014-05-31 16:52:06 +04:00
%+ cope ^$(muy t.muy)
2015-12-20 23:50:45 +03:00
|= {cof/cafe rex/(list (pair wing vase))}
2014-05-31 16:52:06 +04:00
(fine cof [[p.i.muy q.cay] rex])
2015-12-20 23:50:45 +03:00
|= {cof/cafe yom/(list (pair wing vase))}
2014-05-31 16:52:06 +04:00
%+ cope (make cof kas)
2015-05-26 04:17:59 +03:00
%- tabl-run
2015-12-20 23:50:45 +03:00
|= {cof/cafe cay/cage}
%+ cope (keel cof q.cay yom)
2015-12-20 23:50:45 +03:00
(flux |=(vax/vase [%& p.cay vax]))
2014-05-31 16:52:06 +04:00
::
++ keel :: apply mutations
2015-12-20 23:50:45 +03:00
|= {cof/cafe suh/vase yom/(list (pair wing vase))}
^- (bolt vase)
2015-12-21 00:16:39 +03:00
%+ cool =< |.(leaf+"ford: keel {<(murn yom +)>}")
2015-12-26 13:07:50 +03:00
|= {a/wing b/span *}
2015-12-21 08:05:19 +03:00
=+ c=p:(slap suh wing+a)
2015-07-06 22:48:16 +03:00
?: (~(nest ut c) | b) ~
(some [a c b])
2014-10-02 23:46:00 +04:00
%^ maim cof
%+ slop suh
|- ^- vase
?~ yom [[%atom %n ~] ~]
(slop q.i.yom $(yom t.yom))
^- twig
:+ %keep [%& 2]~
=+ axe=3
|- ^- (list (pair wing twig))
?~ yom ~
:- [p.i.yom [%$ (peg axe 2)]]
$(yom t.yom, axe (peg axe 3))
::
2015-07-31 00:28:42 +03:00
++ lads :: possible children
|= {cof/cafe bem/beam}
^- (bolt (map knot $~))
%^ lash cof bem
|= {cof/cafe dir/knot}
%+ cope (lend cof bem(s [dir s.bem]))
(flux |=(a/arch ?~(dir.a ~ (some ~))))
2015-07-31 00:28:42 +03:00
::
2015-07-29 03:04:15 +03:00
++ laze :: find real or virtual
2015-12-20 23:50:45 +03:00
|= {cof/cafe bem/beam}
2015-07-29 03:04:15 +03:00
%^ lash cof bem
2015-12-20 23:50:45 +03:00
|= {cof/cafe for/mark}
^- (bolt (unit $~))
2015-07-29 03:04:15 +03:00
?. ((sane %tas) for) (flue cof)
=. s.bem [for s.bem]
2014-05-16 00:17:54 +04:00
%+ cope (lend cof bem)
2015-12-20 23:50:45 +03:00
|= {cof/cafe arc/arch}
(fine cof (bind fil.arc $~))
2015-07-29 03:04:15 +03:00
::
++ lace :: load real or virtual
|= {cof/cafe for/mark arg/coin bem/beam}
2015-07-29 03:04:15 +03:00
^- (bolt vase)
%+ cool |.(leaf+"ford: load {<for>} {<(tope bem)>}")
2015-07-29 03:04:15 +03:00
=. s.bem [for s.bem]
2016-01-07 01:40:40 +03:00
%+ cope (liar cof bem)
|= {cof/cafe cay/cage}
2016-01-07 01:40:40 +03:00
?. =(for p.cay)
(flaw cof leaf+"unexpected mark {<p.cay>}" ~)
2016-01-07 01:40:40 +03:00
((lake for) cof q.cay)
2014-05-07 21:42:31 +04:00
::
2015-12-21 00:16:39 +03:00
++ lake :: check+coerce
2015-12-20 23:50:45 +03:00
|= for/mark
|= {cof/cafe sam/vase}
2014-07-27 14:26:17 +04:00
^- (bolt vase)
2015-12-21 00:16:39 +03:00
%+ cool |.(leaf+"ford: check {<[for bek `@p`(mug q.sam)]>}")
?: ?=($hoon for)
=+ mas=((soft @t) q.sam)
?~ mas
(flaw cof [leaf+"ford: bad hoon: {<[for bek]>}"]~)
(fine cof [%atom %t ~] u.mas)
2015-03-12 03:37:37 +03:00
%+ cope (fang cof for)
2015-12-20 23:50:45 +03:00
|= {cof/cafe tux/vase}
2015-09-11 20:54:28 +03:00
=+ typ=p:(slot 6 tux)
2016-02-03 05:26:22 +03:00
=. typ ?+(-.typ typ $face q.typ)
2015-09-11 20:54:28 +03:00
?: (~(nest ut typ) | p.sam)
(fine cof typ q.sam)
?. (slob %grab p.tux)
2014-07-29 02:46:03 +04:00
(flaw cof [%leaf "ford: no grab: {<[for bek]>}"]~)
2015-12-21 08:05:19 +03:00
=+ gab=(slap tux [%limb %grab])
?. (slob %noun p.gab)
2014-07-29 02:46:03 +04:00
(flaw cof [%leaf "ford: no noun: {<[for bek]>}"]~)
2015-12-21 08:05:19 +03:00
%+ cope (maul cof (slap gab [%limb %noun]) [%noun q.sam])
2015-12-20 23:50:45 +03:00
|= {cof/cafe pro/vase}
2015-09-11 20:54:28 +03:00
?> (~(nest ut typ) | p.pro)
2014-10-08 23:06:40 +04:00
?: =(q.pro q.sam)
2015-09-11 20:54:28 +03:00
(fine cof typ q.pro)
2014-07-30 03:29:56 +04:00
(flaw cof [%leaf "ford: invalid content: {<[for bek]>}"]~)
2014-05-07 21:42:31 +04:00
::
2014-08-14 05:32:15 +04:00
++ lamp :: normalize version
2015-12-20 23:50:45 +03:00
|= {cof/cafe bem/beam}
2014-08-14 05:32:15 +04:00
^- (bolt beam)
?: ?=($ud -.r.bem) (fine cof bem)
=+ von=(syve [151 %noun] ~ %cw bem(s ~))
?~ von [p=cof q=[%1 [%w bem ~] ~ ~]]
(fine cof bem(r [%ud ((hard @) +.+:(need u.von))]))
2014-08-14 05:32:15 +04:00
::
2014-06-26 16:18:30 +04:00
++ lave :: validate
2015-12-20 23:50:45 +03:00
|= {cof/cafe for/mark som/*}
2014-05-12 02:48:41 +04:00
^- (bolt vase)
2015-03-12 03:37:37 +03:00
((lake for) cof [%noun som])
2014-05-12 02:48:41 +04:00
::
2015-12-26 13:07:50 +03:00
++ lane :: span infer
|= {cof/cafe typ/span gen/twig}
2014-07-26 04:29:01 +04:00
%+ (cowl cof) (mule |.((~(play ut typ) gen)))
2015-12-26 13:07:50 +03:00
|=(ref/span ref)
2014-05-07 21:42:31 +04:00
::
2015-07-29 03:04:15 +03:00
++ lash :: filter at beam
|* {cof/cafe bem/beam fun/(burg knot (unit))}
2014-07-24 03:23:53 +04:00
%+ cope (lend cof bem)
2015-12-20 23:50:45 +03:00
|=({cof/cafe arc/arch} ((some-in-map fun) cof dir.arc))
2014-07-24 03:23:53 +04:00
::
2015-07-08 04:01:17 +03:00
++ lear :: load core
2015-12-20 23:50:45 +03:00
|= {cof/cafe bem/beam} ^- (bolt vase)
(leap cof bem bem many+~)
2016-02-09 23:06:41 +03:00
::
++ leap :: XX load with path
|= {cof/cafe bem/beam bom/beam arg/coin}
2016-02-13 01:34:21 +03:00
%+ cope (lamp cof bem)
|= {cof/cafe bem/beam}
2015-07-08 04:01:17 +03:00
%+ cope (fame cof bem)
2015-12-20 23:50:45 +03:00
|= {cof/cafe bem/beam}
2016-02-09 23:06:41 +03:00
(cope (fape cof %hoon bem bom) abut:(meow bom arg))
::
2014-05-07 21:42:31 +04:00
++ lend :: load arch
2015-12-20 23:50:45 +03:00
|= {cof/cafe bem/beam}
2014-05-07 21:42:31 +04:00
^- (bolt arch)
2016-02-04 06:32:14 +03:00
=+ von=(syve [151 %noun] ~ %cy bem)
2014-12-10 01:59:31 +03:00
?~ von [p=cof q=[%1 [%y bem ~] ~ ~]]
?> ?=({$~ $arch ^} u.von)
2015-07-29 03:04:15 +03:00
=+ arc=((hard arch) q.q.u.u.von)
%+ cope (lamp cof bem)
2015-12-20 23:50:45 +03:00
|= {cof/cafe bem/beam}
2015-07-29 03:04:15 +03:00
(flag bem (fine cof arc))
2014-05-07 21:42:31 +04:00
::
2015-07-08 04:01:17 +03:00
++ liar :: load cage
2015-12-20 23:50:45 +03:00
|= {cof/cafe bem/beam}
2015-07-08 04:01:17 +03:00
^- (bolt cage)
?: =([%ud 0] r.bem)
(flaw cof [leaf+"ford: no data: {<(tope bem(s ~))>}"]~)
2016-02-04 06:32:14 +03:00
=+ von=(syve [151 %noun] ~ %cx bem)
2014-05-07 21:42:31 +04:00
?~ von
[p=cof q=[%1 [[%x bem ~] ~ ~]]]
2014-05-07 21:42:31 +04:00
?~ u.von
2015-12-21 00:16:39 +03:00
(flaw cof leaf+"file not found" (smyt (tope bem)) ~)
2015-07-08 04:01:17 +03:00
(fine cof u.u.von)
2014-05-07 21:42:31 +04:00
::
++ lily
2015-12-20 23:50:45 +03:00
|= {cof/cafe for/mark} ^- (bolt (set @tas))
%+ cope (coop (fang cof for) |=(cof/cafe (fine cof %void ~)))
2015-07-08 04:01:17 +03:00
%- flux
|= 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) ~)
2015-07-08 04:01:17 +03:00
::
2014-05-07 21:42:31 +04:00
++ lima :: load at depth
|= {cof/cafe for/mark arg/coin bem/beam}
%+ (clef %bake) [p=cof q=[%0 p=[bem `~] q=[for arg bem]]]
|= {cof/cafe for/mark arg/coin bem/beam}
2014-05-07 21:42:31 +04:00
^- (bolt (unit vase))
2015-07-29 03:04:15 +03:00
%+ cope (laze cof bem)
|= {cof/cafe mal/(map mark $~)}
2016-01-07 01:40:40 +03:00
?: (~(has by mal) for)
(cope (lace cof for arg bem) (flux some))
2016-01-02 03:19:06 +03:00
=+ opt=(silt (turn (~(tap by mal)) head)) :: XX asymptotics
2015-06-03 04:05:11 +03:00
%+ cope (lion cof for opt)
2015-12-20 23:50:45 +03:00
|= {cof/cafe wuy/(list @tas)}
2015-02-13 00:03:54 +03:00
?~ wuy (flue cof)
2015-07-29 03:04:15 +03:00
%+ cope
2016-01-07 01:40:40 +03:00
(lace cof i.wuy arg bem)
2015-12-20 23:50:45 +03:00
|= {cof/cafe hoc/vase}
2015-06-04 04:03:35 +03:00
(cope (lope cof i.wuy t.wuy hoc) (flux some))
::
2014-06-07 22:36:31 +04:00
++ lime :: load beam
|= {cof/cafe for/mark arg/coin bem/beam}
^- (bolt vase)
%+ cope (lima cof for arg bem)
2015-12-20 23:50:45 +03:00
|= {cof/cafe vux/(unit vase)}
2014-05-16 00:17:54 +04:00
?^ vux (fine cof u.vux)
2016-02-09 23:06:41 +03:00
(leap cof [-.bem /[for]/ren] bem arg)
2014-05-07 21:42:31 +04:00
::
++ link :: translate
2015-12-20 23:50:45 +03:00
|= {cof/cafe too/mark for/mark vax/vase}
2014-05-07 21:42:31 +04:00
^- (bolt vase)
2015-12-21 00:16:39 +03:00
:: %+ cool |.(leaf+"ford: link {<too>} {<for>} {<p.vax>}")
2014-05-16 00:17:54 +04:00
?: =(too for) (fine cof vax)
2014-07-10 04:48:53 +04:00
?: |(=(%noun for) =(%$ for))
2015-03-12 03:37:37 +03:00
((lake too) cof vax)
%+ cope (fang cof for)
2015-12-20 23:50:45 +03:00
|= {cof/cafe pro/vase} ^- (bolt vase)
2015-12-21 08:05:19 +03:00
?: &((slob %grow p.pro) (slob too p:(slap pro [%limb %grow])))
2014-07-29 02:46:03 +04:00
%+ cope (keel cof pro [[%& 6]~ vax]~)
2015-12-20 23:50:45 +03:00
|= {cof/cafe pox/vase}
(maim cof pox [%per [%limb %grow] [%limb too]])
2015-03-12 03:37:37 +03:00
%+ cope (fang cof too)
2015-12-20 23:50:45 +03:00
|= {cof/cafe pro/vase}
2014-07-29 02:46:03 +04:00
=+ ^= zat ^- (unit vase)
?. (slob %grab p.pro) ~
2015-12-21 08:05:19 +03:00
=+ gab=(slap pro [%limb %grab])
?. (slob for p.gab) ~
2015-12-21 08:05:19 +03:00
`(slap gab [%limb for])
2014-07-29 02:46:03 +04:00
?~ zat
(flaw cof [%leaf "ford: no link: {<[for too]>}"]~)
~| [%link-maul for too]
2014-07-29 02:46:03 +04:00
(maul cof u.zat vax)
2014-05-07 21:42:31 +04:00
::
2014-05-09 04:34:57 +04:00
++ lion :: translation search
2015-12-20 23:50:45 +03:00
|= {cof/cafe too/mark fro/(set mark)}
2016-01-02 03:19:06 +03:00
:: ~& lion+[too=too fro=(silt fro)]
^- (bolt (list mark))
=- %+ coop (gro cof too ~ ~) :: XX better grab layer
|= cof/cafe
%+ cope (fang cof too)
|= {cof/cafe vax/vase} ^- (bolt (list mark))
?. (slob %grab p.vax) (flue cof)
%+ cope
(gro cof (silt (sloe p:(slap vax [%limb %grab]))))
(flux |=(a/path (welp a /[too])))
^= gro
|= {cof/cafe tag/(set mark)}
2015-12-20 23:50:45 +03:00
=| $: war/(map mark (list mark))
pax/(list mark)
won/{p/mark q/(qeu mark)}
==
%. [cof fro]
2015-12-20 23:50:45 +03:00
|= {cof/cafe fro/(set mark)} ^- (bolt (list mark))
?: (~(has in tag) p.won)
(fine cof (flop pax))
2015-06-03 04:05:11 +03:00
=+ for=(skip (~(tap by 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)
(flue cof)
=. won ~(get to q.won)
%+ cope (lily cof p.won)
..$(pax [p.won (~(got by war) p.won)])
2014-05-07 21:42:31 +04:00
::
2014-05-16 00:17:54 +04:00
++ lope :: translation pipe
2015-12-20 23:50:45 +03:00
|= {cof/cafe for/mark yaw/(list mark) vax/vase}
2014-05-07 21:42:31 +04:00
^- (bolt vase)
2014-05-16 00:17:54 +04:00
?~ yaw (fine cof vax)
2015-03-12 03:37:37 +03:00
%+ cope (link cof i.yaw for vax)
2015-12-20 23:50:45 +03:00
|= {cof/cafe yed/vase}
2014-07-08 03:17:21 +04:00
^$(cof cof, for i.yaw, yaw t.yaw, vax yed)
2014-05-07 21:42:31 +04:00
::
2015-01-13 04:49:31 +03:00
++ mail :: cached mint
2015-12-26 13:07:50 +03:00
|= {cof/cafe sut/span gen/twig}
^- (bolt (pair span nock))
2015-06-12 00:42:05 +03:00
%+ (clef %slim) (fine cof sut gen)
2015-12-26 13:07:50 +03:00
|= {cof/cafe sut/span gen/twig}
2015-01-13 04:49:31 +03:00
=+ puz=(mule |.((~(mint ut sut) [%noun gen])))
2014-07-19 04:51:22 +04:00
?- -.puz
$| (flaw cof p.puz)
$& (fine cof p.puz)
2014-07-19 04:51:22 +04:00
==
2014-07-09 13:40:49 +04:00
::
2015-01-13 04:49:31 +03:00
++ maim :: slap
2015-12-20 23:50:45 +03:00
|= {cof/cafe vax/vase gen/twig}
2015-01-13 04:49:31 +03:00
^- (bolt vase)
%+ cope (mail cof p.vax gen)
2015-12-26 13:07:50 +03:00
|= {cof/cafe typ/span fol/nock}
%+ (coup cof) (mock [q.vax fol] (sloy syve))
2015-12-20 23:50:45 +03:00
|=(val/* `vase`[typ val])
2015-01-13 04:49:31 +03:00
::
2016-02-13 01:34:21 +03:00
++ make-norm-bek :: normalize root beak
|= {cof/cafe kas/silk}
%+ cope (lamp cof bek ~)
|=({cof/cafe byk/beak *} (make(bek byk) cof kas))
::
2014-05-07 21:42:31 +04:00
++ make :: reduce silk
2015-12-20 23:50:45 +03:00
|= {cof/cafe kas/silk}
2015-07-07 22:51:25 +03:00
:: =+ ^= pre
:: ?+ -.kas -.kas
:: ^ %cell
2016-02-20 00:20:06 +03:00
:: :: $boil [-.kas p.kas (tope q.kas)]
:: $bake [-.kas p.kas (tope q.kas)]
:: $core [-.kas (tope p.kas)]
2015-07-07 22:51:25 +03:00
:: ==
:: ~& [dyv `term`(cat 3 %make (fil 3 dyv ' ')) pre]
:: =- ~& [dyv `term`(cat 3 %made (fil 3 dyv ' ')) pre] -
:: =. dyv +(dyv)
2015-02-27 09:35:41 +03:00
^- (bolt gage)
2014-05-07 21:42:31 +04:00
?- -.kas
2014-04-30 21:04:07 +04:00
^
2014-05-16 00:17:54 +04:00
%. [cof p.kas q.kas]
2014-05-07 21:42:31 +04:00
;~ cope
;~ coax
2015-12-20 23:50:45 +03:00
|=({cof/cafe p/silk q/silk} (cope ^$(cof cof, kas p.kas) furl))
|=({cof/cafe p/silk q/silk} (cope ^$(cof cof, kas q.kas) furl))
2015-05-26 04:17:59 +03:00
== :: XX merge %tabl
2014-05-07 21:42:31 +04:00
::
2015-12-20 23:50:45 +03:00
|= {cof/cafe bor/cage heg/cage} ^- (bolt gage)
2015-05-26 04:17:59 +03:00
(faun cof (slop q.bor q.heg))
2014-05-07 21:42:31 +04:00
==
2014-04-30 21:04:07 +04:00
::
2015-12-07 03:46:01 +03:00
$$ (fine cof %& p.kas)
$alts
2016-01-16 02:32:10 +03:00
%. cof
|= cof/cafe ^- (bolt gage)
?~ p.kas (flaw cof leaf+"ford: out of options" ~)
2016-01-16 02:32:10 +03:00
(coop ^$(cof cof, kas i.p.kas) ..$(p.kas t.p.kas))
2014-05-16 00:17:54 +04:00
::
$bake
2015-05-09 03:13:10 +03:00
^- (bolt gage)
%+ cool
|.(leaf+"ford: bake {<p.kas>} {<(tope r.kas)>} {~(rend co q.kas)}")
%+ cope (lamp cof r.kas)
2015-12-20 23:50:45 +03:00
|= {cof/cafe bem/beam}
%+ cope (lime cof p.kas q.kas bem)
2015-12-20 23:50:45 +03:00
|= {cof/cafe vax/vase}
2015-05-26 04:17:59 +03:00
(fine cof `gage`[%& p.kas vax])
2015-03-11 00:11:48 +03:00
::
2015-12-07 03:46:01 +03:00
$bunt
2015-12-21 00:16:39 +03:00
%+ cool |.(leaf+"ford: bunt {<p.kas>}")
?: ?=($hoon p.kas)
(fine cof %& p.kas [%atom %t ~] '')
2015-03-12 03:37:37 +03:00
%+ cope (fang cof p.kas)
2015-12-20 23:50:45 +03:00
|= {cof/cafe tux/vase}
2015-09-11 20:54:28 +03:00
=+ [typ=p val=q]:(slot 6 tux)
2016-02-03 05:26:22 +03:00
=. typ ?+(-.typ typ $face q.typ)
2015-09-11 20:54:28 +03:00
(fine cof [%& p.kas [typ val]])
2014-04-30 21:04:07 +04:00
::
2015-12-07 03:46:01 +03:00
$call
2015-12-21 00:16:39 +03:00
:: %+ cool |.(leaf+"ford: call {<`@p`(mug kas)>}")
2014-05-16 00:17:54 +04:00
%. [cof p.kas q.kas]
2014-05-07 21:42:31 +04:00
;~ cope
;~ coax
2015-12-20 23:50:45 +03:00
|=({cof/cafe p/silk q/silk} (cope ^$(cof cof, kas p) furl))
|=({cof/cafe p/silk q/silk} ^$(cof cof, kas q))
2014-05-07 21:42:31 +04:00
==
::
2015-12-20 23:50:45 +03:00
|= {cof/cafe gat/cage sam/gage}
2015-05-26 04:17:59 +03:00
%. [cof sam]
%- tabl-run
2015-12-20 23:50:45 +03:00
|= {cof/cafe sam/cage}
2015-05-26 04:17:59 +03:00
(cope (maul cof q.gat q.sam) faun)
2014-05-07 21:42:31 +04:00
==
2014-04-30 21:04:07 +04:00
::
2015-12-07 03:46:01 +03:00
$cast
2015-12-21 00:16:39 +03:00
%+ cool |.(leaf+"ford: cast {<p.kas>}")
2014-07-27 14:26:17 +04:00
%+ cope $(kas q.kas)
2015-05-26 04:17:59 +03:00
%- tabl-run
2015-12-20 23:50:45 +03:00
|= {cof/cafe cay/cage}
2015-02-27 09:35:41 +03:00
^- (bolt gage)
2015-12-21 00:16:39 +03:00
%+ cool |.(leaf+"ford: casting {<p.cay>} to {<p.kas>}")
2015-06-03 04:05:11 +03:00
%+ cope (lion cof p.kas p.cay `~)
2015-12-20 23:50:45 +03:00
|= {cof/cafe wuy/(list @tas)}
2015-05-29 00:36:19 +03:00
%+ cope
?~ wuy
(link cof p.kas p.cay q.cay)
(lope cof i.wuy t.wuy q.cay)
2015-12-20 23:50:45 +03:00
(flux |=(vax/vase [%& p.kas vax]))
::
2015-12-07 03:46:01 +03:00
$core
2015-12-21 00:16:39 +03:00
%+ cool |.(leaf+"ford: core {<(tope p.kas)>}")
2015-12-20 23:50:45 +03:00
(cope (lear cof p.kas) (flux |=(a/vase [%& %core a])))
2015-02-27 09:35:41 +03:00
::
2015-12-07 03:46:01 +03:00
$diff
2015-12-21 00:16:39 +03:00
%+ cool |.(leaf+"ford: diff {<`@p`(mug p.kas)>} {<`@p`(mug q.kas)>}")
2015-02-27 09:35:41 +03:00
(diff cof p.kas q.kas)
2014-04-30 21:04:07 +04:00
::
2015-12-07 03:46:01 +03:00
$dude (cool p.kas $(kas q.kas))
$file
2015-12-21 00:16:39 +03:00
%+ cool |.(leaf+"ford: file {<p.kas>}")
2015-07-08 04:01:17 +03:00
%+ cope (liar cof p.kas)
2015-12-20 23:50:45 +03:00
(flux |=(cay/cage [%& cay]))
2015-05-15 21:27:44 +03:00
::
2015-12-07 03:46:01 +03:00
$flag
=+ rez=$(kas q.kas)
2015-12-07 03:46:01 +03:00
?: ?=($1 -.q.rez) rez
=- rez(p.q -)
|- ^- (set beam)
?~ 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) n.p.kas)
=+ dap=(~(get by deh.bay) n.p.kas)
2015-12-21 00:16:39 +03:00
?~ dap ~&(flag-missed+n.p.kas p.q.rez)
%- ~(uni in p.q.rez) ^- (set beam)
2015-12-07 03:46:01 +03:00
?-(-.u.dap $init p.u.dap, $sent q.u.dap, $done [[bek ~] ~ ~])
:: XX revisit ^ during dependency review
2015-12-07 03:46:01 +03:00
$join
2015-02-27 09:35:41 +03:00
%+ cool
|.
2015-12-21 00:16:39 +03:00
leaf+"ford: join {<p.kas>} {<`@p`(mug q.kas)>} {<`@p`(mug r.kas)>}"
2015-02-27 09:35:41 +03:00
(join cof p.kas q.kas r.kas)
2015-04-04 04:31:57 +03:00
::
2015-12-07 03:46:01 +03:00
$mash
2015-04-04 04:31:57 +03:00
%+ cool
|.
2015-12-21 00:16:39 +03:00
leaf+"ford: mash {<p.kas>} {<`@p`(mug q.kas)>} {<`@p`(mug r.kas)>}"
2015-04-04 04:31:57 +03:00
(mash cof p.kas q.kas r.kas)
2014-06-14 04:38:51 +04:00
::
2015-12-07 03:46:01 +03:00
$mute (kale cof p.kas q.kas)
$pact
2015-12-21 00:16:39 +03:00
%+ cool |.(leaf+"ford: pact {<`@p`(mug p.kas)>} {<`@p`(mug q.kas)>}")
2015-02-27 09:35:41 +03:00
(pact cof p.kas q.kas)
::
2015-12-07 03:46:01 +03:00
$plan (cope (abut:(meow p.kas q.kas) cof r.kas) faun)
$reef (faun cof pit)
$ride
2015-12-21 00:16:39 +03:00
%+ cool |.(leaf+"ford: build failed")
2014-07-29 02:46:03 +04:00
%+ cope $(kas q.kas)
2015-05-26 04:17:59 +03:00
%- tabl-run
2015-12-20 23:50:45 +03:00
|= {cof/cafe cay/cage}
2014-07-29 02:46:03 +04:00
%+ cope (maim cof q.cay p.kas)
2015-12-20 23:50:45 +03:00
|= {cof/cafe vax/vase}
2015-05-26 04:17:59 +03:00
(faun cof vax)
2015-02-27 09:35:41 +03:00
::
2015-12-07 03:46:01 +03:00
$tabl
%+ cope
|- ^- (bolt (list (pair gage gage)))
?~ p.kas (fine cof ~)
%. [cof p.kas]
;~ cope
;~ coax
|=({cof/cafe _p.kas} (fret ^^$(cof cof, kas p.i)))
|=({cof/cafe _p.kas} (fret ^^$(cof cof, kas q.i)))
|=({cof/cafe _p.kas} ^$(cof cof, p.kas t))
==
(flux |=({k/gage v/gage t/(list {gage gage})} [[k v] t]))
2015-07-06 22:48:16 +03:00
==
(flux |=(rex/(list (pair gage gage)) [%tabl rex]))
2014-05-31 16:52:06 +04:00
::
2015-12-07 03:46:01 +03:00
$vale
2015-12-21 00:16:39 +03:00
%+ cool |.(leaf+"ford: vale {<p.kas>} {<`@p`(mug q.kas)>}")
%+ cope (lave cof p.kas q.kas)
2015-12-20 23:50:45 +03:00
(flux |=(vax/vase `gage`[%& p.kas vax]))
2015-03-11 02:56:08 +03:00
::
2015-12-07 20:23:58 +03:00
$volt
2015-12-21 00:16:39 +03:00
%+ cool |.(leaf+"ford: volt {<p.p.kas>}")
%+ cope $(kas [%bunt p.p.kas])
2015-05-26 04:17:59 +03:00
%- tabl-run
2015-12-20 23:50:45 +03:00
|= {cof/cafe cay/cage}
2015-03-11 02:56:08 +03:00
^- (bolt gage)
(fine cof [%& p.p.kas p.q.cay q.p.kas])
2014-04-30 21:04:07 +04:00
==
::
2015-01-13 04:49:31 +03:00
++ malt :: cached slit
2015-12-26 13:07:50 +03:00
|= {cof/cafe gat/span sam/span}
^- (bolt span)
2015-01-13 04:49:31 +03:00
%+ (clef %slit) (fine cof gat sam)
2015-12-26 13:07:50 +03:00
|= {cof/cafe gat/span sam/span}
2015-10-22 01:02:00 +03:00
%+ cool |.(%.(%have ~(dunk ut sam)))
%+ cool |.(%.(%want ~(dunk ut (~(peek ut gat) %free 6))))
2015-01-13 04:49:31 +03:00
=+ top=(mule |.((slit gat sam)))
?- -.top
$| (flaw cof p.top)
$& (fine cof p.top)
2014-05-09 04:34:57 +04:00
==
2014-04-30 21:04:07 +04:00
::
2015-01-13 04:49:31 +03:00
++ maul :: slam
2015-12-20 23:50:45 +03:00
|= {cof/cafe gat/vase sam/vase}
2015-01-13 04:49:31 +03:00
^- (bolt vase)
%+ cope (malt cof p.gat p.sam)
2015-12-26 13:07:50 +03:00
|= {cof/cafe typ/span}
%+ (coup cof) (mong [q.gat q.sam] (sloy syve))
2015-12-20 23:50:45 +03:00
|=(val/* `vase`[typ val])
2015-01-13 04:49:31 +03:00
::
2014-07-19 04:51:22 +04:00
++ meow :: assemble
|= {how/beam arg/coin}
2015-12-20 23:50:45 +03:00
=| $: rop/(map term (pair hoof twig)) :: structures
bil/(map term (pair hoof twig)) :: libraries
boy/(list twig) :: body stack
lit/? :: drop arguments
2014-07-19 04:51:22 +04:00
==
~% %meow ..meow ~
2014-07-19 04:51:22 +04:00
|%
2014-07-27 14:26:17 +04:00
++ able :: assemble preamble
^- twig
:+ %per
?:(=(~ rop) [%$ 1] [%core (~(run by rop) |=({^ a/twig} [%ash a]))])
?:(=(~ bil) [%$ 1] [%core (~(run by bil) |=({^ a/twig} [%ash a]))])
2014-07-27 14:26:17 +04:00
::
2014-07-19 04:51:22 +04:00
++ abut :: generate
2015-12-20 23:50:45 +03:00
|= {cof/cafe hyd/hood}
^- (bolt vase)
2014-07-19 04:51:22 +04:00
%+ cope (apex cof hyd)
2015-12-20 23:50:45 +03:00
|= {cof/cafe sel/_..abut}
2014-07-26 04:29:01 +04:00
=. ..abut sel
%+ cope (maim cof pit able)
2015-12-20 23:50:45 +03:00
|= {cof/cafe bax/vase}
%+ cope (chap cof bax [%fan fan.hyd])
|= {cof/cafe mar/mark gox/vase}
%+ cope (maim cof (slop gox bax) [%tow (flop boy)])
2015-12-20 23:50:45 +03:00
|= {cof/cafe fin/vase}
2014-10-02 23:46:00 +04:00
(fine cof fin)
2014-07-26 04:29:01 +04:00
:: ~> %slog.[0 ~(duck ut p.q.cay)]
2014-07-19 04:51:22 +04:00
::
++ apex :: build to body
2015-12-20 23:50:45 +03:00
|= {cof/cafe hyd/hood}
2015-12-15 01:21:10 +03:00
^- (bolt _..apex)
2014-07-19 04:51:22 +04:00
%+ cope (body cof src.hyd)
2015-12-20 23:50:45 +03:00
|= {cof/cafe sel/_..apex}
2014-07-19 04:51:22 +04:00
=. ..apex sel
%+ cope (neck cof lib.hyd)
2015-12-20 23:50:45 +03:00
|= {cof/cafe sel/_..apex}
2014-07-26 04:29:01 +04:00
=. ..apex sel(boy boy)
%+ cope (head cof sur.hyd)
2015-12-20 23:50:45 +03:00
|= {cof/cafe sel/_..apex}
2014-07-19 04:51:22 +04:00
(fine cof sel)
::
++ body :: produce functions
2015-12-20 23:50:45 +03:00
|= {cof/cafe src/(list hoop)}
2015-12-15 01:21:10 +03:00
^- (bolt _..body)
2014-07-19 04:51:22 +04:00
?~ src (fine cof ..body)
%+ cope (wilt cof i.src)
2015-12-20 23:50:45 +03:00
|= {cof/cafe sel/_..body}
2015-06-03 04:05:11 +03:00
^$(src t.src, ..body sel, cof cof)
2014-07-19 04:51:22 +04:00
::
++ chad :: atomic list
2015-12-20 23:50:45 +03:00
|= {cof/cafe bax/vase doe/term hon/horn}
2014-07-24 03:23:53 +04:00
^- (bolt vase)
2015-07-29 03:04:15 +03:00
%+ cope (lash cof how (flux (slat doe)))
|= {cof/cafe yep/(map knot @)}
=+ ^= poy ^- (list (pair knot @))
%+ sort (~(tap by yep) ~)
2015-12-20 23:50:45 +03:00
|=({{* a/@} {* b/@}} (lth a b))
%+ cope
2015-12-07 03:46:01 +03:00
|- ^- (bolt (list (pair @ vase)))
2015-02-13 00:03:54 +03:00
?~ poy (flue cof)
%+ cope $(poy t.poy)
2015-12-20 23:50:45 +03:00
|= {cof/cafe nex/(list (pair @ vase))}
%+ cope (chap(s.how [p.i.poy s.how]) cof bax hon)
(flux |=({mar/mark elt/vase} [[q.i.poy elt] nex]))
2015-07-29 03:04:15 +03:00
%- flux
2015-12-20 23:50:45 +03:00
|= yal/(list (pair @ vase)) ^- vase
?~ yal [[%atom %n `~] 0]
(slop (slop [[%atom doe ~] p.i.yal] q.i.yal) $(yal t.yal))
::
++ chai :: atomic map
2015-12-20 23:50:45 +03:00
|= {cof/cafe bax/vase hon/horn}
^- (bolt vase)
2014-07-24 03:23:53 +04:00
%+ cope
%+ cope (lads cof how)
2015-07-31 00:28:42 +03:00
%- some-in-map
|= {cof/cafe dir/knot}
2015-07-29 03:04:15 +03:00
=+ nod=(chap(s.how [dir s.how]) cof bax hon)
2015-12-07 03:46:01 +03:00
?: ?=($2 -.q.nod)
2015-07-29 03:04:15 +03:00
(flue cof)
(cope nod (flux some))
%- flux
|= doy/(map @ cage) ^- vase
?~ doy [[%atom %n `0] 0]
2014-07-24 03:23:53 +04:00
%+ slop
(slop [[%atom %ta ~] p.n.doy] q.q.n.doy)
2014-07-24 03:23:53 +04:00
(slop $(doy l.doy) $(doy r.doy))
::
++ chap :: produce resources
2015-12-20 23:50:45 +03:00
|= {cof/cafe bax/vase hon/horn}
^- (bolt cage)
2014-07-24 03:23:53 +04:00
?- -.hon
$ape (cope (maim cof bax p.hon) (flux |=(a/vase [%noun a])))
2015-12-07 03:46:01 +03:00
$arg
%+ cope (maim cof bax p.hon)
2015-12-20 23:50:45 +03:00
|= {cof/cafe gat/vase}
%+ cope (maim cof !>(~) ((jock |) arg))
|= {cof/cafe val/vase}
%+ cope (maul cof gat (slop !>(how) val))
(flux |=(a/vase noun+a))
::
$alt
%. cof
|= cof/cafe ^- (bolt cage)
?~ p.hon (flaw cof leaf+"ford: out of options" ~)
(coop ^$(cof cof, hon i.p.hon) ..$(p.hon t.p.hon))
2016-02-10 02:06:30 +03:00
::
$dep
2016-02-10 02:06:30 +03:00
=+ [dep bot]=(clad $(hon p.hon)) :: XX review
%+ cope bot
%- flux
|= {mark vax/vase}
[%noun (slop [atom+['uvH' ~] dep] vax)]
2014-07-24 03:23:53 +04:00
::
2015-12-07 03:46:01 +03:00
$dub
%+ cope $(hon q.hon)
2016-02-10 02:06:30 +03:00
%- flux
|= {mar/mark vax/vase}
2016-02-10 02:06:30 +03:00
[mar [%face p.hon p.vax] q.vax]
::
2015-12-07 03:46:01 +03:00
$fan
%+ cope
%+ cope
|- ^- (bolt (list vase))
?~ p.hon (flue cof)
%+ cope ^$(cof cof, hon i.p.hon)
|= {cof/cafe mar/mark vax/vase}
%+ cope ^$(cof cof, p.hon t.p.hon)
(flux |=(tev/(list vase) [vax tev]))
|= {cof/cafe tev/(list vase)}
%+ fine cof
|- ^- vase
?~ tev [[%atom %n `~] 0]
(slop i.tev $(tev t.tev))
(flux |=(a/vase noun+a))
2014-07-24 03:23:53 +04:00
::
$for
=+ opt=|.(>(turn p.hon |=({a/path ^} a))<)
|- ^- (bolt cage)
?~ p.hon (flaw cof leaf+"ford: no match" >(tope 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)
::
$hel $(hon p.hon, lit |)
$lin
%+ cope $(hon q.hon)
|= {cof/cafe cay/cage} ^- (bolt cage)
?~ p.hon (fine cof cay)
%+ cope $(p.hon t.p.hon)
|= {cof/cafe cay/cage}
(cope (make cof %cast i.p.hon $+cay) furl)
::
2015-12-07 03:46:01 +03:00
$man
%+ cope
|- ^- (bolt vase)
?~ p.hon (fine cof [[%atom %n `~] 0])
%+ cope $(p.hon l.p.hon)
|= {cof/cafe lef/vase}
%+ cope ^$(cof cof, p.hon r.p.hon)
|= {cof/cafe rig/vase}
%+ cope ^^^$(cof cof, hon q.n.p.hon)
|= {cof/cafe mar/mark vax/vase}
%+ fine cof
%+ slop
(slop [[%atom %tas ~] p.n.p.hon] vax)
(slop lef rig)
(flux |=(a/vase noun+a))
::
$now
%+ cope (chad cof bax %da p.hon)
(flux |=(a/vase noun+a))
::
$nap
%+ cope (chai cof bax p.hon)
(flux |=(a/vase noun+a))
2015-06-24 01:59:48 +03:00
::
2015-12-07 03:46:01 +03:00
$saw
2014-07-24 03:23:53 +04:00
%+ cope $(hon q.hon)
|= {cof/cafe mar/mark sam/vase}
2014-07-24 03:23:53 +04:00
%+ cope (maim cof bax p.hon)
2015-12-20 23:50:45 +03:00
|= {cof/cafe gat/vase}
%+ cope (maul cof gat sam)
(flux |=(a/vase noun+a))
::
$see
2016-02-19 23:00:35 +03:00
=+ vez=(vang & (tope how))
=+ tuz=(posh:vez p.hon)
?~ tuz (flaw cof leaf+"bad tusk: {<p.hon>}" ~)
=+ pax=(plex:vez %conl u.tuz)
?~ pax (flaw cof leaf+"bad path: {<u.tuz>}" ~)
=+ bem=(tome u.pax)
?~ bem (flaw cof leaf+"bad beam: {<u.pax>}" ~)
$(hon q.hon, how u.bem)
2014-07-24 03:23:53 +04:00
::
2015-12-07 03:46:01 +03:00
$sic
2014-07-24 03:23:53 +04:00
%+ cope $(hon q.hon)
|= {cof/cafe mar/mark vax/vase}
2016-02-09 05:17:17 +03:00
%+ cope (maim cof bax [%bunt p.hon])
2015-12-20 23:50:45 +03:00
|= {cof/cafe tug/vase}
?. (~(nest ut p.tug) | p.vax)
(flaw cof [%leaf "type error: {<p.hon>} {<q.hon>}"]~)
(fine cof [mar p.tug q.vax])
::
$toy
?: p.hon
=. arg ?.(lit arg many+~)
(cope (make cof %bake q.hon arg how) furl)
%+ cool |.(leaf+"ford: hook {<q.hon>} {<(tope how)>}")
%+ cope (fade cof %hoon how)
|= {cof/cafe hyd/hood}
%+ cope (abut:(meow how arg) cof hyd)
;~(cope (lake q.hon) (flux |=(a/vase [q.hon a])))
2015-07-31 00:28:42 +03:00
==
::
2014-07-29 02:46:03 +04:00
++ head :: consume structures
2015-12-20 23:50:45 +03:00
|= {cof/cafe bir/(list hoof)}
2015-12-15 01:21:10 +03:00
^- (bolt _..head)
?~ bir
2014-07-26 04:29:01 +04:00
(fine cof ..head)
=+ byf=(~(get by rop) p.i.bir)
2014-07-19 04:51:22 +04:00
?^ byf
?. =(`hoof`i.bir `hoof`p.u.byf)
(flaw cof [%leaf "structure mismatch: {<~[p.u.byf i.bir]>}"]~)
2014-07-19 04:51:22 +04:00
$(bir t.bir)
%+ cope (fame cof (hone %sur i.bir))
2015-12-20 23:50:45 +03:00
|= {cof/cafe bem/beam}
2015-07-08 03:05:25 +03:00
%+ cope (fade cof %hoon bem)
2015-12-20 23:50:45 +03:00
|= {cof/cafe hyd/hood}
2015-07-08 03:05:25 +03:00
%+ cope (apex(how bem, boy ~) cof hyd)
2015-12-20 23:50:45 +03:00
|= {cof/cafe sel/_..head}
2014-07-19 04:51:22 +04:00
=. ..head
%= sel
boy boy
2015-07-08 03:05:25 +03:00
how how
rop %+ ~(put by (~(uni by rop) rop.sel))
p.i.bir
[i.bir [%tow (flop boy.sel)]]
2014-07-19 04:51:22 +04:00
==
2015-07-08 03:05:25 +03:00
^^^$(cof cof, bir t.bir)
2014-07-19 04:51:22 +04:00
::
++ hone :: plant hoof
2015-12-20 23:50:45 +03:00
|= {way/@tas huf/hoof}
2014-07-19 04:51:22 +04:00
^- beam
2014-07-22 05:55:40 +04:00
?~ q.huf
how(s ~[p.huf way])
[[q.u.q.huf q.how p.u.q.huf] ~[p.huf way]]
2014-07-19 04:51:22 +04:00
::
++ neck :: consume libraries
2015-12-20 23:50:45 +03:00
|= {cof/cafe bir/(list hoof)}
2015-12-15 01:21:10 +03:00
^- (bolt _..neck)
2014-07-19 04:51:22 +04:00
?~ bir (fine cof ..neck)
2014-07-22 05:55:40 +04:00
=+ byf=(~(get by bil) p.i.bir)
2014-07-19 04:51:22 +04:00
?^ byf
?. =(`hoof`i.bir `hoof`p.u.byf)
2014-07-22 05:55:40 +04:00
(flaw cof [%leaf "library mismatch: {<~[p.u.byf i.bir]>}"]~)
2014-07-19 04:51:22 +04:00
$(bir t.bir)
2015-07-08 03:05:25 +03:00
%+ cope (fame cof (hone %lib i.bir))
2015-12-20 23:50:45 +03:00
|= {cof/cafe bem/beam}
2015-07-08 03:05:25 +03:00
%+ cope (fade cof %hoon bem)
2015-12-20 23:50:45 +03:00
|= {cof/cafe hyd/hood}
%+ cope (apex(how bem, boy ~) cof hyd)
2015-12-20 23:50:45 +03:00
|= {cof/cafe sel/_..neck}
2014-10-02 23:46:00 +04:00
=. ..neck
2014-07-19 04:51:22 +04:00
%= sel
2015-07-08 03:05:25 +03:00
how how
bil (~(put by bil) p.i.bir [i.bir [%tow (flop boy.sel)]])
2014-07-19 04:51:22 +04:00
==
2015-07-08 03:05:25 +03:00
^^^$(cof cof, bir t.bir)
2014-07-19 04:51:22 +04:00
::
++ wilt :: process body entry
2015-12-20 23:50:45 +03:00
|= {cof/cafe hop/hoop}
2015-12-15 01:21:10 +03:00
^- (bolt _..wilt)
2014-07-24 03:23:53 +04:00
?- -.hop
$& (fine cof ..wilt(boy [p.hop boy]))
$|
=. r.p.hop ?:(?=({$ud $0} r.p.hop) r.how r.p.hop)
2015-12-21 00:16:39 +03:00
%+ cool |.(leaf+"ford: wilt {<[(tope p.hop)]>}")
2014-07-24 03:23:53 +04:00
%+ cope (lend cof p.hop)
2015-12-20 23:50:45 +03:00
|= {cof/cafe arc/arch}
2015-09-06 04:14:00 +03:00
?: (~(has by dir.arc) %hoon)
2014-08-04 21:18:26 +04:00
%+ cope (fade cof %hoon p.hop)
2015-12-20 23:50:45 +03:00
|= {cof/cafe hyd/hood}
2014-07-24 03:23:53 +04:00
%+ cope (apex(boy ~) cof hyd)
(flux |=(sel/_..wilt sel(boy [[%tow boy.sel] boy])))
=+ [all=(lark (slat %tas) arc) sel=..wilt]
2014-07-24 03:23:53 +04:00
%+ cope
2015-12-15 01:21:10 +03:00
|- ^- (bolt (pair (map term foot) _..wilt))
?~ all (fine cof ~ ..wilt)
2014-07-24 03:23:53 +04:00
%+ cope $(all l.all)
2015-12-20 23:50:45 +03:00
|= {cof/cafe lef/(map term foot) sel/_..wilt}
%+ cope ^$(all r.all, cof cof, sel sel)
2015-12-20 23:50:45 +03:00
|= {cof/cafe rig/(map term foot) sel/_..wilt}
2014-10-02 23:46:00 +04:00
%+ cope
%= ^^^^$
cof cof
..wilt sel(boy ~)
s.p.hop [p.n.all s.p.hop]
==
2015-12-20 23:50:45 +03:00
|= {cof/cafe sel/_..wilt}
2014-07-24 03:23:53 +04:00
%+ fine cof
[`(map term foot)`[[p.n.all [%ash [%tow boy.sel]]] lef rig] sel]
2015-12-20 23:50:45 +03:00
|= {cof/cafe mav/(map term foot) sel/_..wilt}
2014-07-24 03:23:53 +04:00
?~ mav
(flaw cof [%leaf "source missing: {<(tope p.hop)>}"]~)
(fine cof sel(boy [[%core mav] boy]))
2014-07-19 04:51:22 +04:00
==
--
::
2015-02-27 09:35:41 +03:00
++ pact :: patch
2015-12-20 23:50:45 +03:00
|= {cof/cafe kas/silk kos/silk}
2015-02-27 09:35:41 +03:00
^- (bolt gage)
%. [cof kas kos]
;~ cope
;~ coax
2015-12-20 23:50:45 +03:00
|=({cof/cafe p/silk q/silk} (cope (make cof p) furl))
|=({cof/cafe p/silk q/silk} (cope (make cof q) furl))
2015-02-27 09:35:41 +03:00
==
2015-12-20 23:50:45 +03:00
|= {cof/cafe cay/cage coy/cage} ^- (bolt gage)
?: ?=($hoon p.cay)
2015-12-07 03:46:01 +03:00
?. ?=($txt-diff p.coy)
(flaw cof leaf+"{<p.cay>} mark with bad diff type: {<p.coy>}" ~)
2015-12-07 20:23:58 +03:00
=+ txt=((soft @t) q.q.cay)
?~ txt
2015-12-21 00:16:39 +03:00
(flaw cof leaf+"{<p.cay>} mark on bad data" ~)
=+ dif=((soft (urge cord)) q.q.coy)
?~ dif
2015-12-21 00:16:39 +03:00
=- (flaw cof leaf+"{<p.cay>} data with bad diff" -)
2015-07-06 22:48:16 +03:00
[>type=p.q.coy< >want=p:!>(*(urge cord))< ~]
2016-01-14 00:19:09 +03:00
=+ pac=(role (lurk (lore u.txt) u.dif))
2016-02-01 09:16:26 +03:00
(fine cof `gage`[%& p.cay [%atom %t ~] (end 3 (dec (met 3 pac)) pac)])
2015-07-06 22:48:16 +03:00
::
2015-03-12 03:37:37 +03:00
%+ cope (fang cof p.cay)
2015-12-20 23:50:45 +03:00
|= {cof/cafe pro/vase}
2015-02-27 09:35:41 +03:00
?. (slab %grad p.pro)
2015-12-21 00:16:39 +03:00
(flaw cof leaf+"no ++grad" ~)
2015-12-21 08:05:19 +03:00
=+ gar=(slap pro [%limb %grad])
2015-07-08 01:22:32 +03:00
?@ q.gar
=+ for=((sand %tas) q.gar)
2015-12-21 00:16:39 +03:00
?~ for (flaw cof leaf+"bad mark ++grad" ~)
2016-01-07 04:47:03 +03:00
(make cof `silk`[%cast p.cay %pact [%cast u.for %$ cay] %$ coy])
2015-07-08 01:22:32 +03:00
?. (slab %form p.gar)
2015-12-21 00:16:39 +03:00
(flaw cof leaf+"no ++form:grad" ~)
2015-12-21 08:05:19 +03:00
=+ for=((soft @tas) q:(slap gar [%limb %form]))
2015-02-27 09:35:41 +03:00
?~ for
2015-12-21 00:16:39 +03:00
(flaw cof leaf+"bad ++form:grad" ~)
2015-02-27 09:35:41 +03:00
?. =(u.for p.coy)
%+ flaw cof :_ ~
2015-12-21 00:16:39 +03:00
=< leaf+"pact on data with wrong form: {-} {+<} {+>}"
2015-02-27 09:35:41 +03:00
[(trip p.cay) (trip u.for) (trip p.coy)]
?. (slab %pact p.gar)
2015-12-21 00:16:39 +03:00
(flaw cof leaf+"no ++pact:grad" ~)
2015-02-27 09:35:41 +03:00
%+ cope (keel cof pro [[%& 6]~ q.cay]~)
2015-12-20 23:50:45 +03:00
|= {cof/cafe pox/vase}
2015-02-27 09:35:41 +03:00
%+ cope
%^ maul cof
2015-12-21 08:05:19 +03:00
(slap (slap pox [%limb %grad]) [%limb %pact])
2015-02-27 09:35:41 +03:00
q.coy
2015-12-20 23:50:45 +03:00
(flux |=(pat/vase [%& p.cay pat]))
2015-02-27 09:35:41 +03:00
==
::
2014-04-30 21:04:07 +04:00
++ resp
2015-12-20 23:50:45 +03:00
|= {tik/@ud rot/riot}
2014-04-30 21:04:07 +04:00
^+ ..zo
?> (~(has by q.kig) tik)
2015-12-20 23:50:45 +03:00
=+ `{ren/care bem/beam}`(~(got by q.kig) tik)
2014-04-30 21:04:07 +04:00
?~ rot
2016-02-10 01:38:23 +03:00
=^ dep deh.bay (daze ~ deh.bay) :: dependencies?
2015-02-19 00:35:22 +03:00
amok:(expo [%made dep %| (smyt ren (tope bem)) ~])
2015-03-31 01:12:18 +03:00
=+ (cat 3 'c' ren)
exec(q.kig (~(del by q.kig) tik), keg (~(put by keg) [- bem] r.u.rot))
::
++ syve
^- sley
2016-02-04 00:33:43 +03:00
|= {ref/* sec/(unit (set monk)) tem/term bem/beam}
^- (unit (unit cage))
2016-02-04 03:14:35 +03:00
?> =(%151 -.ref)
2016-02-12 00:37:56 +03:00
%- %- lift |= (unit cage) :: ignore block
%+ biff +<
|= cay/cage ^- (unit cage)
?. -:(nets:wa +.ref `span`p.q.cay) :: error if bad type
~
`cay
2015-03-31 01:12:18 +03:00
^- (unit (unit cage))
=+ (~(get by keg) tem bem)
?^ -
2016-02-04 00:33:43 +03:00
(some -)
2015-04-14 00:29:39 +03:00
(ska +<.$)
2014-04-30 21:04:07 +04:00
--
--
2015-01-15 22:25:22 +03:00
::
2014-04-30 21:04:07 +04:00
--
2014-04-23 21:02:36 +04:00
. ==
=| axle
=* lex -
|= {now/@da eny/@ ski/sley} :: activate
2014-04-23 21:02:36 +04:00
^? :: opaque core
~% %ford-d ..is ~
2014-04-23 21:02:36 +04:00
|% ::
2014-06-03 09:07:32 +04:00
++ call :: request
2015-12-20 23:50:45 +03:00
|= {hen/duct hic/(hypo (hobo kiss))}
2015-12-07 20:23:58 +03:00
^+ [p=*(list move) q=..^$]
2015-12-07 03:46:01 +03:00
=> .(q.hic ?.(?=($soft -.q.hic) q.hic ((hard kiss) p.q.hic)))
?: ?=($wegh -.q.hic)
2015-05-07 05:25:41 +03:00
:_ ..^$ :_ ~
:^ hen %give %mass
2015-05-13 00:18:34 +03:00
:- %ford
2015-05-07 05:25:41 +03:00
:- %|
2015-12-20 23:50:45 +03:00
%- |= 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
2015-12-20 23:50:45 +03:00
[%& (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))
2015-12-07 20:23:58 +03:00
|= {@ baby}
:~ =< cache+[%| (turn `(list term)`/hood/bake/slit/slim/slap/slam .)]
2015-12-29 01:01:44 +03:00
=- |=(a/term [a %& (~(get ja dep) a)])
2015-12-20 23:50:45 +03:00
=< `dep/(jar term *)`(~(rep by jav) .)
|=({{* a/{term *}} b/(jar term *)} (~(add ja b) -.a +.a))
::
2015-12-21 00:16:39 +03:00
=< depends+[%| (turn `(list term)`/init/sent/done .)]
2015-12-29 01:01:44 +03:00
=- |=(a/term [a %& (~(get ja dep) a)])
2015-12-20 23:50:45 +03:00
=< `dep/(jar term *)`(~(rep by deh) .)
|=({{@ a/{term *}} b/(jar term *)} (~(add ja b) -.a +.a))
::
2015-12-29 01:01:44 +03:00
tasks+[%& dym tad]
2015-05-07 05:25:41 +03:00
==
2015-07-10 21:49:03 +03:00
=+ our=p.q.hic
2014-05-14 04:04:23 +04:00
=+ ^= bay ^- baby
2014-05-22 21:39:51 +04:00
=+ buy=(~(get by pol.lex) our)
2014-05-14 04:04:23 +04:00
?~(buy *baby u.buy)
=^ mos bay
2015-07-10 21:49:03 +03:00
?- -.q.hic
$wipe ~&(%ford-cache-wiped [~ bay(jav ~)])
2015-12-07 20:23:58 +03:00
$wasp
2015-07-10 21:49:03 +03:00
abet:(~(awap za [our hen [now eny ski] ~] bay) q.q.hic)
2015-12-07 20:23:58 +03:00
$exec
2015-07-10 21:49:03 +03:00
?~ q.q.hic
abet:~(apax za [our hen [now eny ski] ~] bay)
abet:(~(apex za [our hen [now eny ski] ~] bay) u.q.q.hic)
==
2014-05-22 21:39:51 +04:00
[mos ..^$(pol (~(put by pol) our bay))]
::
2014-04-23 21:02:36 +04:00
++ doze
2015-12-20 23:50:45 +03:00
|= {now/@da hen/duct}
2015-12-07 20:23:58 +03:00
^- (unit @da)
2014-04-23 21:02:36 +04:00
~
::
2014-07-09 07:00:30 +04:00
++ load :: highly forgiving
2016-02-19 23:00:35 +03:00
:: |=(old/axle ..^$(+>- old))
2015-02-19 00:35:22 +03:00
::=. 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)]
2016-02-19 23:00:35 +03:00
|= old/*
=+ lox=((soft axle) old)
^+ ..^$
?~ lox
~& %ford-reset
..^$
..^$(+>- u.lox)
2014-04-23 21:02:36 +04:00
::
++ scry
2015-12-20 23:50:45 +03:00
|= {fur/(unit (set monk)) ren/@tas who/ship syd/desk lot/coin tyl/path}
2015-02-27 09:35:41 +03:00
^- (unit (unit cage))
2015-01-15 06:07:26 +03:00
[~ ~]
2014-04-23 21:02:36 +04:00
::
2015-12-21 00:16:39 +03:00
++ stay :: save w+o cache
2015-12-20 23:50:45 +03:00
`axle`+>-.$(pol (~(run by pol) |=(a/baby [tad.a dym.a deh.a ~])))
2014-07-09 07:00:30 +04:00
::
2014-06-03 09:07:32 +04:00
++ take :: response
2015-12-20 23:50:45 +03:00
|= {tea/wire hen/duct hin/(hypo sign)}
2015-12-07 20:23:58 +03:00
^+ [p=*(list move) q=..^$]
?> ?=({@ @ *} tea)
2015-04-29 03:43:23 +03:00
=+ our=(slav %p i.tea)
2015-01-08 04:49:57 +03:00
=+ bay=(~(got by pol.lex) our)
2014-06-03 09:07:32 +04:00
=^ mos bay
2015-04-29 03:43:23 +03:00
=+ dep=(slaw %uv i.t.tea)
?^ dep
2015-07-10 21:49:03 +03:00
=+ bem=(need (tome t.t.tea))
abet:(~(axun za [our hen [now eny ski] ~] bay) tea u.dep bem q.hin)
?> ?=({@ $~} t.t.tea)
2015-04-29 03:43:23 +03:00
=+ :* num=(slav %ud i.t.tea)
tik=(slav %ud i.t.t.tea)
2015-02-19 00:35:22 +03:00
==
2015-07-10 21:49:03 +03:00
abet:(~(axon za [our hen [now eny ski] ~] bay) num tik q.hin)
2014-06-03 09:07:32 +04:00
[mos ..^$(pol (~(put by pol) our bay))]
2014-04-23 21:02:36 +04:00
--