module Chiasma.Interpreter.TmuxClient where

import Conc (interpretAtomic)
import Data.Sequence ((|>))
import qualified Data.Text as Text
import Exon (exon)
import qualified Log as Log
import Path (Abs, File, Path, relfile, toFilePath)
import Polysemy.Process.Interpreter.Process (ProcessQueues)
import qualified Process as Process
import Process (
  OutputPipe (Stderr, Stdout),
  Process,
  ProcessError,
  SystemProcess,
  SystemProcessError,
  SystemProcessScopeError,
  interpretProcessInputId,
  interpretProcessOutputLeft,
  interpretProcessOutputTextLines,
  interpretProcess_,
  interpretSystemProcessNative_,
  resolveExecutable,
  withProcess_,
  )
import System.Process.Typed (ProcessConfig, proc)

import qualified Chiasma.Data.TmuxError as TmuxError
import Chiasma.Data.TmuxError (TmuxError (NoExe))
import Chiasma.Data.TmuxNative (TmuxNative (TmuxNative))
import qualified Chiasma.Data.TmuxOutputBlock as TmuxOutputBlock
import Chiasma.Data.TmuxOutputBlock (TmuxOutputBlock)
import qualified Chiasma.Data.TmuxRequest as TmuxRequest
import Chiasma.Data.TmuxRequest (TmuxRequest (TmuxRequest))
import Chiasma.Data.TmuxResponse (TmuxResponse (TmuxResponse))
import qualified Chiasma.Effect.TmuxClient as TmuxClient
import Chiasma.Effect.TmuxClient (TmuxClient)
import Chiasma.Interpreter.ProcessOutput (interpretProcessOutputTmuxBlock)

type TmuxQueues =
  ProcessQueues (Either Text TmuxOutputBlock) Text

type TmuxProc =
  Process ByteString (Either Text TmuxOutputBlock)

validate :: TmuxRequest -> TmuxOutputBlock -> Either TmuxError TmuxResponse
validate :: TmuxRequest -> TmuxOutputBlock -> Either TmuxError TmuxResponse
validate TmuxRequest
request = \case
  TmuxOutputBlock.Success [Text]
a ->
    TmuxResponse -> Either TmuxError TmuxResponse
forall a b. b -> Either a b
Right ([Text] -> TmuxResponse
TmuxResponse [Text]
a)
  TmuxOutputBlock.Error [Text]
a ->
    TmuxError -> Either TmuxError TmuxResponse
forall a b. a -> Either a b
Left (TmuxRequest -> [Text] -> TmuxError
TmuxError.RequestFailed TmuxRequest
request [Text]
a)

tmuxRequest ::
  Members [Process ByteString (Either Text TmuxOutputBlock), Log, Stop TmuxError] r =>
  TmuxRequest ->
  Sem r TmuxResponse
tmuxRequest :: forall (r :: EffectRow).
Members
  '[Process ByteString (Either Text TmuxOutputBlock), Log,
    Stop TmuxError]
  r =>
TmuxRequest -> Sem r TmuxResponse
tmuxRequest TmuxRequest
request = do
  Text -> Sem r ()
