:: :: :: :::: /hoon/dojo/app :: :::: :: :: :: /? 309 :: arvo kelvin /- sole, lens :: console structures /+ sole :: console library =, sole =, space:userlib =, format :: :: :: :::: :: :::: :: :: :: => |% :: external structures ++ house :: all state $: $5 egg/@u :: command count hoc/(map bone session) :: conversations == :: ++ session :: per conversation $: say/sole-share :: command-line state dir/beam :: active path poy/(unit dojo-project) :: working {lib/(list hoof:ford) sur/(list hoof:ford)} :: lib+sur var/(map term cage) :: variable state old/(set term) :: used TLVs buf/tape :: multiline buffer == :: ++ monkey :: per conversation $: say/sole-share :: command-line state dir/beam :: active path poy/(unit dojo-project) :: working var/(map term cage) :: variable state old/(set term) :: used TLVs buf/tape :: multiline buffer == :: ++ dojo-command :: $^ (pair dojo-sink dojo-source) :: route value {$brev p/term} :: unbind variable :: ++ dojo-sink :: $% {$flat p/path} :: atom to unix {$pill p/path} :: noun to unix pill :: {$tree p/path} :: noun to unix tree {$file p/beam} :: save to clay $: $http :: http outbound p/?($post $put) q/(unit knot) r/purl:eyre == {$poke p/goal} :: poke app {$show p/?($0 $1 $2 $3)} :: print val+type+hoon {$verb p/term} :: store variable {$help p/(list term)} :: look up help == :: ++ dojo-source :: construction node $: p/@ud :: assembly index q/dojo-build :: general build == :: ++ dojo-build :: one arvo step $~ [%ex *hoon] $% {$ur p/(unit knot) q/purl:eyre} :: http GET request {$ge p/dojo-model} :: generator {$dv p/path} :: core from source {$ex p/hoon} :: hoon expression {$sa p/mark} :: example mark value {$as p/mark q/dojo-source} :: simple transmute {$do p/hoon q/dojo-source} :: gate apply {$tu p/(list dojo-source)} :: tuple == :: ++ 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/(cask)} :: 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} :: $: $hiss wire (unit knot) mark {$hiss hiss:eyre} == {$exec wire @p (unit {beak silk:ford})} :: {$deal wire sock term club} :: {$info wire @p toro:clay} :: == :: ++ move (pair bone card) :: user-level move ++ sign :: $% {$made p/@uvH q/gage:ford} :: {$unto p/cuft:gall} :: == :: -- :: :: :: :::: :: :: :: =, gall =+ foo=*monkey |_ $: hid/bowl :: system state house :: program state == :: ++ he :: per session |_ {moz/(list move) session} :: ++ dp :: dojo parser |% ++ dp-default-app %hood ++ dp-message :: %poke |= {gol/goal mod/dojo-model} ^- dojo-command [[%poke gol] [0 [%ge mod(q.p [q.gol q.p.mod])]]] :: ++ dp-command-line ;~(sfix dp-command (star ace) (just '\0a')) ++ dp-variable :: %verb or %brev |* {sym/rule src/rule} %+ cook |= {a/term b/(unit dojo-source)} ^- dojo-command ?~(b [%brev a] [[%verb a] u.b]) ;~(plug sym (punt src)) :: ++ dp-command :: ++dojo-command :: =< ;~(less |-(;~(pose (jest '|*') ;~(pfix next (knee ** |.(^$))))) .) %+ knee *dojo-command |. ~+ ;~ pose ;~ pfix bar %+ cook dp-message (stag [our.hid dp-default-app] dp-model) == :: ;~ pfix col %+ cook |= {a/goal b/$^(dojo-model dojo-source)} ?@ -.b [[%poke a] b] (dp-message a b) ;~ plug dp-goal ;~ pose ;~(pfix bar dp-model) ;~(pfix ace dp-source) == == == :: ;~ pfix tis ;~ pose (dp-variable (jest %dir) ;~(pfix ace :(stag 0 %ex dp-rood))) (dp-variable sym ;~(pfix ace dp-source)) == == :: ;~ pfix net ;~ pose (dp-variable (cold %sur hep) ;~(pfix gap dp-hooves)) (dp-variable (cold %lib lus) ;~(pfix gap dp-hooves)) == == :: ;~ pfix hax ;~ pose ;~ pfix ace %+ cook |= a/(list term) [[%help a] 0 %ex [%cnts p=~[[%.y p=1]] q=~]] (most col sym) == (easy [[%help ~] 0 %ex [%cnts p=~[[%.y p=1]] q=~]]) == == :: ;~((glue ace) dp-sink dp-source) (stag [%show %0] dp-source) == ++ dp-sink ;~ pose ;~(plug (cold %file tar) dp-beam) ;~(plug (cold %flat vat) (most net sym)) ;~(plug (cold %pill dot) (most net sym)) ;~(plug (cold %http lus) (stag %post dp-iden-url)) ;~(plug (cold %http hep) (stag %put dp-iden-url)) (stag %show (cook $?($1 $2 $3) (cook lent (stun [1 3] wut)))) == ++ dp-hooves :: hoof list :(stag 0 %ex %clsg (most ;~(plug com gaw) dp-hoof)) :: ++ dp-hoof :: ++ford-hoof hoon ;~ plug :(stag %sand %f ;~(pose (cold %| tar) (easy %&))) :(stag %sand %tas sym) %- dp-hoon-punt ;~ (glue net) ;~(pfix net (sear dp-case-hoon nuck:so)) (stag %sand ;~(plug (cold %p sig) fed:ag)) == == :: ++ dp-hoon-punt :: hoon of unit |*(a/rule ;~(pose (stag [%bust %null] a) (easy [%bust %null]))) :: ++ dp-case-hoon |= a/coin ^- (unit hoon) ?. ?=({~ case} a) ~ %+ some [%rock %tas p.p.a] [%sand p.a] :: ++ dp-source (stag 0 dp-build) :: ++dojo-source ++ dp-build :: ++dojo-build %+ knee *dojo-build |. ~+ ;~ pose ;~(plug (cold %ur lus) dp-iden-url) ;~(plug (cold %ge lus) dp-model) ;~(plug (cold %as pad) sym ;~(pfix ace dp-source)) ;~(plug (cold %do cab) dp-hoon ;~(pfix ace dp-source)) dp-value == :: ++ dp-goal :: ++goal %+ cook |=(a/goal a) ;~ pose ;~ plug ;~(pfix sig fed:ag) ;~(pose ;~(pfix net sym) (easy dp-default-app)) == %+ stag our.hid ;~(pose sym (easy dp-default-app)) == ++ dp-beam :: ++beam %+ cook |=(a/path =+((de-beam a) ?^(- u [he-beak (flop a)]))) =+ vez=(vang | dp-path) (sear plex:vez (stag %clsg poor:vez)) :: ++ dp-iden-url %+ cook |=({a/(unit knot) b/purl:eyre} [`(fall a *knot) b]) auru:de-purl:html :: ++ dp-model ;~(plug dp-server dp-config) :: ++dojo-model ++ dp-path (en-beam he-beam) :: ++path ++ dp-server (stag 0 (most net sym)) :: ++dojo-server ++ dp-hoon tall:(vang | dp-path) :: ++hoon ++ dp-rood :: 'dir' hoon => (vang | (en-beam dir)) ;~ pose rood :: =- ;~(pfix cen (stag %clsg -)) :: XX refactor ++scat %+ sear |=({a/@ud b/tyke} (posh ~ ~ a b)) ;~ pose porc (cook |=(a/(list) [(lent a) ~]) (star cen)) == == ++ dp-value :: ++dojo-source ;~ pose (stag %sa ;~(pfix tar pad sym)) (stag %ex dp-hoon) (stag %tu (ifix [lac rac] (most ace dp-source))) == :: ++ dp-config :: ++dojo-config ;~ plug (star ;~(pfix ace (stag 0 dp-value))) %+ cook ~(gas by *(map term (unit dojo-source))) %- star ;~ plug ;~(pfix com ace tis sym) (punt ;~(pfix ace (stag 0 dp-value))) == == -- :: ++ dy :: project work |_ dojo-project :: ++ dy-abet +>(poy `+<) :: resolve ++ dy-amok +>(poy ~) :: terminate ++ dy-ford :: send work to ford |= {way/wire kas/silk:ford} ^+ +>+> ?> ?=(~ pux) (he-card(poy `+>+<(pux `way)) %exec way our.hid `[he-beak kas]) :: ++ dy-eyre :: send work to eyre |= {way/wire usr/(unit knot) req/hiss:eyre} ^+ +>+> ?> ?=(~ pux) (he-card(poy `+>+<(pux `way)) %hiss way usr %httr %hiss req) :: ++ dy-stop :: stop work ^+ +> =. poy ~ ?~ pux +> %. [%txt "! cancel {}"] he-diff:(he-card %exec u.pux our.hid ~) :: ++ dy-slam :: call by ford |= {way/wire gat/vase sam/vase} ^+ +>+> (dy-ford way `silk:ford`[%call [%$ %noun gat] [%$ %noun sam]]) :: ++ dy-errd :: reject change, abet |= {rev/(unit sole-edit) err/@u} ^+ +>+> (he-errd(poy `+>+<) rev err) :: ++ 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 [mad +>.$] =. q.mad ?+(-.p.mad q.mad $http [0 %as %mime q.mad]) =^ src +>.$ (dy-init-source q.mad) [mad(q 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) -.src +.src))] :: ++ dy-init-source-unit :: (unit dojo-source) |= urc/(unit dojo-source) ^+ [urc +>] ?~ urc [~ +>] =^ src +> (dy-init-source u.urc) [`src +>.$] :: ++ dy-init-build :: ++dojo-build |= bul/dojo-build ^+ [bul +>] ?- -.bul $ex [bul +>.$] $dv [bul +>.$] $sa [bul +>.$] $as =^(mor +>.$ (dy-init-source q.bul) [bul(q mor) +>.$]) $do =^(mor +>.$ (dy-init-source q.bul) [bul(q mor) +>.$]) $ge =^(mod +>.$ (dy-init-model p.bul) [[%ge mod] +>.$]) $ur [bul +>.$] $tu =^ dof +>.$ |- ^+ [p.bul +>.^$] ?~ p.bul [~ +>.^$] =^ dis +>.^$ (dy-init-source i.p.bul) =^ mor +>.^$ $(p.bul t.p.bul) [[dis mor] +>.^$] [[%tu dof] +>.$] == :: ++ 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 [%gen 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 ~) (dy-errd(per ~) per q.q.cag) :: ++ dy-done :: dialog submit |= txt/tape ?: |(?=(^ per) ?=(^ pux) ?=(~ pro)) ~& %dy-no-prompt (dy-diff %bel ~) (dy-slam /dial u.pro !>(txt)) :: ++ dy-cast |* {typ/_* bun/vase} |= a/vase ^- typ ~| [p.bun p.a] ?> (~(nest ut p.bun) & p.a) ;;(typ q.a) :: ++ dy-over :: finish construction ^+ +> :: XX needs filter :: :: ?: ?=({$show $3} -.mad) :: (dy-rash %tan (dy-show-source q.mad) ~) :: XX separate command ?: ?=($brev -.mad) =. var (~(del by var) p.mad) =< dy-amok ?+ p.mad . $?($eny $now $our) !! $lib .(lib ~) $sur .(sur ~) $dir .(dir [[our.hid %home ud+0] /]) == =+ cay=(~(got by rez) p.q.mad) ?- -.p.mad $verb =. var (~(put by var) p.p.mad cay) ~| bad-set+[p.p.mad p.q.cay] =< dy-amok ?+ p.p.mad . $eny ~|(%entropy-is-eternal !!) $now ~|(%time-is-immutable !!) $our ~|(%self-is-immutable !!) $lib .(lib ((dy-cast (list hoof:ford) !>(*(list hoof:ford))) q.cay)) :: $sur .(sur ((dy-cast (list hoof:ford) !>(*(list hoof:ford))) q.cay)) :: $dir =+ ^= pax ^- path =+ pax=((dy-cast path !>(*path)) q.cay) ?: ?=(~ pax) ~[(scot %p our.hid) %home '0'] ?: ?=({@ ~} pax) ~[i.pax %home '0'] ?: ?=({@ @ ~} pax) ~[i.pax i.t.pax '0'] pax =. dir (need (de-beam pax)) =- +>(..dy (he-diff %tan - ~)) rose+[" " `~]^~[leaf+"=%" (smyt (en-beam he-beak s.dir))] == :: $help (dy-inspect +.p.mad p.q.cay) :: $poke %- he-card(poy ~) :* %deal /poke [our.hid p.p.p.mad] q.p.p.mad %poke cay == :: $file %- he-card(poy ~) :* %info /file our.hid (foal (en-beam p.p.mad) cay) == :: $flat ?^ q.q.cay (dy-rash %tan [%leaf "not an atom"]~) (dy-rash %sav p.p.mad q.q.cay) :: $pill (dy-rash %sag p.p.mad q.q.cay) :: $http ?> ?=($mime p.cay) =+ mim=;;(mime q.q.cay) =+ maf=(~(add ja *math:eyre) %content-type (en-mite:mimes:html p.mim)) (dy-eyre /show q.p.mad [r.p.mad p.p.mad maf ~ q.mim]) :: $show %+ dy-print cay =+ mar=|.(?:(=(%noun p.cay) ~ [%rose [~ " " ~] >p.cay< ~]~)) ?- p.p.mad $0 ~ $1 [[%rose [~ " " ~] (skol p.q.cay) ~] (mar)] $2 [[%rose [~ " " ~] (dy-show-type-noun p.q.cay) ~] (mar)] $3 ~ == == :: ++ dy-show |=(cay/cage (dy-print cay ~)) ++ dy-print |= {cay/cage tan/tang} %+ dy-rash %tan %- welp :_ tan ?+ p.cay [(sell q.cay)]~ $tang ;;(tang q.q.cay) $httr =+ hit=;;(httr:eyre q.q.cay) =- (flop (turn `wall`- |=(a/tape leaf+(dash:us a '')))) :- "HTTP {}" %+ weld (turn q.hit |=({a/@t b/@t} "{(trip a)}: {(trip b)}")) :- i="" t=(turn `wain`?~(r.hit ~ (to-wain:format q.u.r.hit)) trip) == :: ++ dy-inspect |= {topic/(list term) sut/type} %+ dy-rash %tan |^ ^- tang =+ to-display=(find-item-in-type (flop topic) sut) ?~ to-display [%leaf "Could not find help"]~ (flop (print-item u.to-display)) :> # %models +| :: :> an overview of all named things in the type. :> :> each item in the overview list is either a documentation for a sublist :> or an association between a term and documentation for it. ++ overview (list overview-item) :: :> in instance in the ++overview list. ++ overview-item $% :> a header {doc} which will indent its {children}. {$header doc/what children/overview} :> an item in a list with {name} and {docs}. {$item name/tape doc/what} == :: :> the part of a {type} being inspected. ++ item $~ [%view ~] $% :> overview of type {$view items/overview} :> inspecting a full core. $: $core name/tape docs/what sut/type con/coil children/(unit item) == :> inspecting a single arm on a core. $: $arm name/tape docs/what f/foot sut/type == :> inspecting a single chapter on a core. $: $chapter name/tape docs/what sut/type con/coil chapter-id/@ == :> inspecting a face and what's behind it. $: $face name/tape docs/what children/(unit item) == == :> # :> # %searching :> # :> functions which find what to print +| :> returns the item to print while searching through {topic}. :> :> this gate is called recursively to find the path {topic} in the type :> {sut}. once it finds the correct part of the type, it switches to :> ++build-inspectable-recursively to describe that part of the type. ++ find-item-in-type |= {topics/(list term) sut/type} ^- (unit item) ?~ topics :: we have no more search path. return the rest as an overview (build-inspectable-recursively sut) ?- sut {$atom *} ~ :: {$cell *} =+ lhs=$(sut p.sut) ?~ lhs $(sut q.sut) lhs :: {$core *} =+ core-docs=r.q.sut ?~ p.core-docs :: todo: this core has no toplevel documentation. it might have :: an arm though. check that next. $(sut p.sut) ?: !=(i.topics u.p.core-docs) :: the current topic isn't the toplevel core topic. =+ arm=(find-arm-in-coil i.topics q.sut) ?~ arm :: the current topic is neither the name of the core or an arm :: on the core. $(sut p.sut) `[%arm (trip i.topics) p.u.arm q.u.arm p.sut] ?~ t.topics :: we matched the core name and have no further search terms. =* compiled-against (build-inspectable-recursively p.sut) `[%core (trip i.topics) q.core-docs p.sut q.sut compiled-against] :: search the core for chapters. =/ tombs/(list (pair @ tomb)) ~(tap by q.s.q.sut) |- ^- (unit item) ?~ tombs ~ ?~ p.p.q.i.tombs :: this has no chapter name. $(tombs t.tombs) ?: !=(i.t.topics u.p.p.q.i.tombs) :: this isn't the topic. $(tombs t.tombs) `[%chapter (trip i.t.topics) q.p.q.i.tombs sut q.sut p.i.tombs] :: {$face *} ?. ?=(term q.p.sut) :: todo: is there something we could do if we have a tune? ~ ?. =(i.topics q.p.sut) :: this face has a name, but it's not the name we're looking for. ~ ?~ t.topics `[%face (trip q.p.sut) p.p.sut (build-inspectable-recursively q.sut)] (find-item-in-type t.topics q.sut) :: {$fork *} =/ types/(list type) ~(tap in p.sut) |- ?~ types ~ =+ res=(find-item-in-type topics i.types) ?~ res $(types t.types) res :: {$help *} :: while we found a raw help, it's associated on the wrong side of a :: set of topics. Walk through it instead of showing it. (find-item-in-type t.topics q.sut) :: {$form *} $(sut q.sut) :: {$hold *} $(sut (~(play ut p.sut) q.sut)) $noun ~ $void ~ == :: :> changes a {type} into an {item}. ++ build-inspectable-recursively |= sut/type ^- (unit item) ?- sut :: {$atom *} ~ :: {$cell *} %+ join-items (build-inspectable-recursively p.sut) (build-inspectable-recursively q.sut) :: {$core *} =* name (fall p.r.q.sut '') =* compiled-against (build-inspectable-recursively p.sut) `[%core (trip name) q.r.q.sut p.sut q.sut compiled-against] :: {$face *} ?. ?=(term q.p.sut) :: todo: can we do anything here if this face doesn't have a term? ~ =* compiled-against (build-inspectable-recursively q.sut) `[%face (trip q.p.sut) p.p.sut compiled-against] :: {$fork *} =* types ~(tap in p.sut) =* items (turn types build-inspectable-recursively) (roll items join-items) :: {$help *} =* rest-type (build-inspectable-recursively q.sut) ?> ?=($docs -.p.sut) `[%view [%header `+.p.sut (item-as-overview rest-type)]~] :: {$form *} $(sut q.sut) {$hold *} $(sut (~(play ut p.sut) q.sut)) $noun ~ $void ~ == :: :> combines two {(unit item)} together ++ join-items |= {lhs/(unit item) rhs/(unit item)} ^- (unit item) ?~ lhs rhs ?~ rhs lhs `[%view (weld (item-as-overview lhs) (item-as-overview rhs))] :: :> changes an item into an overview. ++ item-as-overview |= uit/(unit item) ^- overview ?~ uit ~ =+ itm=u.uit ?- itm :: {$view *} items.itm :: {$core *} ?~ name.itm (item-as-overview children.itm) :- [%item name.itm docs.itm] (item-as-overview children.itm) :: {$arm *} [%item name.itm docs.itm]~ :: {$chapter *} [%item name.itm docs.itm]~ :: {$face *} ?~ name.itm ~ [%item name.itm docs.itm]~ == :: :> translate the internals of a core's {tomb} into an {overview}. ++ arms-as-overview |= {a/(map term (pair what foot)) sut/type} ^- overview %+ turn ~(tap by a) |= (pair term (pair what foot)) =* doc (select-arm-docs p.q q.q sut) [%item (weld "++" (trip p)) -.doc] :: :> if {arm-name} is an arm in {c}, returns its documentation. ++ find-arm-in-coil |= {arm-name/term con/coil} ^- (unit (pair what foot)) =/ tombs ~(tap by q.s.con) |- ?~ tombs ~ =+ item=(~(get by q.q.i.tombs) arm-name) ?~ item $(tombs t.tombs) [~ u.item] :: :> returns an overview for a core's arms and chapters. :> :> returns an overview for arms which are part of unnamed chapters, :> and an overview of the named chapters. ++ arm-and-chapter-overviews |= {sut/type con/coil core-name/tape} ^- {overview overview} =| arm-docs/overview :< documented arms =| chapter-docs/overview :< documented chapters =/ tombs ~(tap by q.s.con) |- ?~ tombs [(sort-overview arm-docs) (sort-overview chapter-docs)] =* current q.i.tombs ?~ p.p.current :: this chapter has no name. add all the foot documentation :: to arm-docs. =. arm-docs (weld arm-docs (arms-as-overview q.current sut)) $(tombs t.tombs) :: this chapter has a name. add it to the list of chapters =. chapter-docs %+ weld chapter-docs ^- overview [%item :(weld (trip u.p.p.current) ":" core-name) q.p.current]~ $(tombs t.tombs) :: :> returns an overview of the arms in a specific chapter. ++ arms-in-chapter |= {sut/type con/coil chapter-id/@} ^- overview =* chapter-tomb (~(got by q.s.con) chapter-id) (sort-overview (arms-as-overview q.chapter-tomb sut)) :: :> sort the items. ++ sort-overview |: ovr=$:overview ^- overview %+ sort ovr |: $:{lhs/overview-item rhs/overview-item} (aor (get-overview-name lhs) (get-overview-name rhs)) :: ++ get-overview-name |: ovr=$:overview-item ?- ovr {$header *} "" {$item *} name.ovr == :: ++ what-from-type |= sut/type ?+ sut ~ {$core *} q.r.q.sut {$help *} ?>(?=($docs -.p.sut) `+.p.sut) {$form *} $(sut q.sut) {$hold *} $(sut (~(play ut p.sut) q.sut)) == :: :> # :> # %printing :> # :> functions which display output of various types. +| ++ print-item |: itm=$:item ^- tang ?- itm {$view *} (print-overview items.itm) {$core *} (print-core +.itm) {$arm *} (print-arm +.itm) {$chapter *} (print-chapter +.itm) {$face *} (print-face +.itm) == :: :> renders the documentation for a full core. ++ print-core |: $:{core-name/tape docs/what sut/type con/coil uit/(unit item)} ^- tang =+ [arms chapters]=(arm-and-chapter-overviews sut con core-name) ;: weld (print-header (trip (fall p.r.con '')) q.r.con) :: :: todo: figure out how to display the default arm, which should :: be rendered separately. :: ?~ arms ~ (print-overview [%header `['arms:' ~] arms]~) :: ?~ chapters ~ (print-overview [%header `['chapters:' ~] chapters]~) :: =+ compiled=(item-as-overview uit) ?~ compiled ~ (print-overview [%header `['compiled against:' ~] compiled]~) == :: :> figures out which {what}s to use. :> :> there are three places with a relevant {what}: the {arm-doc} on the :> arm, the {what} in the computed type of the foot, and the {what} on :> the product of the default arm when the computed type is a core. ++ select-arm-docs |= {arm-doc/what f/foot sut/type} :> the computed arm documentation and the product documentation. ^- {what what} =+ foot-type=(~(play ut sut) p.f) =/ raw-product/what (what-from-type foot-type) =/ product-product/what ?. ?=({$core *} foot-type) ~ =* inner-type (~(play ut foot-type) [%limb %$]) (what-from-type inner-type) :- ?~ arm-doc ?~ raw-product product-product raw-product arm-doc ?~ arm-doc product-product raw-product :: :> renders the documentation for a single arm in a core. ++ print-arm |= {arm-name/tape arm-doc/what f/foot sut/type} :: todo: need to get the sample here. also hoist this to the general :: core printing machinery, too. =+ [main-doc product-doc]=(select-arm-docs arm-doc f sut) %+ weld (print-header arm-name main-doc) ?~ product-doc ~ %+ weld `tang`[[%leaf ""] [%leaf "product:"] ~] (print-header "" product-doc) :: :> renders the documentation for a chapter in a core. ++ print-chapter |= {name/tape doc/what sut/type con/coil chapter-id/@} ;: weld (print-header name doc) :: ?~ doc ~ (print-sections q.u.doc) :: =+ arms=(arms-in-chapter sut con chapter-id) ?~ arms ~ (print-overview [%header `['arms:' ~] arms]~) == :: :> renders the documentation for a face. ++ print-face |= {name/tape doc/what children/(unit item)} %+ weld (print-header name doc) ?~ children ~ (print-item u.children) :: :> returns a set of lines from a {chap} ++ print-header |= {name/tape doc/what} ^- tang ?~ name ?~ doc [%leaf "(Undocumented)"]~ %+ weld `tang`[%leaf "{(trip p.u.doc)}"]~ (print-sections q.u.doc) ?~ doc [%leaf name]~ %+ weld `tang`[%leaf "{name}: {(trip p.u.doc)}"]~ (print-sections q.u.doc) :: :> renders an overview as {tang} ++ print-overview |: ovr=$:overview ^- tang |^ (print-level ovr 0) ++ print-level :> indentation: multiply by 2 to get number of spaces. |: $:{ovr/overview indentation/@u} ^- tang :> max-key-length: length of the longest {item} term. =/ max-key-length (calculate-max-key-length ovr) :> output: what we return =| output/tang |- ?~ ovr output ?- i.ovr :: {$header *} %= $ output ;: weld output ?~ doc.i.ovr ~ `tang`[[%leaf ""] [%leaf "{(trip p.u.doc.i.ovr)}"] ~] ?~ doc.i.ovr ~ (print-sections q.u.doc.i.ovr) (print-level children.i.ovr (add 1 indentation)) == ovr t.ovr == :: {$item *} =* rendered (render-item indentation max-key-length +.i.ovr) %= $ output (weld output rendered) ovr t.ovr == == :: :> ++ calculate-max-key-length |: ovr=$:overview ^- @u %- dy-longest-tape (turn ovr get-overview-name) :: :> renders a single item line with the given indentation level. ++ render-item |= {indentation/@u max-key-length/@u name/tape doc/what} ^- tang =+ spaces=(mul indentation 2) =+ line=(weld (dy-build-space spaces) name) =* line-len (lent line) =* name-len (lent name) =+ diff=(sub max-key-length name-len) =? line (gth diff 0) (weld line (dy-build-space diff)) =/ slogan/tape ?~ doc ~ (trip p.u.doc) =? line !=(0 (lent slogan)) ;: weld line " : " (dy-truncate (sub 80 :(add 1 spaces line-len)) slogan) == [%leaf line]~ -- :: :> renders a list of sections as {tang} :> :> prints the longform documentation. ++ print-sections |= sections/(list sect) ^- tang =| output/tang |- ?~ sections output =. output ;: weld output `tang`[%leaf ""]~ (print-section i.sections) == $(sections t.sections) :: :> renders an individual {sect} to a {tang} ++ print-section |= section/sect ^- tang %+ turn section |= pica ^- tank ?: p [%leaf (trip q)] [%leaf " {(trip q)}"] -- :: :> truncates `t` down to `i` characters, adding an ellipsis. ++ dy-truncate :: todo: when ~palfun's string library is landed, switch to his :: implementation. |= {i/@u t/tape} ^- tape =+ t-len=(lent t) ?: (lth t-len i) t :(weld (scag (sub i 4) t) "...") :: :> creates a tape of i spaces, used for padding. ++ dy-build-space :: todo: when ~palfun's string library is landed, switch to his :: implementation. |= i/@u ^- tape =| t/tape |- ?: =(0 i) t $(t (weld " " t), i (sub i 1)) :: :> returns the length of the longest tape in c. ++ dy-longest-tape |= c/(list tape) =| ret/@ud |- ?~ c ret =+ l=(lent i.c) ?: (gth l ret) $(ret l, c t.c) $(c t.c) :: ++ dy-show-type-noun |= a/type ^- tank =- >[-]< |- ^- $? $% {$atom @tas (unit @)} {$cell _$ _$} {$cube * _$} {$face {what $@(term tune)} _$} {$fork (set _$)} {$hold _$ hoon} == wain :: "<|core|>" $?($noun $void) == ?+ a a {?($cube $face) ^} a(q $(a q.a)) {$cell ^} a(p $(a p.a), q $(a q.a)) {$fork *} a(p (silt (turn ~(tap in p.a) |=(b/type ^$(a b))))) {$form *} !! {$help *} !! {$core ^} `wain`/core {$hold *} a(p $(a p.a)) == :: :: XX needs filter :: :: ++ dy-shown :: $? hoon :: $^ {dy-shown dy-shown} :: $% {$ur (unit knot) purl:eyre} :: {$sa mark} :: {$as mark dy-shown} :: {$do hoon dy-shown} :: {$ge path (list dy-shown) (map term (unit dy-shown))} :: {$dv path} :: == :: == :: :: :: ++ dy-show-source :: |= a/dojo-source ^- tank :: =- >[-]< :: =+ `{@ bil/dojo-build}`a :: |- ^- dy-shown :: ?- -.bil :: $?($ur $dv $sa) bil :: $ex ?. ?=({$cltr *} p.bil) p.bil :: |- ^- hoon :: ?~ p.p.bil !! :: ?~ t.p.p.bil i.p.p.bil :: [i.p.p.bil $(p.p.bil t.p.p.bil)] :: $tu ?~ p.bil !! :: |- :: ?~ t.p.bil ^$(bil q.i.p.bil) :: [^$(bil q.i.p.bil) $(p.bil t.p.bil)] :: $as bil(q $(bil q.q.bil)) :: $do bil(q $(bil q.q.bil)) :: $ge :+ %ge q.p.p.bil :: [(turn p.q.p.bil ..$) (~(run by q.q.p.bil) (lift ..$))] :: == :: ++ dy-edit :: handle edit |= cal/sole-change ^+ +>+> =^ dat say (~(transceive ^sole say) cal) ?: |(?=(^ per) ?=(^ pux) ?=(~ pro)) ~& %dy-edit-busy =^ lic say (~(transmit ^sole 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)) $clr dy-stop == :: ++ 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 [%$ %noun vax]) :: vase to silk ++ dy-silk-sources :: arglist to silk |= src/(list dojo-source) ^- silk:ford %- dy-silk-vase |- ?~ src !>(~) (slop (dy-vase p.i.src) $(src t.src)) :: ++ dy-silk-config :: configure |= {cay/cage cig/dojo-config} ^- {wire silk:ford} ?. (~(nest ut [%cell [%atom %$ ~] %noun]) | p.q.cay) :: :: naked gate :: ?. &(?=({* ~} p.cig) ?=(~ q.cig)) ~|(%one-argument !!) :- /noun :+ %call (dy-silk-vase q.cay) (dy-silk-vase (dy-vase p.i.p.cig)) :: :: normal generator :: :- ?+ -.q.q.cay ~|(%bad-gen ~_((sell (slot 2 q.cay)) !!)) $say /gent $ask /dial $get /scar == =+ gat=(slot 3 q.cay) :+ %call (dy-silk-vase gat) :+ (dy-silk-vase !>([now=now.hid eny=eny.hid bec=he-beak])) (dy-silk-sources p.cig) :+ %mute (dy-silk-vase (fall (slew 27 gat) !>(~))) %+ turn ~(tap by q.cig) |= {a/term b/(unit dojo-source)} ^- (pair wing silk:ford) :- [a ~] %- dy-silk-vase ?~(b !>([~ ~]) (dy-vase p.u.b)) :: ++ dy-hoon-head :: dynamic state :: todo: how do i separate the toplevel 'dojo state' comment? :> dojo state :> :> our: the name of this urbit :> now: the current time :> eny: a piece of random entropy :> ^- cage :- %noun =+ sloop=|=({a/vase b/vase} ?:(=(*vase a) b ?:(=(*vase b) a (slop a b)))) %+ sloop %- ~(rep by var) |= {{a/term @ b/vase} c/vase} ^- vase (sloop b(p face+[[~ a] p.b]) c) !>([our=our now=now eny=eny]:hid) :: ++ dy-made-dial :: dialog product |= cag/cage ^+ +>+> ?. ?=(^ q.q.cag) (dy-errd ~ 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) [%limb %q])) =+ pom=(sole-prompt +<.q.vax) [%pro pom(cad [':' ' ' cad.pom])] == :: ++ dy-made-scar :: scraper product |= cag/cage ^+ +>+> ?. ?=(^ q.q.cag) (dy-errd ~ q.q.cag) =+ tan=((list tank) +2.q.q.cag) =. +>+>.$ (he-diff %tan tan) =+ vax=(spec (slot 3 q.cag)) ~_ (sell q.cag) ?+ -.q.vax !! %& ?~ +.q.vax ~& %dy-made-scar-abort (dy-rash %bel ~) (dy-meal (slot 7 vax)) :: %| => .(vax (slap vax !,(*hoon ?>(?=(%| -) .)))) :: XX working spec #72 =+ typ={%| (unit knot) hiss:eyre *} =+ [~ usr hiz ~]=((dy-cast typ !>($:typ)) vax) =. ..dy (he-diff %tan leaf+"< {(en-purl:html p.hiz)}" ~) (dy-eyre(pro `(slap (slot 15 vax) limb+%r)) /scar usr hiz) == :: ++ dy-sigh-scar :: scraper result |= dat/cage ?~ pro ~& %dy-no-scraper (dy-show dat) (dy-slam(pux ~) /scar u.pro q.dat) :: ++ dy-made-gent :: generator product |= cag/cage (dy-meal q.cag) :: ++ dy-made-noun :: generator product |= cag/cage (dy-hand %noun q.cag) :: ++ dy-make :: build step ^+ +> ?> ?=(^ cud) =+ bil=q.u.cud :: XX =* ?: ?=($ur -.bil) (dy-eyre /hand p.bil [q.bil %get ~ ~]) %- dy-ford ^- (pair path silk:ford) ?- -.bil $ge (dy-silk-config (dy-cage p.p.p.bil) q.p.bil) $dv [/hand [%core he-beak (flop p.bil)]] $ex [/hand (dy-mare p.bil)] $sa [/hand [%bunt p.bil]] $as [/hand [%cast p.bil [%$ (dy-cage p.q.bil)]]] $do [/hand [%call (dy-mare p.bil) [%$ (dy-cage p.q.bil)]]] $tu :- /hand :- %$ :- %noun |- ^- vase ?~ p.bil !! =+ hed=(dy-vase p.i.p.bil) ?~ t.p.bil hed (slop hed $(p.bil t.p.bil)) == :: ++ dy-hoon-mark :: XX architect =+ ^= ope |= gen/hoon ^- hoon ?: ?=(?($sggl $sggr) -.gen) $(gen q.gen) =+ ~(open ap gen) ?.(=(gen -) $(gen -) gen) |= gen/hoon ^- (unit mark) =. gen (ope gen) ?: ?=({$cnts {@ ~} ~} gen) (bind (~(get by var) i.p.gen) head) ~ :: ++ dy-mare :: build expression |= gen/hoon ^- silk:ford =+ too=(dy-hoon-mark gen) =- ?~(too - [%cast u.too -]) :+ %ride gen :- [%$ dy-hoon-head] [%plan he-beam blob+** [zuse sur lib ~ ~]] :: ++ dy-step :: advance project |= nex/@ud ^+ +>+> ?> ?=(~ cud) ?: ?=({$show $3} -.mad) he-easter:dy-over ?: =(nex num) he-easter:dy-over dy-make(cud `[nex (~(got by job) nex)]) -- :: ++ he-dope :: sole user of ++dp |= txt/tape :: ^- (each (unit (each dojo-command tape)) hair) :: prefix+result =+ len=+((lent txt)) :: line length =. txt (weld buf `tape`(weld txt "\0a")) :: =+ vex=((full dp-command-line):dp [1 1] txt) :: ?: =(q.p.vex len) :: matched to line end [%& ~] :: ?: =(p.p.vex +((lent (skim txt |=(a/@ =(10 a)))))) :: parsed all lines [%& ~ ?~(q.vex [%| txt] [%& p.u.q.vex])] :: new buffer+complete [%| p.p.vex (dec q.p.vex)] :: syntax error :: ++ he-duke :: ++he-dope variant |= txt/tape ^- (each (unit (each dojo-command tape)) @ud) =+ foy=(he-dope txt) ?- -.foy %| [%| q.p.foy] %& [%& p.foy] == :: ++ he-easter :: hint messages ^+ . =. egg +(egg) =- ?~(msg ..he-diff (he-diff %tan leaf+u.msg ~)) ^- msg/(unit tape) ?+ (clan:title our.hid) ~ $pawn ?+ egg ~ $5 `":: To request a planet, run |ask 'your@email.co'" == == :: ++ he-abet :: resolve [(flop moz) %_(+> hoc (~(put by hoc) ost.hid +<+))] :: ++ he-abut :: discard => he-stop [(flop moz) %_(+> hoc (~(del by hoc) ost.hid))] :: ++ he-beak -:he-beam ++ he-beam :: logical beam ^- beam ?. =(ud+0 r.dir) dir dir(r [%da now.hid]) :: ++ he-card :: emit gift |= cad/card ^+ +> %_(+> moz [[ost.hid 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 |=(pax/path ?>(=(~ pax) he-prom)) :: ++ he-pine :: restore prompt ^+ . ?^ poy . he-prom:he-pone :: ++ he-errd :: reject update |= {rev/(unit sole-edit) err/@u} ^+ +> =+ red=(fall rev [%nop ~]) :: required for error location sync =^ lic say (~(transmit ^sole say) red) (he-diff %mor [%det lic] [%err err] ~) :: ++ he-pone :: clear prompt ^+ . =^ cal say (~(transmit ^sole say) [%set ~]) (he-diff %mor [%det cal] ~) :: ++ he-prow :: where we are ^- tape ?: &(=(our.hid p.dir) =(%home q.dir) =([%ud 0] r.dir) =(~ s.dir)) ~ %+ weld ?: &(=(our.hid p.dir) =([%ud 0] r.dir)) (weld "/" (trip q.dir)) ;: weld "/" ?:(=(our.hid p.dir) "=" (scow %p p.dir)) "/" ?:(=(%home q.dir) "=" (trip q.dir)) "/" ?:(=([%ud 0] r.dir) "=" (scow r.dir)) == ?:(=(~ s.dir) "" (spud (flop s.dir))) :: ++ he-prom :: send prompt %- he-diff :- %pro [& %$ (weld he-prow ?~(buf "> " "< "))] :: ++ he-made :: result from ford |= {way/wire dep/@uvH reg/gage:ford} ^+ +> ?> ?=(^ poy) =< he-pine ?- -.reg %& %. p.reg =+ dye=~(. dy u.poy(pux ~)) ?+ way !! {$hand ~} dy-hand:dye {$dial ~} dy-made-dial:dye {$gent ~} dy-made-gent:dye {$noun ~} dy-made-noun:dye {$scar ~} dy-made-scar:dye {$edit ~} dy-made-edit:dye == %| (he-diff(poy ~) %tan p.reg) $tabl !! == :: ++ he-sigh :: result from eyre |= {way/wire hit/httr:eyre} ^+ +> ?> ?=(^ poy) =< he-pine %. [%httr !>(hit)] =+ dye=~(. dy u.poy(pux ~)) ?+ way !! {$hand ~} dy-hand:dye {$show ~} dy-show:dye {$scar ~} dy-sigh-scar:dye == :: ++ he-unto :: result from behn |= {way/wire cit/cuft:gall} ^+ +> ?. ?=($coup -.cit) ~& [%strange-unto 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 ^sole say) cal) ?. ?& ?=($del -.dat) =(+(p.dat) (lent buf.say)) == +>.$ =+ foy=(he-dope (tufa buf.say)) ?: ?=(%& -.foy) +>.$ :: ~& [%bad-change dat ted.cal] :: ~& [%our-leg leg.say] (he-errd `dat q.p.foy) :: ++ he-plan :: execute command |= mad/dojo-command ^+ +> ?> ?=(~ poy) he-pine:(dy-step:~(dy-init dy %*(. *dojo-project mad mad)) 0) :: ++ he-done :: parse command |= txt/tape ^+ +> ?~ txt =< he-prom(buf ~) %- he-diff :~ %mor [%txt "> "] [%nex ~] == =+ doy=(he-duke txt) ?- -.doy %| (he-errd ~ p.doy) %& ?~ p.doy (he-errd ~ (lent txt)) =+ old=(weld ?~(buf "> " " ") (tufa buf.say)) =^ cal say (~(transmit ^sole say) [%set ~]) =. +>.$ (he-diff %mor txt+old nex+~ det+cal ~) ?- -.u.p.doy %& (he-plan(buf ~) p.u.p.doy) %| he-prom(buf p.u.p.doy) == == :: ++ 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)) $clr he-pine(buf "") == :: ++ he-lens |= com/command:lens ^+ +> =+ ^- source/dojo-source =| num/@ =- ?. ?=($send-api -.sink.com) :: XX num is incorrect sor :- 0 :+ %as `mark`(cat 3 api.sink.com '-poke') :- 1 :+ %do :^ %brtr [~ ~] [%base %noun] :^ %clls [%rock %tas %post] [%rock %$ endpoint.sink.com] [%cnts ~[[%.y 6]] ~] sor ^= sor |- ^- dojo-source :- num ?- -.source.com $data [%ex %sand %t data.source.com] $dojo %+ rash command.source.com (ifix [(punt gap) (punt gap)] dp-build:dp) :: $clay :- %ex :* %dtkt [%base %noun] :+ %clhp [%rock %tas %cx] %+ rash pax.source.com rood:(vang | /(scot %p our.hid)/home/(scot %da now.hid)) == :: $url [%ur `~. url.source.com] $api !! $get-api :* %ex %dtkt [%bcmc [%wing ~[%json]]] :* %clsg [%rock %tas %gx] [%sand %ta (scot %p our.hid)] [%sand %tas api.source.com] [%sand %ta (scot %da now.hid)] (turn endpoint.source.com |=(a/@t [%sand %ta a])) == == :: $listen-api !! $as :* %as mar.source.com $(num +(num), source.com next.source.com) == :: $hoon :* %do %+ rash code.source.com tall:(vang | /(scot %p our.hid)/home/(scot %da now.hid)) $(num +(num), source.com next.source.com) == :: $tuple :- %tu |- ^- (list dojo-source) ?~ next.source.com ~ =. num +(num) :- ^$(source.com i.next.source.com) $(next.source.com t.next.source.com) == =+ |- ^- sink/dojo-sink ?- -.sink.com $stdout [%show %0] $output-file $(sink.com [%command (cat 3 '@' pax.sink.com)]) $output-clay [%file (need (de-beam pax.sink.com))] $url [%http %post `~. url.sink.com] $to-api !! $send-api [%poke our.hid api.sink.com] $command (rash command.sink.com dp-sink:dp) $app [%poke our.hid app.sink.com] == (he-plan sink source) :: ++ he-lame :: handle error |= {wut/term why/tang} ^+ +> %- (slog (flop `tang`[>%dojo-lame wut< why])) ?^ poy he-pine:~(dy-amok dy u.poy) he-pine :: XX give mean to original keystroke -- :: ++ prep |= old/(unit house) ^+ [~ ..prep] ?~ old `..prep `..prep(+<+ u.old) :: :: pattern: ++ foo |=(data he-abet:(~(he-foo he (~(got by hoc) ost)) data)) ++ arm (arm-session ~ (~(got by hoc) ost.hid)) ++ arm-session |= {moz/(list move) ses/session} => ~(. he moz ses) =- [wrap=- +] =+ he-arm=he-type |% +- $ |: +<.he-arm ^- (quip move _..he) he-abet:(he-arm +<) -- :: ++ peer-sole ~? !=(our.hid src.hid) [%dojo-peer-stranger ost.hid src.hid] ?> (team:title our.hid src.hid) =^ moz . ?. (~(has by hoc) ost.hid) [~ .] ~& [%dojo-peer-replaced ost.hid] ~(he-abut he ~ (~(got by hoc) ost.hid)) =+ ses=%*(. *session -.dir [our.hid %home ud+0]) (wrap he-peer):(arm-session moz ses) :: ++ poke-sole-action |= act/sole-action ~| poke+act %. act (wrap he-type):arm :: ++ poke-lens-command |= com/command:lens ~| poke-lens+com %. com (wrap he-lens):arm :: ++ poke-json |= jon/json ^- {(list move) _+>.$} ~& jon=jon [~ +>.$] :: ++ made (wrap he-made):arm ++ sigh-httr (wrap he-sigh):arm ++ sigh-tang |=({a/wire b/tang} ~|(`term`(cat 3 'sigh-' -.a) (mean b))) ++ lame (wrap he-lame):arm ++ unto (wrap he-unto):arm ++ pull |= {pax/path} ^- (quip move _+>) =^ moz +> ~(he-abut he ~ (~(got by hoc) ost.hid)) [moz +>.$(hoc (~(del by hoc) ost.hid))] --