complete.hoon

/+  language-server-parser
::  Autocomplete for hoon.
::
=/  debug  &
|%
+*  option  [item]
  [term=cord detail=item]
::
::  Like +rose except also produces line number
::
++  lily
  |*  [los=tape sab=rule]
  =+  vex=(sab [[1 1] los])
  ?~  q.vex
    [%| p=p.vex(q (dec q.p.vex))]
  ?.  =(~ q.q.u.q.vex)
    [%| p=p.vex(q (dec q.p.vex))]
  [%& p=p.u.q.vex]
::
::  Get all the identifiers accessible if this type is your subject.
::
++  get-identifiers
  |=  ty=type
  %-  flop
  |-  ^-  (list (option type))
  ::~&  >>  typ+[ty -:ty]
  ?-    ty
      %noun      ~
      %void      ~
      [%atom *]  ~
      [%cell *]
    %+  weld
      $(ty p.ty)
    $(ty q.ty)
  ::
      [%core *]
    ::~&  >  id+r.p.q.ty
    %-  weld
    :_  ?.  ?=(%gold r.p.q.ty)
          ~
        ::~&  >  gr+[-.p.ty]
    $(ty p.ty)
    ^-  (list (option type))
    %-  zing
    %+  turn  ~(tap by q.r.q.ty)
    |=  [term =tome]
    %+  turn
      ~(tap by q.tome)
    |=  [name=term =hoon]
    ^-  (pair term type)
    ::~&  >>  name+name
    ~|  term=term
    [name ~(play ~(et ut ty) ~[name] ~)]
  ::
      [%face *]
    ?^  p.ty
      ~&  >  here+'face'
      ~&  >  [%ppp p.ty]
      =/  aliases=(list (option type))
        %+  turn
          ~(tap by p.p.ty)
        |=  [name=term hun=(unit hoon)]
        =/  skin  ~(flay ap (need hun))
        ~&  >>  skin+skin
        =/  ale=vase  (~(mint ut ty) %noun (need hun))
        =/  dur=type  -:(slop ale !>(..zuse))
        [name dur]
      ~&  aliases+aliases
      ?~  aliases  ~
      ?~  t.aliases
        $(ty detail.i.aliases)
      aliases

    [p.ty q.ty]~
  ::
      [%fork *]
    %=    $
        ty
      =/  tines  ~(tap in p.ty)
      ?~  tines
        %void
      |-  ^-  type
      ?~  t.tines
        i.tines
      (~(fuse ut $(tines t.tines)) i.tines)
    ==
  ::
      [%hint *]  $(ty q.ty)
      [%hold *]  $(ty ~(repo ut ty))
  ==
::
++  search-exact
  |*  [sid=term options=(list (option))]
  =/  match
    %+  skim  options
    |=  [id=cord *]
    =(sid id)
  ?~  match
    ~
  [~ i.match]
::
::  Get all the identifiers that start with sid.
::
++  search-prefix
  |*  [sid=cord ids=(list (option))]
  ~&  >>  sid+sid
  ^+  ids
  %+  skim  ids
  |=  [id=cord *]
  ^-  ?(%.y %.n)
  =(sid (end [3 (met 3 sid)] id))
::
::  Get the longest prefix of a list of identifiers.
::
++  longest-match
  |=  matches=(list (option))
  ^-  cord
  ?~  matches
    ''
  =/  n  1
  =/  last  (met 3 term.i.matches)
  |-  ^-  term
  ?:  (gth n last)
    term.i.matches
  =/  prefix  (end [3 n] term.i.matches)
  ?:  |-  ^-  ?
      ?|  ?=(~ t.matches)
          ?&  =(prefix (end [3 n] term.i.t.matches))
              $(t.matches t.t.matches)
      ==  ==
    $(n +(n))
  (end [3 (dec n)] term.i.matches)
::
::  Run +find-type safely, printing the first line of the stack trace on
::  error.
::
++  find-type-mule
  |=  [sut=type gen=hoon]
  ^-  (unit [term type])
  =/  res  (mule |.((find-type sut gen)))
  ?-  -.res
    %&  p.res
    %|  ((slog (flop (scag 10 p.res))) ~)
  ==
