mirror of
https://github.com/ilyakooo0/urbit.git
synced 2024-12-13 20:04:35 +03:00
758 lines
30 KiB
Plaintext
758 lines
30 KiB
Plaintext
:: :: ::
|
|
:::: /hook/core/dojo/app :: ::::
|
|
:: :: ::
|
|
/? 314 :: arvo kelvin
|
|
/- *sole :: console structures
|
|
/+ sole :: console library
|
|
:: :: ::
|
|
:::: :: ::::
|
|
!: :: ::
|
|
=> |% :: external structures
|
|
++ house :: all state
|
|
$: hoc=(map bone session) :: conversations
|
|
== ::
|
|
++ session :: per conversation
|
|
$: say=sole-share :: command-line state
|
|
syd=desk :: active desk
|
|
luc=(unit case) :: special case
|
|
poy=(unit dojo-project) :: working
|
|
var=(map term cage) :: variable state
|
|
old=(set term) :: used TLVs
|
|
== ::
|
|
++ dojo-command ::
|
|
$% [%flat p=path q=dojo-source] :: noun to unix atom
|
|
[%pill p=path q=dojo-source] :: noun to unix pill
|
|
:: [%tree p=path q=dojo-source] :: noun to unix tree
|
|
[%poke p=goal q=dojo-source] :: make and poke
|
|
[%show p=dojo-source] :: print
|
|
[%verb p=term q=dojo-source] :: store variable
|
|
== ::
|
|
++ dojo-source :: construction node
|
|
$: p=@ud :: assembly index
|
|
q=dojo-build :: general build
|
|
== ::
|
|
++ dojo-build :: one ford step
|
|
$% [%ex p=twig] :: hoon expression
|
|
[%di p=dojo-model] :: dialog
|
|
[%dv p=path] :: gate from source
|
|
[%fi p=dojo-filter q=dojo-source] :: filter
|
|
[%ge p=dojo-model] :: generator
|
|
[%sc p=dojo-model] :: script
|
|
[%tu p=(list dojo-source)] :: tuple
|
|
[%va p=term] :: dojo variable
|
|
== ::
|
|
++ dojo-filter :: pipeline filter
|
|
$% [%a p=twig] :: function gate
|
|
[%b p=mark] :: simple transmute
|
|
[%c p=dojo-model] :: formal filter
|
|
== ::
|
|
++ dojo-model :: data construction
|
|
$: p=dojo-server :: core source
|
|
q=dojo-config :: configuration
|
|
== ::
|
|
++ dojo-server :: numbered device
|
|
$: p=@ud :: assembly index
|
|
q=path :: gate path
|
|
== ::
|
|
++ dojo-config :: configuration
|
|
$: p=(list dojo-source) :: by order
|
|
q=(map term (unit dojo-source)) :: by keyword
|
|
== ::
|
|
++ dojo-project :: construction state
|
|
$: mad=dojo-command :: operation
|
|
num=@ud :: number of tasks
|
|
cud=(unit dojo-source) :: now solving
|
|
pux=(unit path) :: ford working
|
|
pro=(unit vase) :: prompting loop
|
|
per=(unit sole-edit) :: pending reverse
|
|
job=(map ,@ud dojo-build) :: problems
|
|
rez=(map ,@ud cage) :: results
|
|
== ::
|
|
++ bead ,[p=(set beam) q=cage] :: computed result
|
|
++ goal ,[p=ship q=term] :: flat application
|
|
++ clap :: action, user
|
|
$% [%peer p=path] :: subscribe
|
|
[%poke p=term q=*] :: apply
|
|
[%pull ~] :: unsubscribe
|
|
== ::
|
|
++ club :: action, system
|
|
$% [%peer p=path] :: subscribe
|
|
[%poke p=cage] :: apply
|
|
[%pull ~] :: unsubscribe
|
|
== ::
|
|
++ card :: general card
|
|
$% [%diff %sole-effect sole-effect] ::
|
|
[%send wire [ship term] clap] ::
|
|
[%exec wire @p beak (unit silk)] ::
|
|
[%deal wire sock term club] ::
|
|
== ::
|
|
++ move (pair bone card) :: user-level move
|
|
++ hapt ,[p=ship q=path] ::
|
|
++ cuft :: internal gift
|
|
$% [%coup p=(unit tang)] :: poke result
|
|
[%diff p=cage] :: subscription output
|
|
[%quit ~] :: close subscription
|
|
[%reap p=(unit tang)] :: peer result
|
|
== ::
|
|
++ hood :: assembly plan
|
|
$: zus=@ud :: zuse kelvin
|
|
sur=(list hoot) :: structures
|
|
lib=(list hoof) :: libraries
|
|
fan=(list horn) :: resources
|
|
src=(list hoop) :: program
|
|
== ::
|
|
++ hoof (pair term (unit (pair case ship))) :: resource reference
|
|
++ hoot (pair bean hoof) :: structure gate/core
|
|
++ hoop :: source in hood
|
|
$% [%& p=twig] :: direct twig
|
|
[%| p=beam] :: resource location
|
|
== ::
|
|
++ horn :: resource tree
|
|
$% [%ape p=twig] :: /~ twig by hand
|
|
[%arg p=twig] :: /$ argument
|
|
[%day p=horn] :: /| list by @dr
|
|
[%dub p=term q=horn] :: /= apply face
|
|
[%fan p=(list horn)] :: /. list
|
|
[%for p=path q=horn] :: /, descend
|
|
[%hel p=@ud q=horn] :: /% propagate heel
|
|
[%hub p=horn] :: /@ list by @ud
|
|
[%man p=(map span horn)] :: /* hetero map
|
|
[%nap p=horn] :: /_ homo map
|
|
[%now p=horn] :: /& list by @da
|
|
[%saw p=twig q=horn] :: /; operate on
|
|
[%see p=beam q=horn] :: /: relative to
|
|
[%sic p=tile q=horn] :: /^ cast
|
|
[%toy p=mark] :: /mark/ static
|
|
== ::
|
|
++ milk (trel ship desk silk) :: sourced silk
|
|
++ silk :: construction layer
|
|
$& [p=silk q=silk] :: cons
|
|
$% [%bake p=mark q=beam r=path] :: local synthesis
|
|
[%boil p=mark q=beam r=path] :: general synthesis
|
|
[%bunt p=mark] :: example of mark
|
|
[%call p=silk q=silk] :: slam
|
|
[%cast p=mark q=silk] :: translate
|
|
[%diff p=silk q=silk] :: diff
|
|
[%done p=(set beam) q=gage] :: literal
|
|
[%dude p=tank q=silk] :: error wrap
|
|
[%dune p=(set beam) q=(unit gage)] :: unit literal
|
|
[%file p=beam] :: from clay
|
|
[%join p=mark q=silk r=silk] :: merge
|
|
[%mash p=mark q=milk r=milk] :: annotate
|
|
[%mute p=silk q=(list (pair wing silk))] :: mutant
|
|
[%pact p=silk q=silk] :: patch
|
|
[%plan p=beam q=spur r=hood] :: structured assembly
|
|
[%reef ~] :: kernel reef
|
|
[%ride p=twig q=silk] :: silk thru twig
|
|
[%tabl p=(list (pair silk silk))] :: list
|
|
[%vale p=mark q=ship r=*] :: validate [our his]
|
|
[%volt p=(set beam) q=(cask ,*)] :: unsafe add type
|
|
== ::
|
|
++ sign ::
|
|
$% [%made p=@uvH q=(each gage tang)] ::
|
|
[%unto p=cuft] ::
|
|
== ::
|
|
-- ::
|
|
:: ::
|
|
:::: ::
|
|
:: ::
|
|
|_ $: hid=hide :: system state
|
|
house :: program state
|
|
== ::
|
|
++ he :: per session
|
|
|_ [[ost=bone moz=(list move)] session] ::
|
|
++ dp :: dojo parser
|
|
|%
|
|
++ dp-command :: ++dojo-command
|
|
%+ knee *dojo-command |. ~+
|
|
;~ pose
|
|
%+ stag %poke
|
|
;~ pfix col
|
|
%+ cook
|
|
|= [a=goal b=(each dojo-source (trel term path dojo-config))]
|
|
^- (pair goal dojo-source)
|
|
:- a
|
|
?- -.b
|
|
%& p.b
|
|
%| ?+ p.p.b !!
|
|
%di [0 %di [0 [%dog q.a q.p.b]] r.p.b]
|
|
%ge [0 %ge [0 [%cat q.a q.p.b]] r.p.b]
|
|
%sc [0 %sc [0 [%pig q.a q.p.b]] r.p.b]
|
|
==
|
|
==
|
|
;~ plug
|
|
dp-goal
|
|
;~ pose
|
|
(stag %& ;~(pfix ace dp-source))
|
|
%+ stag %|
|
|
;~ plug
|
|
;~ pose
|
|
(cold %di wut)
|
|
(cold %ge lus)
|
|
(cold %sc pam)
|
|
==
|
|
(most fas sym)
|
|
dp-config
|
|
==
|
|
==
|
|
==
|
|
==
|
|
::
|
|
%+ stag %verb
|
|
;~ pfix tis
|
|
;~(plug sym ;~(pfix ace dp-source))
|
|
==
|
|
::
|
|
%+ stag %flat
|
|
;~ pfix pat
|
|
;~(plug (most fas sym) ;~(pfix ace dp-source))
|
|
==
|
|
::
|
|
%+ stag %pill
|
|
;~ pfix dot
|
|
;~(plug (most fas sym) ;~(pfix ace dp-source))
|
|
==
|
|
::
|
|
(stag %show dp-source)
|
|
==
|
|
++ dp-source (stag 0 dp-build) :: ++dojo-source
|
|
++ dp-build :: ++dojo-build
|
|
%+ knee *dojo-build |. ~+
|
|
;~ pose
|
|
;~(pfix lus (stag %ge dp-model-cat))
|
|
;~(pfix wut (stag %di dp-model-dog))
|
|
;~(pfix pam (stag %sc dp-model-pig))
|
|
;~(pfix buc (stag %va sym))
|
|
(stag %ex dp-twig)
|
|
(ifix [sel ser] (stag %tu (most ace dp-source)))
|
|
==
|
|
::
|
|
++ dp-goal :: ++goal
|
|
%+ cook |=(a=goal a)
|
|
;~ pose
|
|
;~ plug
|
|
;~(pfix sig fed:ag)
|
|
;~(pfix fas sym)
|
|
==
|
|
(cook |=(a=term `goal`[our.hid a]) sym)
|
|
(easy [our.hid %hood])
|
|
==
|
|
++ dp-model-cat ;~(plug dp-server-cat dp-config) :: ++dojo-model
|
|
++ dp-model-dog ;~(plug dp-server-dog dp-config) :: ++dojo-model
|
|
++ dp-model-pig ;~(plug dp-server-pig dp-config) :: ++dojo-model
|
|
++ dp-server-cat (stag 0 (stag %cat dp-device)) :: ++dojo-server
|
|
++ dp-server-dog (stag 0 (stag %dog dp-device)) :: ++dojo-server
|
|
++ dp-server-pig (stag 0 (stag %pig dp-device)) :: ++dojo-server
|
|
++ dp-twig wide:(vang & ~) :: ++twig
|
|
++ dp-device (most fas sym) :: ++dojo-device
|
|
++ dp-value :: ++dojo-source
|
|
%+ cook |=(a=dojo-source a)
|
|
%+ stag 0
|
|
;~ pose
|
|
(ifix [kel ker] (stag %tu (most ace dp-source)))
|
|
(stag %va ;~(pfix buc sym))
|
|
(stag %ex dp-twig)
|
|
==
|
|
::
|
|
++ dp-config :: ++dojo-config
|
|
%+ cook |=(a=dojo-config a)
|
|
;~ plug
|
|
(star ;~(pfix ace dp-value))
|
|
%+ cook
|
|
~(gas by *(map term (unit dojo-source)))
|
|
%+ more
|
|
;~(plug com ace)
|
|
;~ plug
|
|
;~(pfix tis sym)
|
|
;~ pose
|
|
;~(pfix ace (stag ~ dp-value))
|
|
(easy ~)
|
|
==
|
|
==
|
|
==
|
|
--
|
|
::
|
|
++ dy :: project work
|
|
|_ dojo-project ::
|
|
++ dy-abet +>(poy `+<) :: resolve
|
|
++ dy-amok +>(poy ~) :: terminate
|
|
++ dy-beak :: XX rethink
|
|
^- beak
|
|
[our.hid %home [%da lat.hid]]
|
|
::
|
|
++ dy-ford :: send work to ford
|
|
|= [way=wire kas=silk]
|
|
^+ +>+>
|
|
?> ?=(~ pux)
|
|
(he-card(poy `+>+<(pux `way)) %exec way our.hid dy-beak `kas)
|
|
::
|
|
++ dy-stop :: stop work
|
|
^+ +>
|
|
?~ pux +>
|
|
(he-card(poy ~) %exec u.pux our.hid dy-beak ~)
|
|
::
|
|
++ dy-slam :: call by ford
|
|
|= [way=wire gat=vase sam=vase]
|
|
^+ +>+>
|
|
(dy-ford way %call [%done ~ %noun gat] [%done ~ %noun sam])
|
|
::
|
|
++ dy-diff :: send effects, abet
|
|
|= fec=sole-effect
|
|
^+ +>+>
|
|
(he-diff(poy `+>+<) fec)
|
|
::
|
|
++ dy-rash :: send effects, amok
|
|
|= fec=sole-effect
|
|
^+ +>+>
|
|
(he-diff(poy ~) fec)
|
|
::
|
|
++ dy-init-command :: ++dojo-command
|
|
|= mad=dojo-command
|
|
^+ [mad +>]
|
|
?- -.mad
|
|
%flat =^(src +>.$ (dy-init-source q.mad) [[%flat p.mad src] +>.$])
|
|
%pill =^(src +>.$ (dy-init-source q.mad) [[%pill p.mad src] +>.$])
|
|
%poke =^(src +>.$ (dy-init-source q.mad) [[%poke p.mad src] +>.$])
|
|
%show =^(src +>.$ (dy-init-source p.mad) [[%show src] +>.$])
|
|
%verb =^(src +>.$ (dy-init-source q.mad) [[%verb p.mad src] +>.$])
|
|
==
|
|
::
|
|
++ dy-init-source-unit :: (unit dojo-source)
|
|
|= urc=(unit dojo-source)
|
|
^+ [urc +>]
|
|
?~ urc [~ +>]
|
|
=^ src +> (dy-init-source u.urc)
|
|
[`src +>.$]
|
|
::
|
|
++ dy-init-source :: ++dojo-source
|
|
|= src=dojo-source
|
|
^+ [src +>]
|
|
=^ bul +> (dy-init-build q.src)
|
|
=: p.src num
|
|
q.src bul
|
|
==
|
|
[src +>.$(num +(num), job (~(put by job) num q.src))]
|
|
::
|
|
++ dy-init-build :: ++dojo-build
|
|
|= bul=dojo-build
|
|
^+ [bul +>]
|
|
?- -.bul
|
|
%ex [bul +>.$]
|
|
%di =^(mod +>.$ (dy-init-model p.bul) [[%di mod] +>.$])
|
|
%dv [bul +>.$]
|
|
%fi !!
|
|
%ge =^(mod +>.$ (dy-init-model p.bul) [[%ge mod] +>.$])
|
|
%sc !!
|
|
%tu =^ dof +>.$
|
|
|- ^+ [p.bul +>.^$]
|
|
?~ p.bul [~ +>.^$]
|
|
=^ dis +>.^$ (dy-init-source i.p.bul)
|
|
=^ mor +>.^$ $(p.bul t.p.bul)
|
|
[[dis mor] +>.^$]
|
|
[[%tu dof] +>.$]
|
|
%va [bul +>.$]
|
|
==
|
|
::
|
|
++ dy-init-model :: ++dojo-model
|
|
|= mol=dojo-model
|
|
^+ [mol +>]
|
|
=^ one +>.$ (dy-init-server p.mol)
|
|
=^ two +>.$ (dy-init-config q.mol)
|
|
[[one two] +>.$]
|
|
::
|
|
++ dy-init-server :: ++dojo-server
|
|
|= srv=dojo-server
|
|
=. p.srv num
|
|
[srv +>.$(num +(num), job (~(put by job) num [%dv q.srv]))]
|
|
::
|
|
++ dy-init-config :: prepare config
|
|
|= cig=dojo-config
|
|
^+ [cig +>]
|
|
=^ ord +>.$ (dy-init-ordered p.cig)
|
|
=^ key +>.$ (dy-init-named q.cig)
|
|
[[ord key] +>.$]
|
|
::
|
|
++ dy-init-ordered :: (list dojo-source)
|
|
|= ord=(list dojo-source)
|
|
^+ [ord +>]
|
|
?~ ord [~ +>.$]
|
|
=^ fir +>.$ (dy-init-source i.ord)
|
|
=^ mor +>.$ $(ord t.ord)
|
|
[[fir mor] +>.$]
|
|
::
|
|
++ dy-init-named :: (map @tas dojo-src)
|
|
|= key=(map term (unit dojo-source))
|
|
^+ [key +>.$]
|
|
?~ key [~ +>.$]
|
|
=^ top +>.$ (dy-init-source-unit q.n.key)
|
|
=^ lef +>.$ $(key l.key)
|
|
=^ rit +>.$ $(key r.key)
|
|
[[[p.n.key top] lef rit] +>.$]
|
|
::
|
|
++ dy-init :: full initialize
|
|
^+ .
|
|
=^(dam . (dy-init-command mad) +(mad dam))
|
|
::
|
|
++ dy-hand :: complete step
|
|
|= cag=cage
|
|
^+ +>+>
|
|
?> ?=(^ cud)
|
|
(dy-step(cud ~, rez (~(put by rez) p.u.cud cag)) +(p.u.cud))
|
|
::
|
|
++ dy-meal :: vase to cage
|
|
|= vax=vase
|
|
?. &(?=(@ -.q.vax) ((sane %tas) -.q.vax))
|
|
~& %dy-meal-cage
|
|
(dy-rash %bel ~)
|
|
(dy-hand -.q.vax (slot 3 vax))
|
|
::
|
|
++ dy-made-edit :: sole edit
|
|
|= cag=cage
|
|
^+ +>+>
|
|
?> ?=(^ per)
|
|
?: ?| ?=(^ q.q.cag)
|
|
=((lent buf.say) q.q.cag)
|
|
!&(?=(%del -.u.per) =(+(p.u.per) (lent buf.say)))
|
|
==
|
|
dy-abet(per ~)
|
|
=^ lic say (~(transmit cs say) u.per)
|
|
(dy-diff(per ~) %mor [%det lic] [%err q.q.cag] ~)
|
|
::
|
|
++ dy-done :: dialog submit
|
|
|= txt=tape
|
|
?> ?=(^ pro)
|
|
(dy-slam /dial u.pro !>(txt))
|
|
::
|
|
++ dy-over :: finish construction
|
|
^+ +>
|
|
?- -.mad
|
|
%poke
|
|
%- he-card(poy ~)
|
|
:* %deal
|
|
/poke
|
|
[our.hid p.p.mad]
|
|
q.p.mad
|
|
%poke
|
|
(~(got by rez) p.q.mad)
|
|
==
|
|
::
|
|
%flat
|
|
=+ out=q.q:(~(got by rez) p.q.mad)
|
|
?^ out
|
|
(dy-rash %tan [%leaf "not an atom"]~)
|
|
(dy-rash %sav p.mad out)
|
|
::
|
|
%pill
|
|
(dy-rash %sag p.mad q.q:(~(got by rez) p.q.mad))
|
|
::
|
|
%verb
|
|
dy-amok(var (~(put by var) p.mad (~(got by rez) p.q.mad)))
|
|
::
|
|
%show
|
|
(dy-rash %tan (sell q:(~(got by rez) p.p.mad)) ~)
|
|
==
|
|
::
|
|
++ dy-edit :: handle edit
|
|
|= cal=sole-change
|
|
^+ +>+>
|
|
=^ dat say (~(transceive cs say) cal)
|
|
?: |(?=(^ per) ?=(^ pux) ?=(~ pro))
|
|
~& %dy-edit-busy
|
|
=^ lic say (~(transmit cs say) dat)
|
|
(dy-diff %mor [%det lic] [%bel ~] ~)
|
|
(dy-slam(per `dat) /edit u.pro !>((tufa buf.say)))
|
|
::
|
|
++ dy-type :: sole action
|
|
|= act=sole-action
|
|
?- -.act
|
|
%det (dy-edit +.act)
|
|
%ret (dy-done (tufa buf.say))
|
|
==
|
|
::
|
|
++ dy-cage |=(num=@ud (~(got by rez) num)) :: known cage
|
|
++ dy-vase |=(num=@ud q:(dy-cage num)) :: known vase
|
|
++ dy-silk-vase |=(vax=vase [%done ~ %noun vax]) :: vase to silk
|
|
++ dy-silk-config :: configure
|
|
|= [cag=cage cig=dojo-config]
|
|
^- silk
|
|
:+ %ride [%cnzy %$]
|
|
:+ %mute [%done ~ cag]
|
|
^- (list (pair wing silk))
|
|
:* :- [[~ 12] ~]
|
|
(dy-silk-vase !>([now=lat.hid eny=eny.hid bec=he-beak]))
|
|
::
|
|
:- [[~ 26] ~]
|
|
%- dy-silk-vase
|
|
|- ^- vase
|
|
?~ p.cig !>(~)
|
|
(slop (dy-vase p.i.p.cig) $(p.cig t.p.cig))
|
|
::
|
|
%+ turn (~(tap by q.cig))
|
|
|= [a=term b=(unit dojo-source)]
|
|
^- (pair wing silk)
|
|
:- [a [~ 27] ~]
|
|
%- dy-silk-vase
|
|
?~(b !>([~ ~]) (dy-vase p.u.b))
|
|
==
|
|
::
|
|
++ dy-silk-init-modo :: init and config
|
|
|= [cag=cage cig=dojo-config]
|
|
^- silk
|
|
(dy-silk-config cag cig)
|
|
::
|
|
++ dy-silk-device :: device to silk
|
|
|= way=wire
|
|
^- silk
|
|
[%boil %gate [he-beak (flop way)] ~]
|
|
::
|
|
++ dy-twig-head :: dynamic state
|
|
^- vase
|
|
:(slop !>(`our=@p`our.hid) !>(`tym=@da`lat.hid) !>(`eny=@uvI`eny.hid))
|
|
::
|
|
++ dy-made-dial :: dialog product
|
|
|= cag=cage
|
|
^+ +>+>
|
|
?. ?=(^ q.q.cag)
|
|
(dy-diff %err q.q.cag)
|
|
=+ tan=((list tank) +2.q.q.cag)
|
|
=. +>+>.$ (he-diff %tan tan)
|
|
=+ vax=(spec (slot 3 q.cag))
|
|
?+ -.q.vax !!
|
|
%&
|
|
?~ +.q.vax
|
|
~& %dy-made-dial-abort
|
|
(dy-rash %bel ~)
|
|
(dy-meal (slot 7 vax))
|
|
::
|
|
%|
|
|
=< he-pone
|
|
%- dy-diff(pro `(slap (slot 7 vax) [%cnzy %q]))
|
|
=+ pom=(sole-prompt +<.q.vax)
|
|
[%pro pom(cad [':' ' ' cad.pom])]
|
|
==
|
|
::
|
|
++ dy-made-gent :: generator product
|
|
|= cag=cage
|
|
(dy-meal q.cag)
|
|
::
|
|
++ dy-make :: build step
|
|
^+ +>
|
|
?> ?=(^ cud)
|
|
%- dy-ford
|
|
^- (pair path silk)
|
|
?+ -.q.u.cud !!
|
|
%di [/dial (dy-silk-init-modo (dy-cage p.p.p.q.u.cud) q.p.q.u.cud)]
|
|
%ge [/gent (dy-silk-init-modo (dy-cage p.p.p.q.u.cud) q.p.q.u.cud)]
|
|
%dv [/hand (dy-silk-device p.q.u.cud)]
|
|
%ex [/hand [%ride p.q.u.cud [[%done ~ %$ dy-twig-head] [%reef ~]]]]
|
|
%tu :- /hand
|
|
:+ %done ~
|
|
:- %noun
|
|
|- ^- vase
|
|
?~ p.q.u.cud !!
|
|
=+ hed=(dy-vase p.i.p.q.u.cud)
|
|
?~ t.p.q.u.cud hed
|
|
(slop hed $(p.q.u.cud t.p.q.u.cud))
|
|
==
|
|
::
|
|
++ dy-step :: advance project
|
|
|= nex=@ud
|
|
^+ +>+>
|
|
?> ?=(~ cud)
|
|
?: =(nex num)
|
|
dy-over
|
|
dy-make(cud `[nex (~(got by job) nex)])
|
|
--
|
|
::
|
|
++ he-dope :: sole user of ++dp
|
|
|= txt=tape ::
|
|
^- (each (unit dojo-command) hair) :: prefix/result
|
|
=+ vex=(dp-command:dp [1 1] txt) ::
|
|
?. =(+((lent txt)) q.p.vex) :: fully parsed
|
|
[%| p.p.vex (dec q.p.vex)] :: syntax error
|
|
[%& ?~(q.vex ~ `p.u.q.vex)] :: prefix/complete
|
|
::
|
|
++ he-duke :: ++he-dope variant
|
|
|= txt=tape
|
|
^- (each dojo-command ,@ud)
|
|
=+ foy=(he-dope txt)
|
|
?- -.foy
|
|
%| [%| q.p.foy]
|
|
%& ?~(p.foy [%| (lent txt)] [%& u.p.foy])
|
|
==
|
|
::
|
|
++ he-abet :: resolve
|
|
[(flop moz) %_(+> hoc (~(put by hoc) ost +<+))]
|
|
::
|
|
++ he-beak :: logical beam
|
|
^- beak
|
|
[our.hid syd ?^(luc u.luc [%da lat.hid])]
|
|
::
|
|
++ he-card :: emit gift
|
|
|= cad=card
|
|
^+ +>
|
|
%_(+> moz [[ost cad] moz])
|
|
::
|
|
++ he-send
|
|
|= [way=wire him=ship dap=term cop=clap]
|
|
^+ +>
|
|
(he-card %send way [him dap] cop)
|
|
::
|
|
++ he-diff :: emit update
|
|
|= fec=sole-effect
|
|
^+ +>
|
|
(he-card %diff %sole-effect fec)
|
|
::
|
|
++ he-stop :: abort work
|
|
^+ .
|
|
?~(poy . ~(dy-stop dy u.poy))
|
|
::
|
|
++ he-peer :: subscribe to
|
|
he-prom
|
|
::
|
|
++ he-pine :: restore prompt
|
|
^+ .
|
|
?^ poy .
|
|
he-prom:he-pone
|
|
::
|
|
++ he-pone :: clear prompt
|
|
^+ .
|
|
=^ cal say (~(transmit cs say) [%set ~])
|
|
(he-diff %mor [%det cal] ~)
|
|
::
|
|
++ he-prom :: send prompt
|
|
%- he-diff
|
|
:- %pro
|
|
[& %$ "> "]
|
|
::
|
|
++ he-made :: result from ford
|
|
|= [way=wire dep=@uvH reg=(each gage tang)]
|
|
^+ +>
|
|
?> ?=(^ poy)
|
|
=< he-pine
|
|
?- -.reg
|
|
%& ?> ?=(@ p.p.reg)
|
|
%. p.reg
|
|
=+ dye=~(. dy u.poy(pux ~))
|
|
?+ way !!
|
|
[%hand ~] dy-hand:dye
|
|
[%dial ~] dy-made-dial:dye
|
|
[%gent ~] dy-made-gent:dye
|
|
[%edit ~] dy-made-edit:dye
|
|
==
|
|
%| (he-diff(poy ~) %tan p.reg)
|
|
==
|
|
::
|
|
++ he-unto :: result from behn
|
|
|= cit=cuft
|
|
^+ +>
|
|
?> ?=(%coup -.cit)
|
|
?~ p.cit
|
|
(he-diff %txt ">=")
|
|
(he-diff %tan u.p.cit)
|
|
::
|
|
++ he-like :: accept line
|
|
|= buf=(list ,@c)
|
|
=(%& -:(he-dope (tufa buf)))
|
|
::
|
|
++ he-stir :: apply change
|
|
|= cal=sole-change
|
|
^+ +>
|
|
:: ~& [%his-clock ler.cal]
|
|
:: ~& [%our-clock ven.say]
|
|
=^ dat say (~(transceive cs say) cal)
|
|
?. ?& ?=(%del -.dat)
|
|
=(+(p.dat) (lent buf.say))
|
|
==
|
|
+>.$
|
|
=+ foy=(he-dope (tufa buf.say))
|
|
?: ?=(%& -.foy) +>.$
|
|
:: ~& [%bad-change dat ted.cal]
|
|
=^ lic say (~(transmit cs say) dat)
|
|
:: ~& [%our-leg leg.say]
|
|
(he-diff %mor [%det lic] [%err q.p.foy] ~)
|
|
::
|
|
++ he-plan :: execute command
|
|
|= mad=dojo-command
|
|
^+ +>
|
|
?> ?=(~ poy)
|
|
he-pine:(dy-step:~(dy-init dy mad [0 ~ ~ ~ ~ ~ ~]) 0)
|
|
::
|
|
++ he-done :: parse command
|
|
|= txt=tape
|
|
^+ +>
|
|
?~ txt
|
|
%- he-diff
|
|
:~ %mor
|
|
[%txt "> "]
|
|
[%nex ~]
|
|
==
|
|
=+ doy=(he-duke txt)
|
|
?- -.doy
|
|
%| (he-diff [%err p.doy])
|
|
%&
|
|
=+ old=(weld "> " (tufa buf.say))
|
|
=^ cal say (~(transmit cs say) [%set ~])
|
|
%. p.doy
|
|
=< he-plan
|
|
%- he-diff
|
|
:~ %mor
|
|
[%txt old]
|
|
[%nex ~]
|
|
[%det cal]
|
|
==
|
|
==
|
|
::
|
|
++ he-type :: apply input
|
|
|= act=sole-action
|
|
^+ +>
|
|
?^ poy
|
|
he-pine:(~(dy-type dy u.poy) act)
|
|
?- -.act
|
|
%det (he-stir +.act)
|
|
%ret (he-done (tufa buf.say))
|
|
==
|
|
--
|
|
::
|
|
++ peer-sole
|
|
|= [from pax=path]
|
|
^- (quip move +>)
|
|
~? !=(src our.hid) [%dojo-peer-stranger ost src pax]
|
|
:: ?> =(src our.hid)
|
|
?< (~(has by hoc) ost)
|
|
?> =(~ pax)
|
|
=< he-abet
|
|
%~ he-peer he
|
|
:- [ost ~]
|
|
^- session
|
|
:* *sole-share :: say=sole-share
|
|
%home :: syd=desk
|
|
~ :: luc=(unit case)
|
|
~ :: poy=(unit dojo-project)
|
|
~ :: var=(map term cage)
|
|
~ :: old=(set term)
|
|
==
|
|
::
|
|
++ poke-sole-action
|
|
|= [from act=sole-action]
|
|
^- (quip move +>)
|
|
:: ~& [%dojo-poke ost src act]
|
|
:: ~? !=(src our.hid) [%dojo-poke ost src]
|
|
he-abet:(~(he-type he [ost ~] (~(got by hoc) ost)) act)
|
|
::
|
|
++ made
|
|
|= [then dep=@uvH reg=(each gage tang)]
|
|
he-abet:(~(he-made he [[ost ~] (~(got by hoc) ost)]) way dep reg)
|
|
::
|
|
++ unto
|
|
|= [then cit=cuft]
|
|
he-abet:(~(he-unto he [[ost ~] (~(got by hoc) ost)]) cit)
|
|
::
|
|
++ pull
|
|
|= [from pax=path]
|
|
^- (quip move +>)
|
|
=^ moz +>
|
|
he-abet:~(he-stop he [[ost ~] (~(got by hoc) ost)])
|
|
[moz +>.$(hoc (~(del by hoc) ost))]
|
|
--
|