forall (r :: EffectRow).
(HasCallStack, Member Log r) =>
Text -> Sem r ()
Log.trace [exon|tmux request: #{Text.stripEnd (decodeUtf8 cmdline)}|]
  ByteString -> Sem r ()
forall i o (r :: EffectRow).
Member (Process i o) r =>
i -> Sem r ()
Process.send ByteString
cmdline
  Sem r (Either Text TmuxOutputBlock)
forall i o (r :: EffectRow). Member (Process i o) r => Sem r o
Process.recv Sem r (Either Text TmuxOutputBlock)
-> (Either Text TmuxOutputBlock -> Sem r TmuxResponse)
-> Sem r TmuxResponse
forall a b. Sem r a -> (a -> Sem r b) -> Sem r b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
    Left Text
err -> TmuxError -> Sem r TmuxResponse
forall e (r :: EffectRow) a. Member (Stop e) r => e -> Sem r a
stop (TmuxRequest -> [Text] -> TmuxError
TmuxError.RequestFailed TmuxRequest
request [Text
Item [Text]
err])
    Right TmuxOutputBlock
block -> do
      Text -> Sem r ()
forall (r :: EffectRow).
(HasCallStack, Member Log r) =>
Text -> Sem r ()
Log.trace [exon|tmux response: #{show block}|]
      Either TmuxError TmuxResponse -> Sem r TmuxResponse
forall err (r :: EffectRow) a.
Member (Stop err) r =>
Either err a -> Sem r a
stopEither (TmuxRequest -> TmuxOutputBlock -> Either TmuxError TmuxResponse
validate TmuxRequest
request TmuxOutputBlock
block)
  where
    cmdline :: ByteString
cmdline =
      TmuxRequest -> ByteString
TmuxRequest.encode TmuxRequest
request

socketArg :: Path Abs File -> [String]
socketArg :: Path Abs File -> [String]
socketArg Path Abs File
socket =
  [String
Item [String]
"-S", Path Abs File -> String
forall b t. Path b t -> String
toFilePath Path Abs File
socket]

tmuxProc ::
  TmuxNative ->
  ProcessConfig () () ()
tmuxProc :: TmuxNative -> ProcessConfig () () ()
tmuxProc (TmuxNative Path Abs File
exe Maybe (Path Abs File)
socket) =
  String -> [String] -> ProcessConfig () () ()
proc (Path Abs File -> String
forall b t. Path b t -> String
toFilePath Path Abs File
exe) ((Path Abs File -> [String]) -> Maybe (Path Abs File) -> [String]
forall m a. Monoid m => (a -> m) -> Maybe a -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap Path Abs File -> [String]
socketArg Maybe (Path Abs File)
socket [String] -> [String] -> [String]
forall a. Semigroup a => a -> a -> a
<> [String
Item [String]
"-C", String
Item [String]
"-u", String
Item [String]
"attach-session", String
Item [String]
"-f", String
Item [String]
"ignore-size"])

interpretSystemProcessTmux ::
  Members [Reader TmuxNative, Resource, Race, Async, Embed IO] r =>
  InterpreterFor (Scoped_ (SystemProcess !! SystemProcessError) !! SystemProcessScopeError) r
interpretSystemProcessTmux :: forall (r :: EffectRow).
Members '[Reader TmuxNative, Resource, Race, Async, Embed IO] r =>
InterpreterFor
  (Scoped_ (SystemProcess !! SystemProcessError)
   !! SystemProcessScopeError)
  r
interpretSystemProcessTmux Sem
  ((Scoped_ (SystemProcess !! SystemProcessError)
    !! SystemProcessScopeError)
     : r)
  a
sem = do
  ProcessConfig () () ()
conf <- TmuxNative -> ProcessConfig () () ()
tmuxProc (TmuxNative -> ProcessConfig () () ())
-> Sem r TmuxNative -> Sem r (ProcessConfig () () ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sem r TmuxNative
forall i (r :: EffectRow). Member (Reader i) r => Sem r i
ask
  ProcessConfig () () ()
-> InterpreterFor
     (Scoped_ (SystemProcess !! SystemProcessError)
      !! SystemProcessScopeError)
     r
forall (r :: EffectRow).
Members '[Resource, Embed IO] r =>
ProcessConfig () () ()
-> InterpreterFor
     (Scoped_ (SystemProcess !! SystemProcessError)
      !! SystemProcessScopeError)
     r
interpretSystemProcessNative_ ProcessConfig () () ()
conf Sem
  ((Scoped_ (SystemProcess !! SystemProcessError)
    !! SystemProcessScopeError)
     : r)
  a
sem

interpretProcessTmux ::
  Member (Scoped_ (SystemProcess !! SystemProcessError) !! SystemProcessScopeError) r =>
  Members [Resource, Race, Async, Embed IO] r =>
  InterpreterFor (Scoped_ TmuxProc !! ProcessError) r
interpretProcessTmux :: forall (r :: EffectRow).
(Member
   (Scoped_ (SystemProcess !! SystemProcessError)
    !! SystemProcessScopeError)
   r,
 Members '[Resource, Race, Async, Embed IO] r) =>
InterpreterFor
  (Scoped_ (Process ByteString (Either Text TmuxOutputBlock))
   !! ProcessError)
  r
interpretProcessTmux Sem
  ((Scoped_ (Process ByteString (Either Text TmuxOutputBlock))
    !! ProcessError)
     : r)
  a
sem = do
  forall (p :: OutputPipe) (r :: EffectRow).
Member (Embed IO) r =>
InterpreterFor (ProcessOutput p (Either Text TmuxOutputBlock)) r
interpretProcessOutputTmuxBlock @'Stdout (Sem (ProcessOutput 'Stdout (Either Text TmuxOutputBlock) : r) a
 -> Sem r a)
-> Sem (ProcessOutput 'Stdout (Either Text TmuxOutputBlock) : r) a
-> Sem r a
forall a b. (a -> b) -> a -> b
$
    forall (p :: OutputPipe) (r :: EffectRow) a.
Sem (ProcessOutput p Text : r) a -> Sem r a
interpretProcessOutputTextLines @'Stderr (Sem
   (ProcessOutput 'Stderr Text
      : ProcessOutput 'Stdout (Either Text TmuxOutputBlock) : r)
   a
 -> Sem (ProcessOutput 'Stdout (Either Text TmuxOutputBlock) : r) a)
-> Sem
     (ProcessOutput 'Stderr Text
        : ProcessOutput 'Stdout (Either Text TmuxOutputBlock) : r)
     a
-> Sem (ProcessOutput 'Stdout (Either Text TmuxOutputBlock) : r) a
forall a b. (a -> b) -> a -> b
$
    forall (p :: OutputPipe) a b (r :: EffectRow).
Member (ProcessOutput p a) r =>
InterpreterFor (ProcessOutput p (Either a b)) r
interpretProcessOutputLeft @'Stderr (Sem
   (ProcessOutput 'Stderr (Either Text TmuxOutputBlock)
      : ProcessOutput 'Stderr Text
      : ProcessOutput 'Stdout (Either Text TmuxOutputBlock) : r)
   a
 -> Sem
      (ProcessOutput 'Stderr Text
         : ProcessOutput 'Stdout (Either Text TmuxOutputBlock) : r)
      a)
-> Sem
     (ProcessOutput 'Stderr (Either Text TmuxOutputBlock)
        : ProcessOutput 'Stderr Text
        : ProcessOutput 'Stdout (Either Text TmuxOutputBlock) : r)
     a
-> Sem
     (ProcessOutput 'Stderr Text
        : ProcessOutput 'Stdout (Either Text TmuxOutputBlock) : r)
     a
forall a b. (a -> b) -> a -> b
$
    Sem
  (ProcessInput ByteString
     : ProcessOutput 'Stderr (Either Text TmuxOutputBlock)
     : ProcessOutput 'Stderr Text
     : ProcessOutput 'Stdout (Either Text TmuxOutputBlock) : r)
  a
-> Sem
     (ProcessOutput 'Stderr (Either Text TmuxOutputBlock)
        : ProcessOutput 'Stderr Text
        : ProcessOutput 'Stdout (Either Text TmuxOutputBlock) : r)
     a
forall (r :: EffectRow) a.
Sem (ProcessInput ByteString : r) a -> Sem r a
interpretProcessInputId (Sem
   (ProcessInput ByteString
      : ProcessOutput 'Stderr (Either Text TmuxOutputBlock)
      : ProcessOutput 'Stderr Text
      : ProcessOutput 'Stdout (Either Text TmuxOutputBlock) : r)
   a
 -> Sem
      (ProcessOutput 'Stderr (Either Text TmuxOutputBlock)
         : ProcessOutput 'Stderr Text
         : ProcessOutput 'Stdout (Either Text TmuxOutputBlock) : r)
      a)
-> Sem
     (ProcessInput ByteString
        : ProcessOutput 'Stderr (Either Text TmuxOutputBlock)
        : ProcessOutput 'Stderr Text
        : ProcessOutput 'Stdout (Either Text TmuxOutputBlock) : r)
     a
-> Sem
     (ProcessOutput 'Stderr (Either Text TmuxOutputBlock)
        : ProcessOutput 'Stderr Text
        : ProcessOutput 'Stdout (Either Text TmuxOutputBlock) : r)
     a
forall a b. (a -> b) -> a -> b
$
    ProcessOptions
-> InterpreterFor
     (Scoped_ (Process ByteString (Either Text TmuxOutputBlock))
      !! ProcessError)
     (ProcessInput ByteString
        : ProcessOutput 'Stderr (Either Text TmuxOutputBlock)
        : ProcessOutput 'Stderr Text
        : ProcessOutput 'Stdout (Either Text TmuxOutputBlock) : r)
forall i o (r :: EffectRow).
(Member
   (Scoped_ (SystemProcess !! SystemProcessError)
    !! SystemProcessScopeError)
   r,
 Members
   '[ProcessOutput 'Stdout o, ProcessOutput 'Stderr o, ProcessInput i,
     Resource, Race, Async, Embed IO]
   r) =>
ProcessOptions
-> InterpreterFor (Scoped_ (Process i o) !! ProcessError) r
interpretProcess_ ProcessOptions
forall a. Default a => a
def (Sem
   ((Scoped_ (Process ByteString (Either Text TmuxOutputBlock))
     !! ProcessError)
      : ProcessInput ByteString
      : ProcessOutput 'Stderr (Either Text TmuxOutputBlock)
      : ProcessOutput 'Stderr Text
      : ProcessOutput 'Stdout (Either Text TmuxOutputBlock) : r)
   a
 -> Sem
      (ProcessInput ByteString
         : ProcessOutput 'Stderr (Either Text TmuxOutputBlock)
         : ProcessOutput 'Stderr Text
         : ProcessOutput 'Stdout (Either Text TmuxOutputBlock) : r)
      a)
-> Sem
     ((Scoped_ (Process ByteString (Either Text TmuxOutputBlock))
       !! ProcessError)
        : ProcessInput ByteString
        : ProcessOutput 'Stderr (Either Text TmuxOutputBlock)
        : ProcessOutput 'Stderr Text
        : ProcessOutput 'Stdout (Either Text TmuxOutputBlock) : r)
     a
-> Sem
     (ProcessInput ByteString
        : ProcessOutput 'Stderr (Either Text TmuxOutputBlock)
        : ProcessOutput 'Stderr Text
        : ProcessOutput 'Stdout (Either Text TmuxOutputBlock) : r)
     a
forall a b. (a -> b) -> a -> b
$
    forall (index :: Nat) (inserted :: EffectRow) (head :: EffectRow)
       (oldTail :: EffectRow) (tail :: EffectRow) (old :: EffectRow)
       (full :: EffectRow) a.
(ListOfLength index head, WhenStuck index InsertAtUnprovidedIndex,
 old ~ Append head oldTail, tail ~ Append inserted oldTail,
 full ~ Append head tail,
 InsertAtIndex index head tail oldTail full inserted) =>
Sem old a -> Sem full a
insertAt @1 Sem
  ((Scoped_ (Process ByteString (Either Text TmuxOutputBlock))
    !! ProcessError)
     : r)
  a
sem
{-# inline interpretProcessTmux #-}

flush ::
  Members [TmuxProc, AtomicState (Seq TmuxRequest), Log, Stop TmuxError] r =>
  Sem r ()
flush :: forall (r :: EffectRow).
Members
  '[Process ByteString (Either Text TmuxOutputBlock),
    AtomicState (Seq TmuxRequest), Log, Stop TmuxError]
  r =>
Sem r ()
flush =
  (TmuxRequest -> Sem r TmuxResponse) -> Seq TmuxRequest -> Sem r ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
(a -> f b) -> t a -> f ()
traverse_ TmuxRequest -> Sem r TmuxResponse
forall (r :: EffectRow).
Members
  '[Process ByteString (Either Text TmuxOutputBlock), Log,
    Stop TmuxError]
  r =>
TmuxRequest -> Sem r TmuxResponse
tmuxRequest (Seq TmuxRequest -> Sem r ())
-> Sem r (Seq TmuxRequest) -> Sem r ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< (Seq TmuxRequest -> (Seq TmuxRequest, Seq TmuxRequest))
-> Sem r (Seq TmuxRequest)
forall s a (r :: EffectRow).
Member (AtomicState s) r =>
(s -> (s, a)) -> Sem r a
atomicState' (Seq TmuxRequest
forall a. Monoid a => a
mempty,)

tmuxSession ::
  ∀ r a .
  Members [Scoped_ TmuxProc !! ProcessError, AtomicState (Seq TmuxRequest), Log, Stop TmuxError] r =>
  Sem (TmuxProc : r) a ->
  Sem r a
tmuxSession :: forall (r :: EffectRow) a.
Members
  '[Scoped_ (Process ByteString (Either Text TmuxOutputBlock))
    !! ProcessError,
    AtomicState (Seq TmuxRequest), Log, Stop TmuxError]
  r =>
Sem (Process ByteString (Either Text TmuxOutputBlock) : r) a
-> Sem r a
tmuxSession Sem (Process ByteString (Either Text TmuxOutputBlock) : r) a
action =
  forall err (eff :: (* -> *) -> * -> *) err' (r :: EffectRow) a.
Members '[Resumable err eff, Stop err'] r =>
(err -> err') -> Sem (eff : r) a -> Sem r a
resumeHoist @ProcessError @(Scoped_ TmuxProc) ProcessError -> TmuxError
TmuxError.ProcessFailed (Sem
   (Scoped_ (Process ByteString (Either Text TmuxOutputBlock)) : r) a
 -> Sem r a)
-> Sem
     (Scoped_ (Process ByteString (Either Text TmuxOutputBlock)) : r) a
-> Sem r a
forall a b. (a -> b) -> a -> b
$ Sem
  (Process ByteString (Either Text TmuxOutputBlock)
     : Scoped_ (Process ByteString (Either Text TmuxOutputBlock)) : r)
  a
-> Sem
     (Scoped_ (Process ByteString (Either Text TmuxOutputBlock)) : r) a
InterpreterFor
  (Process ByteString (Either Text TmuxOutputBlock))
  (Scoped_ (Process ByteString (Either Text TmuxOutputBlock)) : r)
forall i o (r :: EffectRow).
Member (Scoped_ (Process i o)) r =>
InterpreterFor (Process i o) r
withProcess_ do
    Sem
  (Process ByteString (Either Text TmuxOutputBlock)
     : Scoped_ (Process ByteString (Either Text TmuxOutputBlock)) : r)
  (Either Text TmuxOutputBlock)
-> Sem
     (Process ByteString (Either Text TmuxOutputBlock)
        : Scoped_ (Process ByteString (Either Text TmuxOutputBlock)) : r)
     ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void Sem
  (Process ByteString (Either Text TmuxOutputBlock)
     : Scoped_ (Process ByteString (Either Text TmuxOutputBlock)) : r)
  (Either Text TmuxOutputBlock)
forall i o (r :: EffectRow). Member (Process i o) r => Sem r o
Process.recv
    TmuxRequest
-> Sem
     (Process ByteString (Either Text TmuxOutputBlock)
        : Scoped_ (Process ByteString (Either Text TmuxOutputBlock)) : r)
     TmuxResponse
forall (r :: EffectRow).
Members
  '[Process ByteString (Either Text TmuxOutputBlock), Log,
    Stop TmuxError]
  r =>
TmuxRequest -> Sem r TmuxResponse
tmuxRequest (Text -> [Text] -> Maybe TmuxQuery -> TmuxRequest
TmuxRequest Text
"refresh-client" [Text
Item [Text]
"-C", Text
Item [Text]
"10000x10000"] Maybe TmuxQuery
forall a. Maybe a
Nothing)
    Sem (Process ByteString (Either Text TmuxOutputBlock) : r) a
-> Sem
     (Process ByteString (Either Text TmuxOutputBlock)
        : Scoped_ (Process ByteString (Either Text TmuxOutputBlock)) : r)
     a
forall (e2 :: (* -> *) -> * -> *) (e1 :: (* -> *) -> * -> *)
       (r :: EffectRow) a.
Sem (e1 : r) a -> Sem (e1 : e2 : r) a
raiseUnder Sem (Process ByteString (Either Text TmuxOutputBlock) : r) a
action Sem
  (Process ByteString (Either Text TmuxOutputBlock)
     : Scoped_ (Process ByteString (Either Text TmuxOutputBlock)) : r)
  a
-> Sem
     (Process ByteString (Either Text TmuxOutputBlock)
        : Scoped_ (Process ByteString (Either Text TmuxOutputBlock)) : r)
     ()
-> Sem
     (Process ByteString (Either Text TmuxOutputBlock)
        : Scoped_ (Process ByteString (Either Text TmuxOutputBlock)) : r)
     a
forall a b.
Sem
  (Process ByteString (Either Text TmuxOutputBlock)
     : Scoped_ (Process ByteString (Either Text TmuxOutputBlock)) : r)
  a
-> Sem
     (Process ByteString (Either Text TmuxOutputBlock)
        : Scoped_ (Process ByteString (Either Text TmuxOutputBlock)) : r)
     b
-> Sem
     (Process ByteString (Either Text TmuxOutputBlock)
        : Scoped_ (Process ByteString (Either Text TmuxOutputBlock)) : r)
     a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Sem
  (Process ByteString (Either Text TmuxOutputBlock)
     : Scoped_ (Process ByteString (Either Text TmuxOutputBlock)) : r)
  ()
forall (r :: EffectRow).
Members
  '[Process ByteString (Either Text TmuxOutputBlock),
    AtomicState (Seq TmuxRequest), Log, Stop TmuxError]
  r =>
Sem r ()
flush

interpretTmuxProcessBuffered ::
  Members [AtomicState (Seq TmuxRequest), Scoped_ TmuxProc !! ProcessError, Log, Embed IO] r =>
  InterpreterFor (Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError) r
interpretTmuxProcessBuffered :: forall (r :: EffectRow).
Members
  '[AtomicState (Seq TmuxRequest),
    Scoped_ (Process ByteString (Either Text TmuxOutputBlock))
    !! ProcessError,
    Log, Embed IO]
  r =>
InterpreterFor
  (Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError) r
interpretTmuxProcessBuffered =
  forall (extra :: EffectRow) param (effect :: (* -> *) -> * -> *)
       err (r :: EffectRow).
KnownList extra =>
(forall (q :: (* -> *) -> * -> *) x.
 param
 -> Sem (extra ++ (Stop err : Opaque q : r)) x
 -> Sem (Stop err : Opaque q : r) x)
-> (forall (q :: (* -> *) -> * -> *) (r0 :: EffectRow) x.
    effect (Sem r0) x -> Sem (extra ++ (Stop err : Opaque q : r)) x)
-> InterpreterFor (Scoped param effect !! err) r
interpretScopedResumableWith_ @'[TmuxProc] ((Sem
   (Process ByteString (Either Text TmuxOutputBlock)
      : Stop TmuxError : Opaque q : r)
   x
 -> Sem (Stop TmuxError : Opaque q : r) x)
-> ()
-> Sem
     (Process ByteString (Either Text TmuxOutputBlock)
        : Stop TmuxError : Opaque q : r)
     x
-> Sem (Stop TmuxError : Opaque q : r) x
forall a b. a -> b -> a
const Sem
  (Process ByteString (Either Text TmuxOutputBlock)
     : Stop TmuxError : Opaque q : r)
  x
-> Sem (Stop TmuxError : Opaque q : r) x
forall (r :: EffectRow) a.
Members
  '[Scoped_ (Process ByteString (Either Text TmuxOutputBlock))
    !! ProcessError,
    AtomicState (Seq TmuxRequest), Log, Stop TmuxError]
  r =>
Sem (Process ByteString (Either Text TmuxOutputBlock) : r) a
-> Sem r a
tmuxSession) \case
    TmuxClient.Schedule TmuxRequest
request ->
      (Seq TmuxRequest -> Seq TmuxRequest)
-> Sem
     (Process ByteString (Either Text TmuxOutputBlock)
        : Stop TmuxError : Opaque q : r)
     ()
forall s (r :: EffectRow).
Member (AtomicState s) r =>
(s -> s) -> Sem r ()
atomicModify' (Seq TmuxRequest -> TmuxRequest -> Seq TmuxRequest
forall a. Seq a -> a -> Seq a
|> TmuxRequest
request)
    TmuxClient.Send TmuxRequest
cmd -> do
      Sem
  (Process ByteString (Either Text TmuxOutputBlock)
     : Stop TmuxError : Opaque q : r)
  ()
forall (r :: EffectRow).
Members
  '[Process ByteString (Either Text TmuxOutputBlock),
    AtomicState (Seq TmuxRequest), Log, Stop TmuxError]
  r =>
Sem r ()
flush
      TmuxRequest
-> Sem
     (Process ByteString (Either Text TmuxOutputBlock)
        : Stop TmuxError : Opaque q : r)
     TmuxResponse
forall (r :: EffectRow).
Members
  '[Process ByteString (Either Text TmuxOutputBlock), Log,
    Stop TmuxError]
  r =>
TmuxRequest -> Sem r TmuxResponse
tmuxRequest TmuxRequest
cmd
{-# inline interpretTmuxProcessBuffered #-}

interpretTmuxWithProcess ::
  Members [Scoped_ TmuxProc !! ProcessError, Log, Embed IO] r =>
  InterpreterFor (Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError) r
interpretTmuxWithProcess :: forall (r :: EffectRow).
Members
  '[Scoped_ (Process ByteString (Either Text TmuxOutputBlock))
    !! ProcessError,
    Log, Embed IO]
  r =>
InterpreterFor
  (Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError) r
interpretTmuxWithProcess =
  Seq TmuxRequest -> InterpreterFor (AtomicState (Seq TmuxRequest)) r
forall a (r :: EffectRow).
Member (Embed IO) r =>
a -> InterpreterFor (AtomicState a) r
interpretAtomic Seq TmuxRequest
forall a. Monoid a => a
mempty (Sem (AtomicState (Seq TmuxRequest) : r) a -> Sem r a)
-> (Sem
      ((Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError) : r)
      a
    -> Sem (AtomicState (Seq TmuxRequest) : r) a)
-> Sem
     ((Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError) : r)
     a
-> Sem r a
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  Sem
  ((Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError)
     : AtomicState (Seq TmuxRequest) : r)
  a
-> Sem (AtomicState (Seq TmuxRequest) : r) a
forall (r :: EffectRow).
Members
  '[AtomicState (Seq TmuxRequest),
    Scoped_ (Process ByteString (Either Text TmuxOutputBlock))
    !! ProcessError,
    Log, Embed IO]
  r =>
InterpreterFor
  (Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError) r
InterpreterFor
  (Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError)
  (AtomicState (Seq TmuxRequest) : r)
interpretTmuxProcessBuffered (Sem
   ((Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError)
      : AtomicState (Seq TmuxRequest) : r)
   a
 -> Sem (AtomicState (Seq TmuxRequest) : r) a)
-> (Sem
      ((Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError) : r)
      a
    -> Sem
         ((Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError)
            : AtomicState (Seq TmuxRequest) : r)
         a)
-> Sem
     ((Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError) : r)
     a
-> Sem (AtomicState (Seq TmuxRequest) : r) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  Sem
  ((Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError) : r)
  a
-> Sem
     ((Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError)
        : AtomicState (Seq TmuxRequest) : r)
     a
forall (e2 :: (* -> *) -> * -> *) (e1 :: (* -> *) -> * -> *)
       (r :: EffectRow) a.
Sem (e1 : r) a -> Sem (e1 : e2 : r) a
raiseUnder
{-# inline interpretTmuxWithProcess #-}

interpretTmuxNative ::
  ∀ r .
  Members [Reader TmuxNative, Log, Resource, Race, Async, Embed IO] r =>
  InterpreterFor (Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError) r
interpretTmuxNative :: forall (r :: EffectRow).
Members
  '[Reader TmuxNative, Log, Resource, Race, Async, Embed IO] r =>
InterpreterFor
  (Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError) r
interpretTmuxNative =
  Sem
  ((Scoped_ (SystemProcess !! SystemProcessError)
    !! SystemProcessScopeError)
     : r)
  a
-> Sem r a
forall (r :: EffectRow).
Members '[Reader TmuxNative, Resource, Race, Async, Embed IO] r =>
InterpreterFor
  (Scoped_ (SystemProcess !! SystemProcessError)
   !! SystemProcessScopeError)
  r
InterpreterFor
  (Scoped_ (SystemProcess !! SystemProcessError)
   !! SystemProcessScopeError)
  r
interpretSystemProcessTmux (Sem
   ((Scoped_ (SystemProcess !! SystemProcessError)
     !! SystemProcessScopeError)
      : r)
   a
 -> Sem r a)
-> (Sem
      ((Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError) : r)
      a
    -> Sem
         ((Scoped_ (SystemProcess !! SystemProcessError)
           !! SystemProcessScopeError)
            : r)
         a)
-> Sem
     ((Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError) : r)
     a
-> Sem r a
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  Sem
  ((Scoped_ (Process ByteString (Either Text TmuxOutputBlock))
    !! ProcessError)
     : (Scoped_ (SystemProcess !! SystemProcessError)
        !! SystemProcessScopeError)
     : r)
  a
-> Sem
     ((Scoped_ (SystemProcess !! SystemProcessError)
       !! SystemProcessScopeError)
        : r)
     a
forall (r :: EffectRow).
(Member
   (Scoped_ (SystemProcess !! SystemProcessError)
    !! SystemProcessScopeError)
   r,
 Members '[Resource, Race, Async, Embed IO] r) =>
InterpreterFor
  (Scoped_ (Process ByteString (Either Text TmuxOutputBlock))
   !! ProcessError)
  r
InterpreterFor
  (Scoped_ (Process ByteString (Either Text TmuxOutputBlock))
   !! ProcessError)
  ((Scoped_ (SystemProcess !! SystemProcessError)
    !! SystemProcessScopeError)
     : r)
interpretProcessTmux (Sem
   ((Scoped_ (Process ByteString (Either Text TmuxOutputBlock))
     !! ProcessError)
      : (Scoped_ (SystemProcess !! SystemProcessError)
         !! SystemProcessScopeError)
      : r)
   a
 -> Sem
      ((Scoped_ (SystemProcess !! SystemProcessError)
        !! SystemProcessScopeError)
         : r)
      a)
-> (Sem
      ((Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError) : r)
      a
    -> Sem
         ((Scoped_ (Process ByteString (Either Text TmuxOutputBlock))
           !! ProcessError)
            : (Scoped_ (SystemProcess !! SystemProcessError)
               !! SystemProcessScopeError)
            : r)
         a)
-> Sem
     ((Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError) : r)
     a
-> Sem
     ((Scoped_ (SystemProcess !! SystemProcessError)
       !! SystemProcessScopeError)
        : r)
     a
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  Sem
  ((Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError)
     : (Scoped_ (Process ByteString (Either Text TmuxOutputBlock))
        !! ProcessError)
     : (Scoped_ (SystemProcess !! SystemProcessError)
        !! SystemProcessScopeError)
     : r)
  a
-> Sem
     ((Scoped_ (Process ByteString (Either Text TmuxOutputBlock))
       !! ProcessError)
        : (Scoped_ (SystemProcess !! SystemProcessError)
           !! SystemProcessScopeError)
        : r)
     a
forall (r :: EffectRow).
Members
  '[Scoped_ (Process ByteString (Either Text TmuxOutputBlock))
    !! ProcessError,
    Log, Embed IO]
  r =>
InterpreterFor
  (Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError) r
InterpreterFor
  (Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError)
  ((Scoped_ (Process ByteString (Either Text TmuxOutputBlock))
    !! ProcessError)
     : (Scoped_ (SystemProcess !! SystemProcessError)
        !! SystemProcessScopeError)
     : r)
interpretTmuxWithProcess (Sem
   ((Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError)
      : (Scoped_ (Process ByteString (Either Text TmuxOutputBlock))
         !! ProcessError)
      : (Scoped_ (SystemProcess !! SystemProcessError)
         !! SystemProcessScopeError)
      : r)
   a
 -> Sem
      ((Scoped_ (Process ByteString (Either Text TmuxOutputBlock))
        !! ProcessError)
         : (Scoped_ (SystemProcess !! SystemProcessError)
            !! SystemProcessScopeError)
         : r)
      a)
-> (Sem
      ((Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError) : r)
      a
    -> Sem
         ((Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError)
            : (Scoped_ (Process ByteString (Either Text TmuxOutputBlock))
               !! ProcessError)
            : (Scoped_ (SystemProcess !! SystemProcessError)
               !! SystemProcessScopeError)
            : r)
         a)
-> Sem
     ((Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError) : r)
     a
-> Sem
     ((Scoped_ (Process ByteString (Either Text TmuxOutputBlock))
       !! ProcessError)
        : (Scoped_ (SystemProcess !! SystemProcessError)
           !! SystemProcessScopeError)
        : r)
     a
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  Sem
  ((Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError) : r)
  a
-> Sem
     ((Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError)
        : (Scoped_ (Process ByteString (Either Text TmuxOutputBlock))
           !! ProcessError)
        : (Scoped_ (SystemProcess !! SystemProcessError)
           !! SystemProcessScopeError)
        : r)
     a
forall (e2 :: (* -> *) -> * -> *) (e3 :: (* -> *) -> * -> *)
       (e1 :: (* -> *) -> * -> *) (r :: EffectRow) a.
Sem (e1 : r) a -> Sem (e1 : e2 : e3 : r) a
raiseUnder2
{-# inline interpretTmuxNative #-}

interpretTmuxFailing ::
  TmuxError ->
  InterpreterFor (Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError) r
interpretTmuxFailing :: forall (r :: EffectRow).
TmuxError
-> InterpreterFor
     (Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError) r
interpretTmuxFailing TmuxError
err =
  (forall (q :: (* -> *) -> * -> *).
 () -> Sem (Stop TmuxError : Opaque q : r) ())
-> (forall (q :: (* -> *) -> * -> *) (r0 :: EffectRow) x.
    ()
    -> TmuxClient TmuxRequest TmuxResponse (Sem r0) x
    -> Sem (Stop TmuxError : Opaque q : r) x)
-> InterpreterFor
     (Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError) r
forall param resource (effect :: (* -> *) -> * -> *) err
       (r :: EffectRow).
(forall (q :: (* -> *) -> * -> *).
 param -> Sem (Stop err : Opaque q : r) resource)
-> (forall (q :: (* -> *) -> * -> *) (r0 :: EffectRow) x.
    resource -> effect (Sem r0) x -> Sem (Stop err : Opaque q : r) x)
-> InterpreterFor (Scoped param effect !! err) r
interpretScopedResumable_ () -> Sem (Stop TmuxError : Opaque q : r) ()
forall a. Monoid a => a
forall (q :: (* -> *) -> * -> *).
() -> Sem (Stop TmuxError : Opaque q : r) ()
mempty \ () -> \case
    TmuxClient.Schedule TmuxRequest
_ ->
      TmuxError -> Sem (Stop TmuxError : Opaque q : r) x
forall e (r :: EffectRow) a. Member (Stop e) r => e -> Sem r a
stop TmuxError
err
    TmuxClient.Send TmuxRequest
_ ->
      TmuxError -> Sem (Stop TmuxError : Opaque q : r) x
forall e (r :: EffectRow) a. Member (Stop e) r => e -> Sem r a
stop TmuxError
err

withTmuxNativeEnv ::
  Member (Embed IO) r =>
  Maybe (Path Abs File) ->
  (Maybe TmuxNative -> Sem r a) ->
  Sem r a
withTmuxNativeEnv :: forall (r :: EffectRow) a.
Member (Embed IO) r =>
Maybe (Path Abs File) -> (Maybe TmuxNative -> Sem r a) -> Sem r a
withTmuxNativeEnv Maybe (Path Abs File)
socket Maybe TmuxNative -> Sem r a
use =
  Maybe TmuxNative -> Sem r a
use (Maybe TmuxNative -> Sem r a)
-> (Either Text (Path Abs File) -> Maybe TmuxNative)
-> Either Text (Path Abs File)
-> Sem r a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Path Abs File -> TmuxNative)
-> Maybe (Path Abs File) -> Maybe TmuxNative
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((Path Abs File -> Maybe (Path Abs File) -> TmuxNative)
-> Maybe (Path Abs File) -> Path Abs File -> TmuxNative
forall a b c. (a -> b -> c) -> b -> a -> c
flip Path Abs File -> Maybe (Path Abs File) -> TmuxNative
TmuxNative Maybe (Path Abs File)
socket) (Maybe (Path Abs File) -> Maybe TmuxNative)
-> (Either Text (Path Abs File) -> Maybe (Path Abs File))
-> Either Text (Path Abs File)
-> Maybe TmuxNative
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Either Text (Path Abs File) -> Maybe (Path Abs File)
forall l r. Either l r -> Maybe r
rightToMaybe (Either Text (Path Abs File) -> Sem r a)
-> Sem r (Either Text (Path Abs File)) -> Sem r a
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Path Rel File
-> Maybe (Path Abs File) -> Sem r (Either Text (Path Abs File))
forall (r :: EffectRow).
Member (Embed IO) r =>
Path Rel File
-> Maybe (Path Abs File) -> Sem r (Either Text (Path Abs File))
resolveExecutable [relfile|tmux|] Maybe (Path Abs File)
forall a. Maybe a
Nothing

runReaderTmuxNativeEnv ::
  Members [Error TmuxError, Embed IO] r =>
  Maybe (Path Abs File) ->
  InterpreterFor (Reader TmuxNative) r
runReaderTmuxNativeEnv :: forall (r :: EffectRow).
Members '[Error TmuxError, Embed IO] r =>
Maybe (Path Abs File) -> InterpreterFor (Reader TmuxNative) r
runReaderTmuxNativeEnv Maybe (Path Abs File)
socket Sem (Reader TmuxNative : r) a
sem = do
  TmuxNative
tn <- Maybe (Path Abs File)
-> (Maybe TmuxNative -> Sem r TmuxNative) -> Sem r TmuxNative
forall (r :: EffectRow) a.
Member (Embed IO) r =>
Maybe (Path Abs File) -> (Maybe TmuxNative -> Sem r a) -> Sem r a
withTmuxNativeEnv Maybe (Path Abs File)
socket (TmuxError -> Maybe TmuxNative -> Sem r TmuxNative
forall e (r :: EffectRow) a.
Member (Error e) r =>
e -> Maybe a -> Sem r a
note TmuxError
NoExe)
  TmuxNative -> Sem (Reader TmuxNative : r) a -> Sem r a
forall i (r :: EffectRow) a. i -> Sem (Reader i : r) a -> Sem r a
runReader TmuxNative
tn Sem (Reader TmuxNative : r) a
sem
{-# inline runReaderTmuxNativeEnv #-}

interpretTmuxNativeEnv ::
  Members [Error TmuxError, Log, Resource, Race, Async, Embed IO] r =>
  Maybe (Path Abs File) ->
  InterpreterFor (Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError) r
interpretTmuxNativeEnv :: forall (r :: EffectRow).
Members
  '[Error TmuxError, Log, Resource, Race, Async, Embed IO] r =>
Maybe (Path Abs File)
-> InterpreterFor
     (Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError) r
interpretTmuxNativeEnv Maybe (Path Abs File)
socket =
  Maybe (Path Abs File) -> InterpreterFor (Reader TmuxNative) r
forall (r :: EffectRow).
Members '[Error TmuxError, Embed IO] r =>
Maybe (Path Abs File) -> InterpreterFor (Reader TmuxNative) r
runReaderTmuxNativeEnv Maybe (Path Abs File)
socket (Sem (Reader TmuxNative : r) a -> Sem r a)
-> (Sem
      ((Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError) : r)
      a
    -> Sem (Reader TmuxNative : r) a)
-> Sem
     ((Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError) : r)
     a
-> Sem r a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Sem
  ((Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError)
     : Reader TmuxNative : r)
  a
-> Sem (Reader TmuxNative : r) a
forall (r :: EffectRow).
Members
  '[Reader TmuxNative, Log, Resource, Race, Async, Embed IO] r =>
InterpreterFor
  (Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError) r
InterpreterFor
  (Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError)
  (Reader TmuxNative : r)
interpretTmuxNative (Sem
   ((Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError)
      : Reader TmuxNative : r)
   a
 -> Sem (Reader TmuxNative : r) a)
-> (Sem
      ((Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError) : r)
      a
    -> Sem
         ((Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError)
            : Reader TmuxNative : r)
         a)
-> Sem
     ((Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError) : r)
     a
-> Sem (Reader TmuxNative : r) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Sem
  ((Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError) : r)
  a
-> Sem
     ((Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError)
        : Reader TmuxNative : r)
     a
forall (e2 :: (* -> *) -> * -> *) (e1 :: (* -> *) -> * -> *)
       (r :: EffectRow) a.
Sem (e1 : r) a -> Sem (e1 : e2 : r) a
raiseUnder
{-# inline interpretTmuxNativeEnv #-}

interpretTmuxNativeEnvGraceful ::
  Members [Log, Resource, Race, Async, Embed IO] r =>
  Maybe (Path Abs File) ->
  InterpreterFor (Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError) r
interpretTmuxNativeEnvGraceful :: forall (r :: EffectRow).
Members '[Log, Resource, Race, Async, Embed IO] r =>
Maybe (Path Abs File)
-> InterpreterFor
     (Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError) r
interpretTmuxNativeEnvGraceful Maybe (Path Abs File)
socket Sem
  ((Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError) : r)
  a
sem =
  Maybe (Path Abs File) -> (Maybe TmuxNative -> Sem r a) -> Sem r a
forall (r :: EffectRow) a.
Member (Embed IO) r =>
Maybe (Path Abs File) -> (Maybe TmuxNative -> Sem r a) -> Sem r a
withTmuxNativeEnv Maybe (Path Abs File)
socket \case
    Just TmuxNative
tn -> TmuxNative -> Sem (Reader TmuxNative : r) a -> Sem r a
forall i (r :: EffectRow) a. i -> Sem (Reader i : r) a -> Sem r a
runReader TmuxNative
tn (Sem
  ((Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError)
     : Reader TmuxNative : r)
  a
-> Sem (Reader TmuxNative : r) a
forall (r :: EffectRow).
Members
  '[Reader TmuxNative, Log, Resource, Race, Async, Embed IO] r =>
InterpreterFor
  (Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError) r
InterpreterFor
  (Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError)
  (Reader TmuxNative : r)
interpretTmuxNative (Sem
  ((Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError) : r)
  a
-> Sem
     ((Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError)
        : Reader TmuxNative : r)
     a
forall (e2 :: (* -> *) -> * -> *) (e1 :: (* -> *) -> * -> *)
       (r :: EffectRow) a.
Sem (e1 : r) a -> Sem (e1 : e2 : r) a
raiseUnder Sem
  ((Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError) : r)
  a
sem))
    Maybe TmuxNative
Nothing -> TmuxError
-> InterpreterFor
     (Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError) r
forall (r :: EffectRow).
TmuxError
-> InterpreterFor
     (Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError) r
interpretTmuxFailing TmuxError
NoExe Sem
  ((Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError) : r)
  a
sem
{-# inline interpretTmuxNativeEnvGraceful #-}

interpretTmuxClientNull ::
  InterpreterFor (Scoped_ (TmuxClient i ()) !! TmuxError) r
interpretTmuxClientNull :: forall i (r :: EffectRow) a.
Sem ((Scoped_ (TmuxClient i ()) !! TmuxError) : r) a -> Sem r a
interpretTmuxClientNull =
  (forall (q :: (* -> *) -> * -> *).
 () -> Sem (Stop TmuxError : Opaque q : r) ())
-> (forall (q :: (* -> *) -> * -> *) (r0 :: EffectRow) x.
    ()
    -> TmuxClient i () (Sem r0) x
    -> Sem (Stop TmuxError : Opaque q : r) x)
-> InterpreterFor (Scoped () (TmuxClient i ()) !! TmuxError) r
forall param resource (effect :: (* -> *) -> * -> *) err
       (r :: EffectRow).
(forall (q :: (* -> *) -> * -> *).
 param -> Sem (Stop err : Opaque q : r) resource)
-> (forall (q :: (* -> *) -> * -> *) (r0 :: EffectRow) x.
    resource -> effect (Sem r0) x -> Sem (Stop err : Opaque q : r) x)
-> InterpreterFor (Scoped param effect !! err) r
interpretScopedResumable_ () -> Sem (Stop TmuxError : Opaque q : r) ()
forall a. Monoid a => a
forall (q :: (* -> *) -> * -> *).
() -> Sem (Stop TmuxError : Opaque q : r) ()
mempty \ () -> \case
    TmuxClient.Schedule i
_ ->
      Sem (Stop TmuxError : Opaque q : r) x
Sem (Stop TmuxError : Opaque q : r) ()
forall (f :: * -> *). Applicative f => f ()
unit
    TmuxClient.Send i
_ ->
      Sem (Stop TmuxError : Opaque q : r) x
Sem (Stop TmuxError : Opaque q : r) ()
forall (f :: * -> *). Applicative f => f ()
unit
{-# inline interpretTmuxClientNull #-}