{-# OPTIONS_GHC -fno-warn-orphans #-}

module Ribosome.Control.Monad.Ribo where

import Control.Exception.Lifted (onException)
import Control.Lens (Lens')
import qualified Control.Lens as Lens (mapMOf, over, view)
import Control.Monad.Base (MonadBase(..))
import Control.Monad.Catch (MonadCatch, MonadMask, MonadThrow)
import Control.Monad.Error.Class (MonadError(..))
import qualified Control.Monad.Reader as ReaderT
import Control.Monad.Trans.Free (FreeT)
import Control.Monad.Trans.Resource (MonadResource(..), runResourceT)
import qualified Control.Monad.Trans.State.Strict as StateT (gets, modify)
import Data.DeepLenses (DeepLenses(deepLens))
import Data.DeepPrisms (DeepPrisms)
import Neovim.Context.Internal (Neovim(..))

import Ribosome.Control.Ribosome (Ribosome, RibosomeInternal, RibosomeState)
import qualified Ribosome.Control.Ribosome as Ribosome (_errors, errors, name, state)
import qualified Ribosome.Control.Ribosome as RibosomeState (internal, public)
import Ribosome.Control.StrictRibosome (StrictRibosome)
import qualified Ribosome.Control.StrictRibosome as StrictRibosome (name, state)
import Ribosome.Data.Errors (Errors)
import Ribosome.Nvim.Api.RpcCall (Rpc, RpcError)
import qualified Ribosome.Nvim.Api.RpcCall as Rpc (Rpc(..))
import Ribosome.Orphans ()
import Ribosome.Plugin.RpcHandler (RpcHandler(..))

type RNeovim s = Neovim (Ribosome s)

instance MonadBase IO (Neovim e) where
  liftBase :: IO α -> Neovim e α
liftBase = IO α -> Neovim e α
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO

instance MonadBaseControl IO (Neovim e) where
  type StM (Neovim e) a = a
  liftBaseWith :: (RunInBase (Neovim e) IO -> IO a) -> Neovim e a
liftBaseWith RunInBase (Neovim e) IO -> IO a
f =
    ResourceT (ReaderT (Config e) IO) a -> Neovim e a
forall env a. ResourceT (ReaderT (Config env) IO) a -> Neovim env a
Neovim (ReaderT (Config e) IO a -> ResourceT (ReaderT (Config e) IO) a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (ReaderT (Config e) IO a -> ResourceT (ReaderT (Config e) IO) a)
-> ReaderT (Config e) IO a -> ResourceT (ReaderT (Config e) IO) a
forall a b. (a -> b) -> a -> b
$ (Config e -> IO a) -> ReaderT (Config e) IO a
forall r (m :: * -> *) a. (r -> m a) -> ReaderT r m a
ReaderT ((Config e -> IO a) -> ReaderT (Config e) IO a)
-> (Config e -> IO a) -> ReaderT (Config e) IO a
forall a b. (a -> b) -> a -> b
$ \Config e
r -> RunInBase (Neovim e) IO -> IO a
f (Config e -> Neovim e a -> IO a
forall env a. Config env -> Neovim env a -> IO a
peel Config e
r))
    where
      peel :: Config env -> Neovim env a -> IO a
peel Config env
r Neovim env a
ma =
        ReaderT (Config env) IO a -> Config env -> IO a
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT (ResourceT (ReaderT (Config env) IO) a -> ReaderT (Config env) IO a
forall (m :: * -> *) a. MonadUnliftIO m => ResourceT m a -> m a
runResourceT (Neovim env a -> ResourceT (ReaderT (Config env) IO) a
forall env a. Neovim env a -> ResourceT (ReaderT (Config env) IO) a
unNeovim Neovim env a
ma)) Config env
r
  restoreM :: StM (Neovim e) a -> Neovim e a
restoreM = StM (Neovim e) a -> Neovim e a
forall (m :: * -> *) a. Monad m => a -> m a
return

newtype Ribo s e a =
  Ribo { Ribo s e a -> ExceptT e (RNeovim s) a
unRibo :: ExceptT e (RNeovim s) a }
  deriving newtype (a -> Ribo s e b -> Ribo s e a
(a -> b) -> Ribo s e a -> Ribo s e b
(forall a b. (a -> b) -> Ribo s e a -> Ribo s e b)
-> (forall a b. a -> Ribo s e b -> Ribo s e a)
-> Functor (Ribo s e)
forall a b. a -> Ribo s e b -> Ribo s e a
forall a b. (a -> b) -> Ribo s e a -> Ribo s e b
forall s e a b. a -> Ribo s e b -> Ribo s e a
forall s e a b. (a -> b) -> Ribo s e a -> Ribo s e b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> Ribo s e b -> Ribo s e a
$c<$ :: forall s e a b. a -> Ribo s e b -> Ribo s e a
fmap :: (a -> b) -> Ribo s e a -> Ribo s e b
$cfmap :: forall s e a b. (a -> b) -> Ribo s e a -> Ribo s e b
Functor, Functor (Ribo s e)
a -> Ribo s e a
Functor (Ribo s e)
-> (forall a. a -> Ribo s e a)
-> (forall a b. Ribo s e (a -> b) -> Ribo s e a -> Ribo s e b)
-> (forall a b c.
    (a -> b -> c) -> Ribo s e a -> Ribo s e b -> Ribo s e c)
-> (forall a b. Ribo s e a -> Ribo s e b -> Ribo s e b)
-> (forall a b. Ribo s e a -> Ribo s e b -> Ribo s e a)
-> Applicative (Ribo s e)
Ribo s e a -> Ribo s e b -> Ribo s e b
Ribo s e a -> Ribo s e b -> Ribo s e a
Ribo s e (a -> b) -> Ribo s e a -> Ribo s e b
(a -> b -> c) -> Ribo s e a -> Ribo s e b -> Ribo s e c
forall a. a -> Ribo s e a
forall s e. Functor (Ribo s e)
forall a b. Ribo s e a -> Ribo s e b -> Ribo s e a
forall a b. Ribo s e a -> Ribo s e b -> Ribo s e b
forall a b. Ribo s e (a -> b) -> Ribo s e a -> Ribo s e b
forall s e a. a -> Ribo s e a
forall a b c.
(a -> b -> c) -> Ribo s e a -> Ribo s e b -> Ribo s e c
forall s e a b. Ribo s e a -> Ribo s e b -> Ribo s e a
forall s e a b. Ribo s e a -> Ribo s e b -> Ribo s e b
forall s e a b. Ribo s e (a -> b) -> Ribo s e a -> Ribo s e b
forall s e a b c.
(a -> b -> c) -> Ribo s e a -> Ribo s e b -> Ribo s e c
forall (f :: * -> *).
Functor f
-> (forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
<* :: Ribo s e a -> Ribo s e b -> Ribo s e a
$c<* :: forall s e a b. Ribo s e a -> Ribo s e b -> Ribo s e a
*> :: Ribo s e a -> Ribo s e b -> Ribo s e b
$c*> :: forall s e a b. Ribo s e a -> Ribo s e b -> Ribo s e b
liftA2 :: (a -> b -> c) -> Ribo s e a -> Ribo s e b -> Ribo s e c
$cliftA2 :: forall s e a b c.
(a -> b -> c) -> Ribo s e a -> Ribo s e b -> Ribo s e c
<*> :: Ribo s e (a -> b) -> Ribo s e a -> Ribo s e b
$c<*> :: forall s e a b. Ribo s e (a -> b) -> Ribo s e a -> Ribo s e b
pure :: a -> Ribo s e a
$cpure :: forall s e a. a -> Ribo s e a
$cp1Applicative :: forall s e. Functor (Ribo s e)
Applicative, Applicative (Ribo s e)
a -> Ribo s e a
Applicative (Ribo s e)
-> (forall a b. Ribo s e a -> (a -> Ribo s e b) -> Ribo s e b)
-> (forall a b. Ribo s e a -> Ribo s e b -> Ribo s e b)
-> (forall a. a -> Ribo s e a)
-> Monad (Ribo s e)
Ribo s e a -> (a -> Ribo s e b) -> Ribo s e b
Ribo s e a -> Ribo s e b -> Ribo s e b
forall a. a -> Ribo s e a
forall s e. Applicative (Ribo s e)
forall a b. Ribo s e a -> Ribo s e b -> Ribo s e b
forall a b. Ribo s e a -> (a -> Ribo s e b) -> Ribo s e b
forall s e a. a -> Ribo s e a
forall s e a b. Ribo s e a -> Ribo s e b -> Ribo s e b
forall s e a b. Ribo s e a -> (a -> Ribo s e b) -> Ribo s e b
forall (m :: * -> *).
Applicative m
-> (forall a b. m a -> (a -> m b) -> m b)
-> (forall a b. m a -> m b -> m b)
-> (forall a. a -> m a)
-> Monad m
return :: a -> Ribo s e a
$creturn :: forall s e a. a -> Ribo s e a
>> :: Ribo s e a -> Ribo s e b -> Ribo s e b
$c>> :: forall s e a b. Ribo s e a -> Ribo s e b -> Ribo s e b
>>= :: Ribo s e a -> (a -> Ribo s e b) -> Ribo s e b
$c>>= :: forall s e a b. Ribo s e a -> (a -> Ribo s e b) -> Ribo s e b
$cp1Monad :: forall s e. Applicative (Ribo s e)
Monad, Monad (Ribo s e)
Monad (Ribo s e)
-> (forall a. IO a -> Ribo s e a) -> MonadIO (Ribo s e)
IO a -> Ribo s e a
forall a. IO a -> Ribo s e a
forall s e. Monad (Ribo s e)
forall s e a. IO a -> Ribo s e a
forall (m :: * -> *).
Monad m -> (forall a. IO a -> m a) -> MonadIO m
liftIO :: IO a -> Ribo s e a
$cliftIO :: forall s e a. IO a -> Ribo s e a
$cp1MonadIO :: forall s e. Monad (Ribo s e)
MonadIO, Monad (Ribo s e)
e -> Ribo s e a
Monad (Ribo s e)
-> (forall e a. Exception e => e -> Ribo s e a)
-> MonadThrow (Ribo s e)
forall s e. Monad (Ribo s e)
forall e a. Exception e => e -> Ribo s e a
forall s e e a. Exception e => e -> Ribo s e a
forall (m :: * -> *).
Monad m -> (forall e a. Exception e => e -> m a) -> MonadThrow m
throwM :: e -> Ribo s e a
$cthrowM :: forall s e e a. Exception e => e -> Ribo s e a
$cp1MonadThrow :: forall s e. Monad (Ribo s e)
MonadThrow, MonadThrow (Ribo s e)
MonadThrow (Ribo s e)
-> (forall e a.
    Exception e =>
    Ribo s e a -> (e -> Ribo s e a) -> Ribo s e a)
-> MonadCatch (Ribo s e)
Ribo s e a -> (e -> Ribo s e a) -> Ribo s e a
forall s e. MonadThrow (Ribo s e)
forall e a.
Exception e =>
Ribo s e a -> (e -> Ribo s e a) -> Ribo s e a
forall s e e a.
Exception e =>
Ribo s e a -> (e -> Ribo s e a) -> Ribo s e a
forall (m :: * -> *).
MonadThrow m
-> (forall e a. Exception e => m a -> (e -> m a) -> m a)
-> MonadCatch m
catch :: Ribo s e a -> (e -> Ribo s e a) -> Ribo s e a
$ccatch :: forall s e e a.
Exception e =>
Ribo s e a -> (e -> Ribo s e a) -> Ribo s e a
$cp1MonadCatch :: forall s e. MonadThrow (Ribo s e)
MonadCatch, MonadCatch (Ribo s e)
MonadCatch (Ribo s e)
-> (forall b.
    ((forall a. Ribo s e a -> Ribo s e a) -> Ribo s e b) -> Ribo s e b)
-> (forall b.
    ((forall a. Ribo s e a -> Ribo s e a) -> Ribo s e b) -> Ribo s e b)
-> (forall a b c.
    Ribo s e a
    -> (a -> ExitCase b -> Ribo s e c)
    -> (a -> Ribo s e b)
    -> Ribo s e (b, c))
-> MonadMask (Ribo s e)
Ribo s e a
-> (a -> ExitCase b -> Ribo s e c)
-> (a -> Ribo s e b)
-> Ribo s e (b, c)
((forall a. Ribo s e a -> Ribo s e a) -> Ribo s e b) -> Ribo s e b
((forall a. Ribo s e a -> Ribo s e a) -> Ribo s e b) -> Ribo s e b
forall b.
((forall a. Ribo s e a -> Ribo s e a) -> Ribo s e b) -> Ribo s e b
forall s e. MonadCatch (Ribo s e)
forall a b c.
Ribo s e a
-> (a -> ExitCase b -> Ribo s e c)
-> (a -> Ribo s e b)
-> Ribo s e (b, c)
forall s e b.
((forall a. Ribo s e a -> Ribo s e a) -> Ribo s e b) -> Ribo s e b
forall s e a b c.
Ribo s e a
-> (a -> ExitCase b -> Ribo s e c)
-> (a -> Ribo s e b)
-> Ribo s e (b, c)
forall (m :: * -> *).
MonadCatch m
-> (forall b. ((forall a. m a -> m a) -> m b) -> m b)
-> (forall b. ((forall a. m a -> m a) -> m b) -> m b)
-> (forall a b c.
    m a -> (a -> ExitCase b -> m c) -> (a -> m b) -> m (b, c))
-> MonadMask m
generalBracket :: Ribo s e a
-> (a -> ExitCase b -> Ribo s e c)
-> (a -> Ribo s e b)
-> Ribo s e (b, c)
$cgeneralBracket :: forall s e a b c.
Ribo s e a
-> (a -> ExitCase b -> Ribo s e c)
-> (a -> Ribo s e b)
-> Ribo s e (b, c)
uninterruptibleMask :: ((forall a. Ribo s e a -> Ribo s e a) -> Ribo s e b) -> Ribo s e b
$cuninterruptibleMask :: forall s e b.
((forall a. Ribo s e a -> Ribo s e a) -> Ribo s e b) -> Ribo s e b
mask :: ((forall a. Ribo s e a -> Ribo s e a) -> Ribo s e b) -> Ribo s e b
$cmask :: forall s e b.
((forall a. Ribo s e a -> Ribo s e a) -> Ribo s e b) -> Ribo s e b
$cp1MonadMask :: forall s e. MonadCatch (Ribo s e)
MonadMask, Monad (Ribo s e)
Monad (Ribo s e)
-> (forall a. String -> Ribo s e a) -> MonadFail (Ribo s e)
String -> Ribo s e a
forall a. String -> Ribo s e a
forall s e. Monad (Ribo s e)
forall s e a. String -> Ribo s e a
forall (m :: * -> *).
Monad m -> (forall a. String -> m a) -> MonadFail m
fail :: String -> Ribo s e a
$cfail :: forall s e a. String -> Ribo s e a
$cp1MonadFail :: forall s e. Monad (Ribo s e)
MonadFail, MonadBase IO)

deriving newtype instance MonadError e (Ribo s e)

modifyTMVar ::
  MonadIO m =>
  (a -> a) ->
  TMVar a ->
  m a
modifyTMVar :: (a -> a) -> TMVar a -> m a
modifyTMVar a -> a
f TMVar a
tmvar = do
  a
a <- a -> a
f (a -> a) -> m a -> m a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> STM a -> m a
forall (m :: * -> *) a. MonadIO m => STM a -> m a
atomically (TMVar a -> STM a
forall a. TMVar a -> STM a
takeTMVar TMVar a
tmvar)
  STM () -> m ()
forall (m :: * -> *) a. MonadIO m => STM a -> m a
atomically (STM () -> m ()) -> STM () -> m ()
forall a b. (a -> b) -> a -> b
$ TMVar a -> a -> STM ()
forall a. TMVar a -> a -> STM ()
putTMVar TMVar a
tmvar a
a
  return a
a

safeModifyTMVarM ::
  MonadIO m =>
  MonadBaseControl IO m =>
  (a -> m a) ->
  TMVar a ->
  m a
safeModifyTMVarM :: (a -> m a) -> TMVar a -> m a
safeModifyTMVarM a -> m a
f TMVar a
tmvar =
  a -> m a
process (a -> m a) -> m a -> m a
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< STM a -> m a
forall (m :: * -> *) a. MonadIO m => STM a -> m a
atomically (TMVar a -> STM a
forall a. TMVar a -> STM a
takeTMVar TMVar a
tmvar)
  where
    process :: a -> m a
process a
a =
      m a -> m a -> m a
forall (m :: * -> *) a b.
MonadBaseControl IO m =>
m a -> m b -> m a
onException (a -> m a
restore (a -> m a) -> m a -> m a
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< a -> m a
f a
a) (a -> m a
restore a
a)
    restore :: a -> m a
restore a
a =
      a
a a -> m () -> m a
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ (STM () -> m ()
forall (m :: * -> *) a. MonadIO m => STM a -> m a
atomically (STM () -> m ()) -> (a -> STM ()) -> a -> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TMVar a -> a -> STM ()
forall a. TMVar a -> a -> STM ()
putTMVar TMVar a
tmvar (a -> m ()) -> a -> m ()
forall a b. (a -> b) -> a -> b
$ a
a)

deriving newtype instance MonadReader (Ribosome s) (Ribo s e)

riboStateVar ::
  MonadReader (Ribosome s) m =>
  m (TMVar (RibosomeState s))
riboStateVar :: m (TMVar (RibosomeState s))
riboStateVar =
  (Ribosome s -> TMVar (RibosomeState s))
-> m (TMVar (RibosomeState s))
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
ReaderT.asks (Getting
  (TMVar (RibosomeState s)) (Ribosome s) (TMVar (RibosomeState s))
-> Ribosome s -> TMVar (RibosomeState s)
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
Lens.view Getting
  (TMVar (RibosomeState s)) (Ribosome s) (TMVar (RibosomeState s))
forall c s. HasRibosome c s => Lens' c (TMVar (RibosomeState s))
Ribosome.state)

public ::
  DeepLenses s s' =>
  Lens' (RibosomeState s) s'
public :: Lens' (RibosomeState s) s'
public =
  (s -> f s) -> RibosomeState s -> f (RibosomeState s)
forall c s. HasRibosomeState c s => Lens' c s
RibosomeState.public ((s -> f s) -> RibosomeState s -> f (RibosomeState s))
-> ((s' -> f s') -> s -> f s)
-> (s' -> f s')
-> RibosomeState s
-> f (RibosomeState s)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (s' -> f s') -> s -> f s
forall s s'. DeepLenses s s' => Lens' s s'
deepLens

instance DeepLenses s s' => MonadDeepState s s' (Ribo s e) where
  get :: Ribo s e s'
get =
    Getting s' (RibosomeState s) s' -> RibosomeState s -> s'
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
Lens.view Getting s' (RibosomeState s) s'
forall s s'. DeepLenses s s' => Lens' (RibosomeState s) s'
public (RibosomeState s -> s')
-> Ribo s e (RibosomeState s) -> Ribo s e s'
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (STM (RibosomeState s) -> Ribo s e (RibosomeState s)
forall (m :: * -> *) a. MonadIO m => STM a -> m a
atomically (STM (RibosomeState s) -> Ribo s e (RibosomeState s))
-> (TMVar (RibosomeState s) -> STM (RibosomeState s))
-> TMVar (RibosomeState s)
-> Ribo s e (RibosomeState s)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TMVar (RibosomeState s) -> STM (RibosomeState s)
forall a. TMVar a -> STM a
readTMVar (TMVar (RibosomeState s) -> Ribo s e (RibosomeState s))
-> Ribo s e (TMVar (RibosomeState s)) -> Ribo s e (RibosomeState s)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ribo s e (TMVar (RibosomeState s))
forall s (m :: * -> *).
MonadReader (Ribosome s) m =>
m (TMVar (RibosomeState s))
riboStateVar)

  modifyM' :: (s' -> Ribo s e s') -> Ribo s e s'
modifyM' s' -> Ribo s e s'
f =
    Getting s' (RibosomeState s) s' -> RibosomeState s -> s'
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
Lens.view Getting s' (RibosomeState s) s'
forall s s'. DeepLenses s s' => Lens' (RibosomeState s) s'
public (RibosomeState s -> s')
-> Ribo s e (RibosomeState s) -> Ribo s e s'
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((RibosomeState s -> Ribo s e (RibosomeState s))
-> TMVar (RibosomeState s) -> Ribo s e (RibosomeState s)
forall (m :: * -> *) a.
(MonadIO m, MonadBaseControl IO m) =>
(a -> m a) -> TMVar a -> m a
safeModifyTMVarM RibosomeState s -> Ribo s e (RibosomeState s)
trans (TMVar (RibosomeState s) -> Ribo s e (RibosomeState s))
-> Ribo s e (TMVar (RibosomeState s)) -> Ribo s e (RibosomeState s)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ribo s e (TMVar (RibosomeState s))
forall s (m :: * -> *).
MonadReader (Ribosome s) m =>
m (TMVar (RibosomeState s))
riboStateVar)
    where
      trans :: RibosomeState s -> Ribo s e (RibosomeState s)
trans = LensLike
  (WrappedMonad (Ribo s e)) (RibosomeState s) (RibosomeState s) s' s'
-> (s' -> Ribo s e s')
-> RibosomeState s
-> Ribo s e (RibosomeState s)
forall (m :: * -> *) s t a b.
LensLike (WrappedMonad m) s t a b -> (a -> m b) -> s -> m t
Lens.mapMOf LensLike
  (WrappedMonad (Ribo s e)) (RibosomeState s) (RibosomeState s) s' s'
forall s s'. DeepLenses s s' => Lens' (RibosomeState s) s'
public s' -> Ribo s e s'
f

  put :: s' -> Ribo s e ()
put =
    (s' -> s') -> Ribo s e ()
forall s' s (m :: * -> *).
MonadDeepState s s' m =>
(s' -> s') -> m ()
modify ((s' -> s') -> Ribo s e ())
-> (s' -> s' -> s') -> s' -> Ribo s e ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. s' -> s' -> s'
forall a b. a -> b -> a
const

class Monad m => Nvim m where
  call :: Rpc c a => c -> m (Either RpcError a)

instance Nvim (Neovim e) where
  call :: c -> Neovim e (Either RpcError a)
call = c -> Neovim e (Either RpcError a)
forall c a e. Rpc c a => c -> Neovim e (Either RpcError a)
Rpc.call

instance (MonadTrans t, Monad (t m), Nvim m) => Nvim (t m) where
  call :: c -> t m (Either RpcError a)
call = m (Either RpcError a) -> t m (Either RpcError a)
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m (Either RpcError a) -> t m (Either RpcError a))
-> (c -> m (Either RpcError a)) -> c -> t m (Either RpcError a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. c -> m (Either RpcError a)
forall (m :: * -> *) c a.
(Nvim m, Rpc c a) =>
c -> m (Either RpcError a)
call

instance Nvim (Ribo s e) where
  call :: c -> Ribo s e (Either RpcError a)
call = ExceptT e (RNeovim s) (Either RpcError a)
-> Ribo s e (Either RpcError a)
forall s e a. ExceptT e (RNeovim s) a -> Ribo s e a
Ribo (ExceptT e (RNeovim s) (Either RpcError a)
 -> Ribo s e (Either RpcError a))
-> (c -> ExceptT e (RNeovim s) (Either RpcError a))
-> c
-> Ribo s e (Either RpcError a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. c -> ExceptT e (RNeovim s) (Either RpcError a)
forall (m :: * -> *) c a.
(Nvim m, Rpc c a) =>
c -> m (Either RpcError a)
call

class (Nvim m, MonadDeepError e RpcError m) => NvimE e m where

instance DeepPrisms e RpcError => NvimE e (Ribo s e) where

instance (DeepPrisms e RpcError, Nvim m, Monad m) => NvimE e (ExceptT e m) where

instance (Functor f, MonadDeepError e RpcError m, Nvim m, Monad m) => NvimE e (FreeT f m) where

instance MonadBaseControl IO (Ribo s e) where
    type StM (Ribo s e) a = Either e a
    liftBaseWith :: (RunInBase (Ribo s e) IO -> IO a) -> Ribo s e a
liftBaseWith RunInBase (Ribo s e) IO -> IO a
f =
      ExceptT e (RNeovim s) a -> Ribo s e a
forall s e a. ExceptT e (RNeovim s) a -> Ribo s e a
Ribo (ExceptT e (RNeovim s) a -> Ribo s e a)
-> ExceptT e (RNeovim s) a -> Ribo s e a
forall a b. (a -> b) -> a -> b
$ (RunInBase (ExceptT e (RNeovim s)) IO -> IO a)
-> ExceptT e (RNeovim s) a
forall (b :: * -> *) (m :: * -> *) a.
MonadBaseControl b m =>
(RunInBase m b -> b a) -> m a
liftBaseWith ((RunInBase (ExceptT e (RNeovim s)) IO -> IO a)
 -> ExceptT e (RNeovim s) a)
-> (RunInBase (ExceptT e (RNeovim s)) IO -> IO a)
-> ExceptT e (RNeovim s) a
forall a b. (a -> b) -> a -> b
$ \ RunInBase (ExceptT e (RNeovim s)) IO
q -> RunInBase (Ribo s e) IO -> IO a
f (ExceptT e (RNeovim s) a -> IO (Either e a)
RunInBase (ExceptT e (RNeovim s)) IO
q (ExceptT e (RNeovim s) a -> IO (Either e a))
-> (Ribo s e a -> ExceptT e (RNeovim s) a)
-> Ribo s e a
-> IO (Either e a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ribo s e a -> ExceptT e (RNeovim s) a
forall s e a. Ribo s e a -> ExceptT e (RNeovim s) a
unRibo)
    {-# INLINABLE liftBaseWith #-}
    restoreM :: StM (Ribo s e) a -> Ribo s e a
restoreM =
      ExceptT e (RNeovim s) a -> Ribo s e a
forall s e a. ExceptT e (RNeovim s) a -> Ribo s e a
Ribo (ExceptT e (RNeovim s) a -> Ribo s e a)
-> (Either e a -> ExceptT e (RNeovim s) a)
-> Either e a
-> Ribo s e a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Either e a -> ExceptT e (RNeovim s) a
forall (b :: * -> *) (m :: * -> *) a.
MonadBaseControl b m =>
StM m a -> m a
restoreM
    {-# INLINABLE restoreM #-}

instance MonadResource (Ribo s e) where
    liftResourceT :: ResourceT IO a -> Ribo s e a
liftResourceT = ExceptT e (RNeovim s) a -> Ribo s e a
forall s e a. ExceptT e (RNeovim s) a -> Ribo s e a
Ribo (ExceptT e (RNeovim s) a -> Ribo s e a)
-> (ResourceT IO a -> ExceptT e (RNeovim s) a)
-> ResourceT IO a
-> Ribo s e a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ResourceT IO a -> ExceptT e (RNeovim s) a
forall (m :: * -> *) a. MonadResource m => ResourceT IO a -> m a
liftResourceT

instance RpcHandler e (Ribosome s) (Ribo s e) where
  native :: Ribo s e a -> ExceptT e (Neovim (Ribosome s)) a
native = Ribo s e a -> ExceptT e (Neovim (Ribosome s)) a
forall s e a. Ribo s e a -> ExceptT e (RNeovim s) a
runRiboE

acall :: (Monad m, Nvim m, Rpc c ()) => c -> m ()
acall :: c -> m ()
acall c
c = () -> Either RpcError () -> ()
forall b a. b -> Either a b -> b
fromRight () (Either RpcError () -> ()) -> m (Either RpcError ()) -> m ()
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> c -> m (Either RpcError ())
forall (m :: * -> *) c a.
(Nvim m, Rpc c a) =>
c -> m (Either RpcError a)
call c
c

readTv :: Lens' (RibosomeState s) s' -> TMVar (RibosomeState s) -> IO s'
readTv :: Lens' (RibosomeState s) s' -> TMVar (RibosomeState s) -> IO s'
readTv Lens' (RibosomeState s) s'
l TMVar (RibosomeState s)
t = Getting s' (RibosomeState s) s' -> RibosomeState s -> s'
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
Lens.view Getting s' (RibosomeState s) s'
Lens' (RibosomeState s) s'
l (RibosomeState s -> s') -> IO (RibosomeState s) -> IO s'
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> STM (RibosomeState s) -> IO (RibosomeState s)
forall (m :: * -> *) a. MonadIO m => STM a -> m a
atomically (TMVar (RibosomeState s) -> STM (RibosomeState s)
forall a. TMVar a -> STM a
readTMVar TMVar (RibosomeState s)
t)

runRibo :: Ribo s e a -> RNeovim s (Either e a)
runRibo :: Ribo s e a -> RNeovim s (Either e a)
runRibo =
  ExceptT e (RNeovim s) a -> RNeovim s (Either e a)
forall e (m :: * -> *) a. ExceptT e m a -> m (Either e a)
runExceptT (ExceptT e (RNeovim s) a -> RNeovim s (Either e a))
-> (Ribo s e a -> ExceptT e (RNeovim s) a)
-> Ribo s e a
-> RNeovim s (Either e a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ribo s e a -> ExceptT e (RNeovim s) a
forall s e a. Ribo s e a -> ExceptT e (RNeovim s) a
unRibo

runRiboE :: Ribo s e a -> ExceptT e (RNeovim s) a
runRiboE :: Ribo s e a -> ExceptT e (RNeovim s) a
runRiboE =
  Ribo s e a -> ExceptT e (RNeovim s) a
forall s e a. Ribo s e a -> ExceptT e (RNeovim s) a
unRibo

class PluginName m where
  pluginName1 :: m Text

instance PluginName IO where
  pluginName1 :: IO Text
pluginName1 = Text -> IO Text
forall (f :: * -> *) a. Applicative f => a -> f a
pure Text
"io"

instance PluginName (RNeovim s) where
  pluginName1 :: RNeovim s Text
pluginName1 =
    (Ribosome s -> Text) -> RNeovim s Text
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
ReaderT.asks (Getting Text (Ribosome s) Text -> Ribosome s -> Text
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
Lens.view Getting Text (Ribosome s) Text
forall c s. HasRibosome c s => Lens' c Text
Ribosome.name)

class MonadIO m => MonadRibo m where
  pluginName :: m Text
  pluginInternal :: m RibosomeInternal
  pluginInternalModify :: (RibosomeInternal -> RibosomeInternal) -> m ()

pluginInternals :: MonadRibo m => (RibosomeInternal -> a) -> m a
pluginInternals :: (RibosomeInternal -> a) -> m a
pluginInternals = ((RibosomeInternal -> a) -> m RibosomeInternal -> m a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m RibosomeInternal
forall (m :: * -> *). MonadRibo m => m RibosomeInternal
pluginInternal)

pluginInternalL :: MonadRibo m => Lens' RibosomeInternal a -> m a
pluginInternalL :: Lens' RibosomeInternal a -> m a
pluginInternalL = (RibosomeInternal -> a) -> m a
forall (m :: * -> *) a.
MonadRibo m =>
(RibosomeInternal -> a) -> m a
pluginInternals ((RibosomeInternal -> a) -> m a)
-> (Getting a RibosomeInternal a -> RibosomeInternal -> a)
-> Getting a RibosomeInternal a
-> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Getting a RibosomeInternal a -> RibosomeInternal -> a
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
Lens.view

pluginInternalPut' :: MonadRibo m => RibosomeInternal -> m ()
pluginInternalPut' :: RibosomeInternal -> m ()
pluginInternalPut' RibosomeInternal
s =
  (RibosomeInternal -> RibosomeInternal) -> m ()
forall (m :: * -> *).
MonadRibo m =>
(RibosomeInternal -> RibosomeInternal) -> m ()
pluginInternalModify (RibosomeInternal -> RibosomeInternal -> RibosomeInternal
forall a b. a -> b -> a
const RibosomeInternal
s)

pluginInternalModifyL :: MonadRibo m => Lens' RibosomeInternal a -> (a -> a) -> m ()
pluginInternalModifyL :: Lens' RibosomeInternal a -> (a -> a) -> m ()
pluginInternalModifyL Lens' RibosomeInternal a
l a -> a
f =
  (RibosomeInternal -> RibosomeInternal) -> m ()
forall (m :: * -> *).
MonadRibo m =>
(RibosomeInternal -> RibosomeInternal) -> m ()
pluginInternalModify ((RibosomeInternal -> RibosomeInternal) -> m ())
-> (RibosomeInternal -> RibosomeInternal) -> m ()
forall a b. (a -> b) -> a -> b
$ ASetter RibosomeInternal RibosomeInternal a a
-> (a -> a) -> RibosomeInternal -> RibosomeInternal
forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
Lens.over ASetter RibosomeInternal RibosomeInternal a a
Lens' RibosomeInternal a
l a -> a
f

instance MonadRibo (RNeovim s) where
  pluginName :: RNeovim s Text
pluginName =
    (Ribosome s -> Text) -> RNeovim s Text
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
ReaderT.asks (Getting Text (Ribosome s) Text -> Ribosome s -> Text
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
Lens.view Getting Text (Ribosome s) Text
forall c s. HasRibosome c s => Lens' c Text
Ribosome.name)

  pluginInternal :: RNeovim s RibosomeInternal
pluginInternal =
    Getting RibosomeInternal (RibosomeState s) RibosomeInternal
-> RibosomeState s -> RibosomeInternal
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
Lens.view Getting RibosomeInternal (RibosomeState s) RibosomeInternal
forall c s. HasRibosomeState c s => Lens' c RibosomeInternal
RibosomeState.internal (RibosomeState s -> RibosomeInternal)
-> (TMVar (RibosomeState s)
    -> Neovim (Ribosome s) (RibosomeState s))
-> TMVar (RibosomeState s)
-> RNeovim s RibosomeInternal
forall (f0 :: * -> *) (f1 :: * -> *) a b.
(Functor f0, Functor f1) =>
(a -> b) -> f1 (f0 a) -> f1 (f0 b)
<$$> STM (RibosomeState s) -> Neovim (Ribosome s) (RibosomeState s)
forall (m :: * -> *) a. MonadIO m => STM a -> m a
atomically (STM (RibosomeState s) -> Neovim (Ribosome s) (RibosomeState s))
-> (TMVar (RibosomeState s) -> STM (RibosomeState s))
-> TMVar (RibosomeState s)
-> Neovim (Ribosome s) (RibosomeState s)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TMVar (RibosomeState s) -> STM (RibosomeState s)
forall a. TMVar a -> STM a
readTMVar (TMVar (RibosomeState s) -> RNeovim s RibosomeInternal)
-> Neovim (Ribosome s) (TMVar (RibosomeState s))
-> RNeovim s RibosomeInternal
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< (Ribosome s -> TMVar (RibosomeState s))
-> Neovim (Ribosome s) (TMVar (RibosomeState s))
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
ReaderT.asks (Getting
  (TMVar (RibosomeState s)) (Ribosome s) (TMVar (RibosomeState s))
-> Ribosome s -> TMVar (RibosomeState s)
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
Lens.view Getting
  (TMVar (RibosomeState s)) (Ribosome s) (TMVar (RibosomeState s))
forall c s. HasRibosome c s => Lens' c (TMVar (RibosomeState s))
Ribosome.state)

  pluginInternalModify :: (RibosomeInternal -> RibosomeInternal) -> RNeovim s ()
pluginInternalModify RibosomeInternal -> RibosomeInternal
f =
    Neovim (Ribosome s) (RibosomeState s) -> RNeovim s ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (Neovim (Ribosome s) (RibosomeState s) -> RNeovim s ())
-> (TMVar (RibosomeState s)
    -> Neovim (Ribosome s) (RibosomeState s))
-> TMVar (RibosomeState s)
-> RNeovim s ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (RibosomeState s -> RibosomeState s)
-> TMVar (RibosomeState s) -> Neovim (Ribosome s) (RibosomeState s)
forall (m :: * -> *) a. MonadIO m => (a -> a) -> TMVar a -> m a
modifyTMVar (ASetter
  (RibosomeState s)
  (RibosomeState s)
  RibosomeInternal
  RibosomeInternal
-> (RibosomeInternal -> RibosomeInternal)
-> RibosomeState s
-> RibosomeState s
forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
Lens.over ASetter
  (RibosomeState s)
  (RibosomeState s)
  RibosomeInternal
  RibosomeInternal
forall c s. HasRibosomeState c s => Lens' c RibosomeInternal
RibosomeState.internal RibosomeInternal -> RibosomeInternal
f) (TMVar (RibosomeState s) -> RNeovim s ())
-> Neovim (Ribosome s) (TMVar (RibosomeState s)) -> RNeovim s ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Neovim (Ribosome s) (TMVar (RibosomeState s))
forall s (m :: * -> *).
MonadReader (Ribosome s) m =>
m (TMVar (RibosomeState s))
riboStateVar

instance MonadRibo (Ribo s e) where
  pluginName :: Ribo s e Text
pluginName = ExceptT e (RNeovim s) Text -> Ribo s e Text
forall s e a. ExceptT e (RNeovim s) a -> Ribo s e a
Ribo ExceptT e (RNeovim s) Text
forall (m :: * -> *). MonadRibo m => m Text
pluginName
  pluginInternal :: Ribo s e RibosomeInternal
pluginInternal = ExceptT e (RNeovim s) RibosomeInternal -> Ribo s e RibosomeInternal
forall s e a. ExceptT e (RNeovim s) a -> Ribo s e a
Ribo ExceptT e (RNeovim s) RibosomeInternal
forall (m :: * -> *). MonadRibo m => m RibosomeInternal
pluginInternal
  pluginInternalModify :: (RibosomeInternal -> RibosomeInternal) -> Ribo s e ()
pluginInternalModify = ExceptT e (RNeovim s) () -> Ribo s e ()
forall s e a. ExceptT e (RNeovim s) a -> Ribo s e a
Ribo (ExceptT e (RNeovim s) () -> Ribo s e ())
-> ((RibosomeInternal -> RibosomeInternal)
    -> ExceptT e (RNeovim s) ())
-> (RibosomeInternal -> RibosomeInternal)
-> Ribo s e ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (RibosomeInternal -> RibosomeInternal) -> ExceptT e (RNeovim s) ()
forall (m :: * -> *).
MonadRibo m =>
(RibosomeInternal -> RibosomeInternal) -> m ()
pluginInternalModify

instance {-# OVERLAPPABLE #-} (MonadTrans t, MonadIO (t m), MonadRibo m) => MonadRibo (t m) where
  pluginName :: t m Text
pluginName = m Text -> t m Text
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift m Text
forall (m :: * -> *). MonadRibo m => m Text
pluginName
  pluginInternal :: t m RibosomeInternal
pluginInternal = m RibosomeInternal -> t m RibosomeInternal
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift m RibosomeInternal
forall (m :: * -> *). MonadRibo m => m RibosomeInternal
pluginInternal
  pluginInternalModify :: (RibosomeInternal -> RibosomeInternal) -> t m ()
pluginInternalModify = m () -> t m ()
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m () -> t m ())
-> ((RibosomeInternal -> RibosomeInternal) -> m ())
-> (RibosomeInternal -> RibosomeInternal)
-> t m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (RibosomeInternal -> RibosomeInternal) -> m ()
forall (m :: * -> *).
MonadRibo m =>
(RibosomeInternal -> RibosomeInternal) -> m ()
pluginInternalModify

instance {-# OVERLAPPING #-} MonadIO m => MonadRibo (StateT (StrictRibosome s) m) where
  pluginName :: StateT (StrictRibosome s) m Text
pluginName =
    (StrictRibosome s -> Text) -> StateT (StrictRibosome s) m Text
forall (m :: * -> *) s a. Monad m => (s -> a) -> StateT s m a
StateT.gets (Getting Text (StrictRibosome s) Text -> StrictRibosome s -> Text
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
Lens.view Getting Text (StrictRibosome s) Text
forall c s. HasStrictRibosome c s => Lens' c Text
StrictRibosome.name)
  pluginInternal :: StateT (StrictRibosome s) m RibosomeInternal
pluginInternal =
    (StrictRibosome s -> RibosomeInternal)
-> StateT (StrictRibosome s) m RibosomeInternal
forall (m :: * -> *) s a. Monad m => (s -> a) -> StateT s m a
StateT.gets (Getting RibosomeInternal (StrictRibosome s) RibosomeInternal
-> StrictRibosome s -> RibosomeInternal
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
Lens.view (Getting RibosomeInternal (StrictRibosome s) RibosomeInternal
 -> StrictRibosome s -> RibosomeInternal)
-> Getting RibosomeInternal (StrictRibosome s) RibosomeInternal
-> StrictRibosome s
-> RibosomeInternal
forall a b. (a -> b) -> a -> b
$ (RibosomeState s -> Const RibosomeInternal (RibosomeState s))
-> StrictRibosome s -> Const RibosomeInternal (StrictRibosome s)
forall c s. HasStrictRibosome c s => Lens' c (RibosomeState s)
StrictRibosome.state ((RibosomeState s -> Const RibosomeInternal (RibosomeState s))
 -> StrictRibosome s -> Const RibosomeInternal (StrictRibosome s))
-> ((RibosomeInternal -> Const RibosomeInternal RibosomeInternal)
    -> RibosomeState s -> Const RibosomeInternal (RibosomeState s))
-> Getting RibosomeInternal (StrictRibosome s) RibosomeInternal
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (RibosomeInternal -> Const RibosomeInternal RibosomeInternal)
-> RibosomeState s -> Const RibosomeInternal (RibosomeState s)
forall c s. HasRibosomeState c s => Lens' c RibosomeInternal
RibosomeState.internal)
  pluginInternalModify :: (RibosomeInternal -> RibosomeInternal)
-> StateT (StrictRibosome s) m ()
pluginInternalModify =
    (StrictRibosome s -> StrictRibosome s)
-> StateT (StrictRibosome s) m ()
forall (m :: * -> *) s. Monad m => (s -> s) -> StateT s m ()
StateT.modify ((StrictRibosome s -> StrictRibosome s)
 -> StateT (StrictRibosome s) m ())
-> ((RibosomeInternal -> RibosomeInternal)
    -> StrictRibosome s -> StrictRibosome s)
-> (RibosomeInternal -> RibosomeInternal)
-> StateT (StrictRibosome s) m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ASetter
  (StrictRibosome s)
  (StrictRibosome s)
  RibosomeInternal
  RibosomeInternal
-> (RibosomeInternal -> RibosomeInternal)
-> StrictRibosome s
-> StrictRibosome s
forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
Lens.over ((RibosomeState s -> Identity (RibosomeState s))
-> StrictRibosome s -> Identity (StrictRibosome s)
forall c s. HasStrictRibosome c s => Lens' c (RibosomeState s)
StrictRibosome.state ((RibosomeState s -> Identity (RibosomeState s))
 -> StrictRibosome s -> Identity (StrictRibosome s))
-> ((RibosomeInternal -> Identity RibosomeInternal)
    -> RibosomeState s -> Identity (RibosomeState s))
-> ASetter
     (StrictRibosome s)
     (StrictRibosome s)
     RibosomeInternal
     RibosomeInternal
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (RibosomeInternal -> Identity RibosomeInternal)
-> RibosomeState s -> Identity (RibosomeState s)
forall c s. HasRibosomeState c s => Lens' c RibosomeInternal
RibosomeState.internal)

getErrors :: MonadRibo m => m Errors
getErrors :: m Errors
getErrors =
  (RibosomeInternal -> Errors) -> m Errors
forall (m :: * -> *) a.
MonadRibo m =>
(RibosomeInternal -> a) -> m a
pluginInternals RibosomeInternal -> Errors
Ribosome._errors

inspectErrors :: MonadRibo m => (Errors -> a) -> m a
inspectErrors :: (Errors -> a) -> m a
inspectErrors = ((Errors -> a) -> m Errors -> m a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Errors
forall (m :: * -> *). MonadRibo m => m Errors
getErrors)

modifyErrors :: MonadRibo m => (Errors -> Errors) -> m ()
modifyErrors :: (Errors -> Errors) -> m ()
modifyErrors =
  Lens' RibosomeInternal Errors -> (Errors -> Errors) -> m ()
forall (m :: * -> *) a.
MonadRibo m =>
Lens' RibosomeInternal a -> (a -> a) -> m ()
pluginInternalModifyL forall c. HasRibosomeInternal c => Lens' c Errors
Lens' RibosomeInternal Errors
Ribosome.errors

prepend :: ∀s' s m a. MonadDeepState s s' m => Lens' s' [a] -> a -> m ()
prepend :: Lens' s' [a] -> a -> m ()
prepend Lens' s' [a]
lens a
a =
  (s' -> s') -> m ()
forall s' s (m :: * -> *).
MonadDeepState s s' m =>
(s' -> s') -> m ()
modify ((s' -> s') -> m ()) -> (s' -> s') -> m ()
forall a b. (a -> b) -> a -> b
$ ASetter s' s' [a] [a] -> ([a] -> [a]) -> s' -> s'
forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
Lens.over ASetter s' s' [a] [a]
Lens' s' [a]
lens (a
aa -> [a] -> [a]
forall a. a -> [a] -> [a]
:)

prependUnique ::
  ∀ s' s m a .
  Eq a =>
  MonadDeepState s s' m =>
  Lens' s' [a] ->
  a ->
  m ()
prependUnique :: Lens' s' [a] -> a -> m ()
prependUnique Lens' s' [a]
lens a
a =
  (s' -> s') -> m ()
forall s' s (m :: * -> *).
MonadDeepState s s' m =>
(s' -> s') -> m ()
modify ((s' -> s') -> m ()) -> (s' -> s') -> m ()
forall a b. (a -> b) -> a -> b
$ ASetter s' s' [a] [a] -> ([a] -> [a]) -> s' -> s'
forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
Lens.over ASetter s' s' [a] [a]
Lens' s' [a]
lens [a] -> [a]
modder
  where
    modder :: [a] -> [a]
modder [a]
as =
      a
a a -> [a] -> [a]
forall a. a -> [a] -> [a]
: (a -> Bool) -> [a] -> [a]
forall a. (a -> Bool) -> [a] -> [a]
filter (a
a a -> a -> Bool
forall a. Eq a => a -> a -> Bool
/=) [a]
as

prependUniqueBy ::
  ∀ s' s m a b .
  Eq b =>
  MonadDeepState s s' m =>
  Lens' a b ->
  Lens' s' [a] ->
  a ->
  m ()
prependUniqueBy :: Lens' a b -> Lens' s' [a] -> a -> m ()
prependUniqueBy Lens' a b
attr Lens' s' [a]
lens a
a =
  (s' -> s') -> m ()
forall s' s (m :: * -> *).
MonadDeepState s s' m =>
(s' -> s') -> m ()
modify ((s' -> s') -> m ()) -> (s' -> s') -> m ()
forall a b. (a -> b) -> a -> b
$ ASetter s' s' [a] [a] -> ([a] -> [a]) -> s' -> s'
forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
Lens.over ASetter s' s' [a] [a]
Lens' s' [a]
lens [a] -> [a]
modder
  where
    modder :: [a] -> [a]
modder [a]
as =
      a
a a -> [a] -> [a]
forall a. a -> [a] -> [a]
: (a -> Bool) -> [a] -> [a]
forall a. (a -> Bool) -> [a] -> [a]
filter a -> Bool
pred' [a]
as
    pred' :: a -> Bool
pred' a
b =
      Getting b a b -> a -> b
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
Lens.view Getting b a b
Lens' a b
attr a
a b -> b -> Bool
forall a. Eq a => a -> a -> Bool
/= Getting b a b -> a -> b
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
Lens.view Getting b a b
Lens' a b
attr a
b

inspectHeadE ::
  ∀ s' s e e' m a .
  (MonadDeepState s s' m, MonadDeepError e e' m) =>
  e' ->
  Lens' s' [a] ->
  m a
inspectHeadE :: e' -> Lens' s' [a] -> m a
inspectHeadE e'
err Lens' s' [a]
lens = do
  [a]
as <- (s' -> [a]) -> m [a]
forall s' s (m :: * -> *) a.
MonadDeepState s s' m =>
(s' -> a) -> m a
gets ((s' -> [a]) -> m [a]) -> (s' -> [a]) -> m [a]
forall a b. (a -> b) -> a -> b
$ Getting [a] s' [a] -> s' -> [a]
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
Lens.view Getting [a] s' [a]
Lens' s' [a]
lens
  case [a]
as of
    (a
a : [a]
_) -> a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return a
a
    [a]
_ -> e' -> m a
forall e e' (m :: * -> *) a. MonadDeepError e e' m => e' -> m a
throwHoist e'
err