::
::  Get the subject type of the wing where you've put the "magic-spoon".
::
++  find-type
  |=  [sut=type gen=hoon]
  =*  loop  $
  |^
  ^-  (unit [term type])
  ?-    gen
      [%cnts [%magic-spoon ~] *]    `['' sut]
      [%cnts [%magic-spoon @ ~] *]  ~&  >>  gen+[i.t.p.gen sut]  `[i.t.p.gen sut]
      [%cnts [%magic-spoon @ *] *]
    %=  $
      sut      (~(play ut sut) wing+t.t.p.gen)
      t.p.gen  t.p.gen(t ~)
    ==
  ::
      [%cnts [%magic-fork @ ~] *]
    `['' (~(play ut sut) wing+t.p.gen)]
  ::
      [^ *]      (both p.gen q.gen)
      [%brcn *]  (grow q.gen)
      [%brpt *]  (grow q.gen)
      [%cnts *]
    ?^  a=(find [%magic-spoon ~] p.gen)
      $(p.gen (slag u.a p.gen))
    |-  ^-  (unit [term type])
    =*  inner-loop  $
    ?~  q.gen
      ~
    %+  replace
      loop(gen q.i.q.gen)
    |.  inner-loop(q.gen t.q.gen)
  ::
      [%dtkt *]  (spec-and-hoon p.gen q.gen)
      [%dtls *]  loop(gen p.gen)
      [%rock *]  ~
      [%sand *]  ~
      [%tune *]   ~

      [%dttr *]  (both p.gen q.gen)
      [%dtts *]  (both p.gen q.gen)
      [%dtwt *]  loop(gen p.gen)
      [%hand *]  ~
      [%ktbr *]  loop(gen p.gen)
      [%ktls *]  (both p.gen q.gen)
      [%ktpm *]  loop(gen p.gen)
      [%ktsg *]  loop(gen p.gen)
      [%ktwt *]  loop(gen p.gen)
      [%note *]  loop(gen q.gen)
      [%sgzp *]  (both p.gen q.gen)
      [%sggr *]  loop(gen q.gen)  ::  should check for hoon in p.gen
      [%tsgr *]  (change p.gen q.gen)
      [%tscm *]
    %+  replace
      loop(gen p.gen)
    |.(loop(gen q.gen, sut (~(busk ut sut) p.gen)))
  ::
      [%wtcl *]  (bell p.gen q.gen r.gen)
      [%fits *]  (both p.gen wing+q.gen)
      [%wthx *]  loop(gen wing+q.gen)
      [%dbug *]  loop(gen q.gen)
      [%zpcm *]  (both p.gen q.gen)
      [%lost *]  loop(gen p.gen)
      [%zpmc *]  (both p.gen q.gen)
      [%zpts *]  loop(gen p.gen)
      [%zppt *]  (both q.gen r.gen)
      [%zpgl *]  (spec-and-hoon p.gen q.gen)
      [%zpzp *]  ~
      *
    =+  doz=~(open ap gen)
    ?:  =(doz gen)
      ~_  (show [%c 'hoon'] [%q gen])
      ~>  %mean.'play-open'
      !!
    loop(gen doz)
  ==
  ::
  ++  replace
    |=  [a=(unit [term type]) b=(trap (unit [term type]))]
    ^-  (unit [term type])
    ?~(a $:b a)
  ::
  ++  both
    |=  [a=hoon b=hoon]
    (replace loop(gen a) |.(loop(gen b)))
  ::
  ++  bell
    |=  [a=hoon b=hoon c=hoon]
    %+  replace  loop(gen a)
    |.  %+  replace  loop(gen b, sut (~(gain ut sut) a))
    |.  loop(gen c, sut (~(lose ut sut) a))
  ::
  ++  spec-and-hoon
    |=  [a=spec b=hoon]
    (replace (find-type-in-spec sut a) |.(loop(gen b)))
  ::
  ++  change
    |=  [a=hoon b=hoon]
    (replace loop(gen a) |.(loop(gen b, sut (~(play ut sut) a))))
  ::
  ++  grow
    |=  m=(map term tome)
    =/  tomes  ~(tap by m)
    |-  ^-  (unit [term type])
    =*  outer-loop  $
    ?~  tomes
      ~
    =/  arms  ~(tap by q.q.i.tomes)
    |-  ^-  (unit [term type])
    =*  inner-loop  $
    ?~  arms
      outer-loop(tomes t.tomes)
    %+  replace
      loop(gen q.i.arms, sut (~(play ut sut) gen))
    |.  inner-loop(arms t.arms)
  --
::
::  Not implemented yet.  I wonder whether we should modify types found
::  in spec mode such that if it's a mold that produces a type, it
::  should just display the type and not that it's technically a
::  function.
::
++  find-type-in-spec
  |=  [sut=type pec=spec]
  ^-  (unit [term type])
  ~
::
++  get-id-sym
  |=  [pos=@ud =tape]
  %^  get-id  pos  tape
  ^-  $-(nail (like (unit @t)))
  ;~(sfix (punt sym) (star ;~(pose prn (just `@`10))))
::
++  get-id-cord
   |=  [pos=@ud =tape]
   %^  get-id  pos  tape
   ^-  $-(nail (like (unit @t)))
   ;~(sfix (punt (cook crip (star prn))) (star ;~(pose prn (just `@`10))))
::
++  get-id
  |=  [pos=@ud txt=tape seek=$-(nail (like (unit @t)))]
  ^-  [forward=(unit @t) backward=(unit @t) id=(unit @t)]
  =/  forward=(unit @t)
    (scan (slag pos txt) seek)
  =/  backward=(unit @t)
    %-  (lift |=(t=@t (swp 3 t)))
    (scan (flop (scag pos txt)) seek)
  =/  id=(unit @t)
    ?~  forward
      ?~  backward
        ~
      `u.backward
    ?~  backward
      `u.forward
    `(cat 3 u.backward u.forward)
  [forward backward id]
