::  
::::  /hoon/sole/lib
  ::  
/?    310
/-    sole
[. ^sole]
!:
::::
  ::
|_  sole-share                                          ::  shared-state engine
++  abet  +<
++  apply
  |=  ted/sole-edit 
  ^+  +>
  ?-    -.ted
    $del  +>.$(buf (weld (scag p.ted buf) (slag +(p.ted) buf)))
    $ins  +>.$(buf (weld (scag p.ted buf) `_buf`[q.ted (slag p.ted buf)]))
    $mor  |-  ^+  +>.^$
          ?~  p.ted 
            +>.^$ 
          $(p.ted t.p.ted, +>.^$ ^$(ted i.p.ted))
    $nop  +>.$
    $set  +>.$(buf p.ted)
  ==
::
::::
::  ++transmute: symmetric operational transformation.  
::
::  for any sole state +>, obeys
::
::      =+  [x=(transmute a b) y=(transmute b a)]
::      .=  (apply:(apply a) x) 
::          (apply:(apply b) y)
::
++  transmute                                         ::  dex as after sin
  |=  {sin/sole-edit dex/sole-edit}
  ~|  [%transmute sin dex]
  ^-  sole-edit
  ?:  ?=($mor -.sin)
    |-  ^-  sole-edit
    ?~  p.sin  dex
    $(p.sin t.p.sin, dex ^$(sin i.p.sin))
  ::
  ?:  ?=($mor -.dex)
    :-  %mor
    |-  ^-  (list sole-edit)
    ?~  p.dex  ~
    [^$(dex i.p.dex) $(p.dex t.p.dex)]
  ::
  ?:  |(?=($nop -.sin) ?=($nop -.dex))  dex
  ?:  ?=($set -.sin)                    [%nop ~]
  ?:  ?=($set -.dex)                    dex
  ::
  ?-    -.sin
      $del
    ?-  -.dex
      $del  ?:  =(p.sin p.dex)  [%nop ~]
            ?:((lth p.sin p.dex) dex(p (dec p.dex)) dex)
      $ins  ?:((lth p.sin p.dex) dex(p (dec p.dex)) dex)
    ==
  ::  
      $ins
    ?-  -.dex
      $del  ?:((lte p.sin p.dex) dex(p +(p.dex)) dex)
      $ins  ?:  =(p.sin p.dex)     
              ?:((lth q.sin q.dex) dex dex(p +(p.dex)))
            ?:((lte p.sin p.dex) dex(p +(p.dex)) dex)
    ==
  ==   
::
++  commit                                            ::  local change
  |=  ted/sole-edit
  ^-  sole-share
  abet:(apply(own.ven +(own.ven), leg [ted leg]) ted)
::
::::
::  ++inverse: inverse of change in context.
::
::  for any sole state +>, obeys
::      
::      =(+> (apply:(apply a) (inverse a)))
::
++  inverse                                           ::  relative inverse
  |=  ted/sole-edit
  ^-  sole-edit
  =.  ted  ?.(?=({$mor * $~} ted) ted i.p.ted)
  ?-  -.ted
    $del  [%ins p.ted (snag p.ted buf)]
    $ins  [%del p.ted]
    $mor  :-  %mor
          %-  flop
          |-  ^-  (list sole-edit)
          ?~  p.ted  ~
          :-  ^$(ted i.p.ted)
          $(p.ted t.p.ted, +>.^$ (apply i.p.ted))
    $nop  [%nop ~]
    $set  [%set buf]
  ==
::
++  receive                                           ::  naturalize event
  |=  sole-change
  ^-  {sole-edit sole-share}
  ?.  &(=(his.ler his.ven) (lte own.ler own.ven))
    ~&  [%receive-sync his+[his.ler his.ven] own+[own.ler own.ven]]
    !!
  ?>  &(=(his.ler his.ven) (lte own.ler own.ven))
  ?>  |(!=(own.ler own.ven) =(`@`0 haw) =(haw (sham buf)))
  =.  leg  (scag (sub own.ven own.ler) leg)
  ::  ~?  !=(own.ler own.ven)  [%miss-leg leg]
  =+  dat=(transmute [%mor leg] ted)
  ::  ~?  !=(~ leg)  [%transmute from+ted to+dat ~]
  [dat abet:(apply(his.ven +(his.ven)) dat)]
::
++  remit                                             ::  conditional accept
  |=  {cal/sole-change ask/$-((list @c) ?)}
  ^-  {(unit sole-change) sole-share}
  =+  old=buf
  =^  dat  +>+<.$  (receive cal)
  ?:  (ask buf)
    [~ +>+<.$]
  =^  lic  +>+<.$  (transmit (inverse(buf old) dat))
  [`lic +>+<.$]
::
++  transmit                                          ::  outgoing change
  |=  ted/sole-edit
  ^-  {sole-change sole-share}
  [[[his.ven own.ven] (sham buf) ted] (commit ted)]
::
++  transceive                                        ::  receive and invert
  |=  sole-change
  ^-  {sole-edit sole-share}
  =+  old=buf
  =^  dat  +>+<.$  (receive +<.$)
  [(inverse(buf old) dat) +>+<.$]
::
++  transpose                                         ::  adjust position
  |=  pos/@ud
  =+  dat=(transmute [%mor leg] [%ins pos `@c`0])
  ?>  ?=($ins -.dat)
  p.dat
--