shrub/main/app/shell/core.hook

::    Shell
::
::::  /hook/core/shell/app
  ::
/?    314
/-    term-line
/=    seeb  /~  !>(.)
::
::::  structures
  ::
|%                                                      ::
++  gift                                                ::
  $%  [%rush p=%txt q=cord]                             ::
      [%rush p=%term-line q=term-line]                  ::
      [%mean p=ares]                                    ::
      [%nice ~]                                         ::
      [%meta p=vase]                                    ::
  ==                                                    ::
++  hapt  ,[p=ship q=path]                              ::
++  move  ,[p=bone q=(mold note gift)]                  ::
++  note                                                ::
  $%  $:  %g                                            ::
  $%  [%cide p=span]                                    ::
      [%show p=hapt q=ship r=path]                      ::
      [%sire p=term q=span]                             ::
      [%mess p=hapt q=ship r=cage]                      ::
      [%meta p=vase]                                    ::
  ==  ==  ==                                            ::
++  coma                                                ::
  $%  [%start p=term q=(list twig)]                     ::
      [%end p=(each ,@u cord)]                          ::
      [%path p=path]                                    ::
      [%hoon p=twig]                                    ::
      [%var p=term q=twig]                              ::
      [%rvar p=term]                                    ::
      [%pipe p=term q=(list twig) r=term s=(list twig)] ::
  ==                                                    ::
++  sign                                                ::
  $%  $:  %g                                            ::
  $%  [%gone p=hapt]                                    ::
      [%mean p=ares]                                    ::
      [%nice ~]                                         ::
      [%rush p=mark q=*]                                ::
      [%rust p=mark q=*]                                ::
  ==  ==  ==                                            ::
--
!:
::::  program
  ::
|_  $:  hid=hide
        pid=@u
        pax=_`path`/=try=
        act=(unit span)
        pip=(map span span)
        pop=(map span span)
        var=(map term vase)
    ==
++  maybe
  |*  fel=_rule
  ;~  pose
    fel
    (easy ~)
  ==
::
++  args
  ;~(pfix ace (more ace wide:(vang & pax)))
::
++  pipe
  ;~  plug
    ;~(pfix bar sym)
    (ifix [sel ser] args)
    ;~(pfix bar ;~(plug sym args))
  ==
::
++  parse
  ^-  $+(nail (like coma))
  =+  paf=?.(=('0' &3.pax) pax pax(&3 (scot da/lat.hid)))
  ;~  pose
    (stag %start ;~(pfix col ;~(plug sym (maybe args(pax paf)))))
    (stag %end ;~(pfix sem ;~(pose (stag %& dem) (stag %| sym))))
    (stag %path (sear plex rood):(vang & pax))
    (stag %pipe pipe(pax paf))
    (stag %var ;~(plug ;~(pfix tis sym) ;~(pfix ace tall:(vang & paf))))
    (stag %rvar ;~(pfix ;~(plug tis tis) sym))
    (stag %hoon tall:(vang & paf))
  ==