::
::  Insert magic marker in hoon source at the given position.
::
++  insert-magic
  |=  [pos=@ud txt=tape]
  ^-  [back-pos=@ud fore-pos=@ud txt=tape]
  ::  Find beg-pos by searching backward to where the current term
  ::  begins
  =+  (get-id-sym pos txt)
  =/  back-pos
    ?~  backward
      pos
    (sub pos (met 3 u.backward))
  =/  fore-pos
    ?~  forward
      pos
    (add pos (met 3 u.forward))
  :+  back-pos  fore-pos
  ::  Insert "magic-spoon" marker so +find-type can identify where to
  ::  stop.
  ::
  ;:  weld
    (scag back-pos txt)
    ?:  &(?=(~ id) ?=([%'.' *] (slag pos txt)))
      "magic-fork"
    "magic-spoon"
    ?~  id
      ""
    "."
    (slag back-pos txt)
    "\0a"
  ==
::
::  Produce the longest possible advance without choosing between
::  matches.
::
::    Takes a +hoon which has already has a magic-spoon marker.  Useful if
::    you want to handle your own parsing.
::
++  advance-hoon
  |=  [sut=type gen=hoon]
  %+  bind  (find-type-mule sut gen)
  |=  [id=term typ=type]
  =/  matches=(list (option type))
    (search-prefix id (get-identifiers typ))
  (longest-match matches)
::
::  Same as +advance-hoon, but takes a position and text directly.
::
++  advance-tape
  |=  [sut=type pos=@ud code=tape]
  (advance-hoon sut (scan txt:(insert-magic pos code) vest))
::
::  Produce a list of matches.
::
::    Takes a +hoon which has already has a magic-spoon marker.  Useful if
::    you want to handle your own parsing.
::
++  tab-list-hoon
  |=  [sut=type gen=hoon]
  ^-  (unit (list (option type)))
  %+  bind  (find-type-mule sut gen)
  |=  [id=term typ=type]
  (search-prefix id (get-identifiers typ))
::
::  Same as +advance-hoon, but takes a position and text directly.
::
++  tab-list-tape
  |=  [sut=type pos=@ud code=tape]
  ^-  (each (unit (list (option type))) [row=@ col=@])
  ~?  >  debug  %start-magick
  =/  magicked  txt:(insert-magic pos code)
  ~?  >  debug  %start-parsing
  =/  res  (lily magicked (language-server-parser *path))
  ?:  ?=(%| -.res)
    ~?  >  debug  [%parsing-error p.res]
    [%| p.res]
  :-  %&
  ~?  >  debug  %parsed-good
  ((cury tab-list-hoon sut) hoon:`pile:clay`p.res)
::
:: Generators
++  tab-generators
  |=  [pfix=path app=(unit term) gens=(list term)]
  ^-  (list (option tank))
  %+  turn  gens
  |=  gen=term
  ^-  (option tank)
  =/  pax=path
    (weld pfix ~[gen %hoon])
  =/  file
    .^(@t %cx pax)
  :_  (render-help file)
  ?~  app
    (cat 3 '+' gen)
  ?:  =(%hood u.app)
    (cat 3 '|' gen)
  :((cury cat 3) ':' u.app '|' gen)
::  Stolen from +help
++  render-help
  |=  a=@t
  ^-  tank
  :-  %leaf
  =/  c  (to-wain:format a)
  ?~  c  "~"
  ?.  =('::  ' (end [3 4] i.c))
    "<undocumented>"
  (trip i.c)
--

language-server.hoon

/-  lsp-sur=language-server
/+  *server,
    auto=language-server-complete,
    lsp-parser=language-server-parser,
    easy-print=language-server-easy-print,
    rune-snippet=language-server-rune-snippet,
    build=language-server-build,
    default-agent, verb, dbug
|%
+$  card  card:agent:gall
+$  lsp-req
  $:  uri=@t
      $%  [%sync changes=(list change)]
          [%completion position]
          [%commit @ud]
          [%hover position]
      ==
  ==
::
+$  change
  $:  range=(unit range)
      range-length=(unit @ud)
      text=@t
  ==
::
+$  range
  $:  start=position
      end=position
  ==
::
+$  position
  [row=@ud col=@ud]
::
+$  state-zero
  $:  %0
      bufs=(map uri=@t buf=wall)
      builds=(map uri=@t =vase)
      ford-diagnostics=(map uri=@t (list diagnostic:lsp-sur))
      preludes=(map uri=@t type)
  ==
+$  versioned-state
  $%
    state-zero
  ==
--
^-  agent:gall
%-  agent:dbug
%+  verb  |
=|  state-zero
=*  state  -
=<
  |_  =bowl:gall
  +*  this      .
      lsp-core  +>
      lsp       ~(. lsp-core bowl)
      def       ~(. (default-agent this %|) bowl)
  ::
  ++  on-init
    ^+  on-init:*agent:gall
    ^-  (quip card _this)
    ~&  >  %lsp-init
    :_  this  :_  ~
    :*  %pass  /connect
        %arvo  %e
        %connect  [~ /'~language-server-protocol']  %language-server
    ==
  ::
  ++  on-save   !>(state)
  ++  on-load
    ^+  on-load:*agent:gall
    |=  old-state=vase
    ^-  (quip card _this)
    ~&  >  %lsp-upgrade
    [~ this(state !<(state-zero old-state))]
  ::
  ++  on-poke
    ^+  on-poke:*agent:gall
    |=  [=mark =vase]
    ^-  (quip card _this)
    =^  cards  state
      ?+    mark  (on-poke:def mark vase)
          %language-server-rpc-notification
        (on-notification:lsp !<(all:notification:lsp-sur vase))
          %language-server-rpc-request
        (on-request:lsp !<(all:request:lsp-sur vase))
      ==
    [cards this]
  ::
  ++  on-watch
    |=  =path
    ?:  ?=([%primary ~] path)
      `this
    ?.  ?=([%http-response @ ~] path)
      (on-watch:def path)
    `this
  ++  on-leave  on-leave:def
  ++  on-peek  on-peek:def
  ++  on-agent  on-agent:def
  ++  on-arvo
    ^+  on-arvo:*agent:gall
    |=  [=wire =sign-arvo]
    ^-  (quip card _this)
    =^  cards  state
      ?+  sign-arvo  (on-arvo:def wire sign-arvo)
        [%eyre %bound *]  `state
        [%clay *]  (handle-build:lsp wire +.sign-arvo)
      ==
    [cards this]
  ::
  ++  on-fail   on-fail:def
  --
::
|_  bow=bowl:gall
::
++  json-response
  |=  [eyre-id=@ta jon=json]
  ^-  (list card)
  (give-simple-payload:app eyre-id (json-response:gen jon))
::
++  give-rpc-notification
  |=  res=out:notification:lsp-sur
  ^-  (list card)
  :_  ~
  [%give %fact ~[/primary] %language-server-rpc-notification !>(res)]
::
++  on-notification
  |=  not=all:notification:lsp-sur
  ^-  (quip card _state)
  =^  cards  state
    ?+  -.not  [~ state]
        %text-document--did-open    (handle-did-open +.not)
        %text-document--did-change  (handle-did-change +.not)
        %text-document--did-save    (handle-did-save +.not)
        %text-document--did-close   (handle-did-close +.not)
        %exit                       handle-exit
    ==
  [cards state]
++  on-request
  |=  req=all:request:lsp-sur
  ^-  (quip card _state)
  =^  cards  state
    ?+  -.req  [~ state]
      %text-document--hover       (handle-hover req)
      %text-document--completion  (handle-completion req)
    ==
  [cards state]
::
++  get-subject
  |=  uri=@t
  ^-  type
  (~(gut by preludes) uri -:!>(..zuse))
::
++  handle-completion
  |=  com=text-document--completion:request:lsp-sur
  ^-  (quip card _state)
  :_  state
  %^  give-rpc-response  %text-document--completion  id.com
  =/  buf=wall
    (~(got by bufs) uri.com)
  =/  txt=tape
    (zing (join "\0a" buf))
  =/  pos
    (get-pos buf row.com col.com)
  =/  rune  (rune-snippet (swag [(safe-sub pos 2) 2] txt))
  ?^  rune  rune
  =/  tab-list
    %^  tab-list-tape:auto
      (~(gut by preludes) uri.com -:!>(..zuse))
    pos  txt
  ?:  ?=(%| -.tab-list)  ~
  ?~  p.tab-list  ~
  ?~  u.p.tab-list  ~
  (turn u.p.tab-list make-completion-item)
::
++  make-completion-item
  |=  [name=term =type]
  ^-  completion-item:lsp-sur
  =/  doc
    %-  crip
    ;:  weld
      "`"
      ~(ram re ~(duck easy-print type))
      "`"
    ==
  [name 1 doc '' name 1]