::
++  peer
  |=  [ost=bone you=ship pax=path]
  ^-  [(list move) _+>]
  ?~  pax  `+>.$
  ?+    i.pax  `+>.$
      %in                                               ::  to app
    ?~  t.pax  `+>.$
    ?.  (~(has by cub.hid) i.t.pax)  `+>.$
    ?:  (~(has by pop) i.t.pax)  `+>.$
    :_  +>.$(act `i.t.pax)
    (print ost you ~)
      %out                                              ::  to terminal
    ?>  ?=(~ t.pax)
    `+>.$
  ==
::
++  cubs
  %-  sort  :_  |=([a=span b=span] (lth (slav %ud a) (slav %ud b)))
  ^-  (list span)
  %+  murn  (~(tap by sup.hid))
  |=  [@ @ a=path] 
  ?.  ?=([%in cord ~] a)  ~
  ?.  (~(has by cub.hid) i.t.a)  ~
  (some i.t.a)
::
++  poke-txt
  |=  [ost=bone you=ship txt=cord]
  ^-  [(list move) _+>]
  ?:  =('\\' (end 3 1 txt))
    ?+    (rsh 3 1 txt)
        :_  +>.$
        :-  [ost %give %nice ~]
        (print ost you leaf/"no command {(trip txt)}" ~)
      %x  =.  act
            =+  ^=  opt
                :-  i=`(unit span)`~
                t=(turn cubs |=(a=span `(unit span)`[~ a]))
            |-
            ?~  t.opt  ~
            ?:  =(act i.opt)
              i.t.opt
            $(opt t.opt)
          :_  +>.$
          :-  [ost %give %nice ~]
          (print ost you ~)
      %l  =+  =-  tak=rose/[" " "[" "]"]^(turn cubs -)
              |=  a=span
              leaf/(trip (rap 3 (~(got by cub.hid) a) '(' a ')' ~))
          [[[ost give/nice/~] (print ost you tak ~)] +>.$]
    ==
  ?^  act
    :_  +>.$
    :-  [ost %give %nice ~]
    (spam /in/[u.act] %rush %txt txt)
  =+  com=(rush txt parse)
  ?~  com
    :_  +>.$
    :-  [ost %give %nice ~]
    (print ost you leaf/"Clarify {(trip txt)}" ~)
  ?-    -.u.com
      %path
    =.  pax  p.u.com
    :_  +>.$
    :-  [ost %give %nice ~]
    (print ost you leaf/"=% {(spud p.u.com)}" ~)
  ::
      %start
    =+  cil=(scot %ud pid)
    =.  pid  +(pid)
    :_  +>.$
    :*  :^  ost  %pass  /child/[cil]/main
        :+  %g  %meta  !>
        :*  %mess  [our.hid cil imp.hid]  you
            (cat 3 p.u.com '-args')  (run [%clsg q.u.com])
        ==
        [ost %pass /child/[cil]/out %g %show [our.hid cil imp.hid] you /out]
        [ost %pass /child/[cil] %g %sire p.u.com cil]       ::  XX strange order?
        (print ost you leaf/"+ :{(trip p.u.com)}" ~)
    ==
  ::
      %end
    :_  +>.$
    ?:  ?=(%& -.p.u.com)
      =+  cil=(scot %ud p.p.u.com)
      =+  cin=(trip (~(got by cub.hid) cil))
      :-  [ost %pass /child/[cil] %g %cide cil]
      (print ost you leaf/"- :{cin}({(trip cil)})" ~)
    =*  cil  p.p.u.com
    =-  %-  welp  :_  mof
        :-  [ost %give %nice ~]
        (print ost you leaf/"-{<(lent mof)>} :{(trip cil)}" ~)
    ^=  mof
    %+  murn  (~(tap by cub.hid))  |=  [a=span b=term]
    ?.  =(b cil)  ~
    %-  some
    [ost %pass /child/[a] %g %cide a]
  ::
      %pipe
    =+  cia=(scot %ud pid)
    =+  cib=(scot %ud +(pid))
    =.  pid  +(+(pid))
    =.  pip  (~(put by pip) cia cib)
    =.  pop  (~(put by pop) cib cia)
    :_  +>.$
    :*  :^  ost  %pass  /child/[cia]/main
        :+  %g  %meta  !>
        :*  %mess  [our.hid cia imp.hid]  you
            (cat 3 p.u.com '-args')  (run [%clsg q.u.com])
        ==
        :^  ost  %pass  /child/[cib]/main
        :+  %g  %meta  !>
        :*  %mess  [our.hid cib imp.hid]  you
            (cat 3 r.u.com '-args')  (run [%clsg s.u.com])
        ==
        [ost %pass /child/[cia]/out %g %show [our.hid cia imp.hid] you /out]
        [ost %pass /child/[cia] %g %sire p.u.com cia]       ::  XX strange order?
        [ost %pass /child/[cib]/out %g %show [our.hid cib imp.hid] you /out]
        [ost %pass /child/[cib] %g %sire r.u.com cib]
        (print ost you leaf/"running {(trip p.u.com)} into {(trip r.u.com)}" ~)
    ==
  ::
      %var
    :_  +>.$(var (~(put by var) p.u.com (run q.u.com)))
    :-  [ost %give %nice ~]
    (print ost you leaf/"created variable '{(trip p.u.com)}'" ~)
  ::
      %rvar
    :_  +>.$(var (~(del by var) p.u.com))
    :-  [ost %give %nice ~]
    (print ost you leaf/"deleted variable '{(trip p.u.com)}'" ~)
  ::
      %hoon
    :_  +>.$
    :-  [ost %give %nice ~]
    (print ost you (sell (run p.u.com)) ~)
  ==
::
++  purr
  |=  [ost=bone pax=path typ=type sih=sign]
  ^-  [(list move) _+>]
  ::  ~&  [%shell-pour -.sih (,@ta +<.sih)]
  ::=+  sih=((hard sign) sih)
  ?~  pax  ~&  %no-path  !!
  ?+    &1.pax  ~&  %strange-path  !!
      %print
    `+>.$
  ::
      %child
    ?~  |1.pax  ~&  %no-child  !!
    ?~  |2.pax
      ?>  ?=(%gone +<.sih)
      :-  [ost %give %nice ~]~
      +>.$(act ?:(=(act [~ &2.pax]) ~ act))
    :_  +>.$
    ?+    &3.pax  ~&  %strange-child-path  !!
        %main
      ?>  ?=(?(%nice %mean) +<.sih)
      [ost %give +.sih]~
        %out
      ?.  ?=(?(%rust %rush) +<.sih)  ~
      ?:  (~(has by pip) &2.pax)
        (spam /in/(~(got by pip) &2.pax) %meta (slot 3 typ sih))
      %^  print-vase  ost  our.hid
      ?+  p.sih 
        !>([(sell (slot 15 [typ sih]))]~)
          %tang
        (slot 15 [typ sih])
    ==
  ==  ==
::
++  print  |=([a=bone b=ship c=(list tank)] (print-vase a b !>(c)))
++  print-vase
  |=  [ost=bone you=ship tan=vase] ::  [p=p:!>(*(list tank)) q=*]
  ^-  (list move)
  =+  ^=  pro
      ?^  act
        (rap 3 (~(got by cub.hid) u.act) '(' u.act ') ' ~)
      ?.  =('0' &3.pax)
        (spat pax)
      (rap 3 '/' &1.pax '/' &2.pax '=' ?~(|3.pax ~ [(spat |3.pax)]~))
  (spam /out %meta :(slop !>(%rust) !>(%term-line) !>(pro) tan))
::
++  run
  |=  gen=twig
  %-  slap  :_  gen
  %+  roll  (~(tap by var))
  =<  .(q seeb)
  |=  [[n=term v=vase] q=vase]
  (slop [[%face n p.v] q.v] q)
::
++  spam
  |=  [pax=path gip=gift]
  ^-  (list move)
  %+  turn
    (~(tap in (~(get ju pus.hid) pax)))
  |=(a=bone [a %give gip])
--