::
++  give-rpc-response
  |=  res=all:response:lsp-sur
  ^-  (list card)
  :_  ~
  [%give %fact ~[/primary] %language-server-rpc-response !>(res)]
::
++  handle-exit
  ^-  (quip card _state)
  ~&  >  %lsp-shutdown
  :_  *state-zero
  %+  turn
    ~(tap in ~(key by builds))
  |=  uri=@t
  [%pass /ford/[uri] %arvo %c %warp our.bow %base ~]
::
++  handle-did-close
  |=  [uri=@t version=(unit @)]
  ^-  (quip card _state)
  =.  bufs
    (~(del by bufs) uri)
  =.  ford-diagnostics
    (~(del by ford-diagnostics) uri)
  =.  builds
    (~(del by builds) uri)
  :_  state
  [%pass /ford/[uri] %arvo %c %warp our.bow %base ~]~
::
++  handle-did-save
  |=  [uri=@t version=(unit @)]
  ^-  (quip card _state)
  :_  state
  :_  (give-rpc-notification (get-diagnostics uri))
  :*
    %pass
    /commit
    %agent
    [our.bow %hood]
    %poke
    %kiln-commit
    !>([q.byk.bow |])
  ==
::
++  handle-did-change
  |=  [document=versioned-doc-id:lsp-sur changes=(list change:lsp-sur)]
  ^-  (quip card _state)
  =/  updated=wall
    (sync-buf (~(got by bufs) uri.document) changes)
  =.  bufs
    (~(put by bufs) uri.document updated)
  `state
::
++  handle-build
  |=  [=path =gift:clay]
  ^-  (quip card _state)
  ?>  ?=([%writ *] gift)
  =/  uri=@t
    (snag 1 path)
  =/  loc=^path  (uri-to-path:build uri)
  =;  [res=(quip card _state) dek=desk]
    [(snoc -.res (build-file | uri loc `dek)) +.res]
  ?~  p.gift
    [[~ state] %base]
  =.  builds
    (~(put by builds) uri q.r.u.p.gift)
  =.  ford-diagnostics
    (~(del by ford-diagnostics) uri)
  =/  bek  byk.bow(r da+now.bow)
  =/  desks=(list desk)  ~(tap in .^((set desk) %cd (en-beam bek /)))
  =|  dek=desk
  |-
  ?~  desks  [[~ state] %base]
  =.  dek  ?:  =(%kids i.desks)  %base  i.desks
  =/  exists=?  .^(? %cu (en-beam bek(q dek) loc))
  ?.  exists  $(desks t.desks)
  =+  .^(=open:clay %cs /(scot %p our.bow)/[dek]/(scot %da now.bow)/open/foo)
  =/  =type  -:(open loc)

  =.  preludes
    (~(put by preludes) uri type)
  :_  dek
  :_  state
  (give-rpc-notification (get-diagnostics uri))
::
++  get-diagnostics
  |=  uri=@t
  ^-  out:notification:lsp-sur
  :+  %text-document--publish-diagnostics
    uri
  %+  weld
    (~(gut by ford-diagnostics) uri ~)
  (get-parser-diagnostics uri)
::
++  build-file
  |=  [eager=? uri=@t =path desk=(unit desk)]
  ^-  card
  =/  =rave:clay
    ?:  eager
      [%sing %a da+now.bow path]
    [%next %a da+now.bow path]
  =/  des=^desk  ?^  desk  u.desk  %base
  [%pass /ford/[uri] %arvo %c %warp our.bow des `rave]
::
++  handle-did-open
  |=  item=text-document-item:lsp-sur
  ^-  (quip card _state)
  =/  =path
    (uri-to-path:build uri.item)
  =/  bek  byk.bow
  =/  desks=(list desk)  ~(tap in .^((set desk) %cd (en-beam bek /)))
  =|  dek=desk
  |-
  ?~  desks  [~ state]
  =.  dek  ?:  =(%kids i.desks)  %base  i.desks
  =/  exists=?  .^(? %cu (en-beam bek(q dek) path))
  ?.  exists  $(desks t.desks)
  ::  ?:  ?=(%sys -.path)
  ::    `state
  =/  buf=wall
    (to-wall (trip text.item))
  =.  bufs
    (~(put by bufs) uri.item buf)
  :_  state
  %+  weld
    (give-rpc-notification (get-diagnostics uri.item))
  [(build-file & uri.item path `dek) ~]
::
++  get-parser-diagnostics
  |=  uri=@t
  ^-  (list diagnostic:lsp-sur)
  =/  t=tape
    (zing (join "\0a" `wall`(~(got by bufs) uri)))
  =/  parse
    (lily:auto t (lsp-parser (uri-to-path:build uri)))
  ?.  ?=(%| -.parse)
    ~
  =/  loc=position:lsp-sur
    [(dec -.p.parse) +.p.parse]
  :_  ~
  [[loc loc] 1 'Syntax Error']
::
++  handle-hover
  |=  hov=text-document--hover:request:lsp-sur
  ^-  (quip card _state)
  :_  state
  %^  give-rpc-response  %text-document--hover  id.hov
  =/  buf=wall
    (~(got by bufs) uri.hov)
  =/  txt
    (zing (join "\0a" buf))
  =/  tab-list
    %^  tab-list-tape:auto
        (~(gut by preludes) uri.hov -:!>(..zuse))
      (get-pos buf row.hov col.hov)
    txt
  ?:  ?=(%| -.tab-list)  ~
  ?~  p.tab-list  ~
  ?~  u.p.tab-list  ~
  :-  ~
  =-  (crip :(weld "```hoon\0a" tape "\0a```"))
  ^-  =tape
  %-  zing
  %+  join  "\0a"
  %+  scag  40
  (~(win re ~(duck easy-print detail.i.u.p.tab-list)) 0 140)
::
++  sync-buf
  |=  [buf=wall changes=(list change:lsp-sur)]
  |-  ^-  wall
  ?~  changes
    buf
  ?:  ?|(?=(~ range.i.changes) ?=(~ range-length.i.changes))
    =/  =wain  (to-wain:format text.i.changes)
    =.  buf  (turn wain trip)
    $(changes t.changes)
  =/  =tape      (zing (join "\0a" buf))
  =/  start-pos  (get-pos buf start.u.range.i.changes)
  =/  end-pos    (get-pos buf end.u.range.i.changes)
  =.  tape
    ;:  weld
      (scag start-pos tape)
      (trip text.i.changes)
      (slag end-pos tape)
    ==
  =.  buf  (to-wall tape)
  $(changes t.changes)
::
++  to-wall
  |=  =tape
  ^-  wall
  %+  roll  (flop tape)
  |=  [char=@tD =wall]
  ?~  wall
    [[char ~] ~]
  ?:  =('\0a' char)
    [~ wall]
  [[char i.wall] t.wall]
::
++  get-pos
  |=  [buf=wall position]
  ^-  @ud
  ?~  buf
    0
  ?:  =(0 row)
    col
  %+  add  +((lent i.buf))  ::  +1 because newline
  $(row (dec row), buf t.buf)
::
++  safe-sub
  |=  [a=@ b=@]
  ?:  (gth b a)
    0
  (sub a b)
--