-- | Provides a dynamic effect for haskeline.
--
-- @since 0.1
module Effectful.Haskeline.Dynamic
  ( -- * Effect
    Haskeline (..),
    haveTerminalUI,
    getInputLine,
    getInputLineWithInitial,
    getInputChar,
    getPassword,
    waitForAnyKey,
    outputStr,
    outputStrLn,
    getHistory,
    putHistory,
    modifyHistory,
    withInterrupt,
    handleInterrupt,

    -- ** Handlers
    runHaskeline,

    -- * Reader
    -- $reader
    Static.runEffInputTEnv,
    Static.runInputTEnv,
    Static.runInputTEnvWith,

    -- * Haskeline Re-exports

    -- ** Types
    InputT,
    InputTEnv,

    -- ** IO Runners
    H.runInputT,
    H.runInputTBehavior,
    H.runInputTBehaviorWithPrefs,

    -- ** Config
    H.defaultSettings,
    H.defaultBehavior,
    H.defaultPrefs,
  )
where

import Effectful
  ( Dispatch (Dynamic),
    DispatchOf,
    Eff,
    Effect,
    IOE,
    type (:>),
  )
import Effectful.Dispatch.Dynamic (HasCallStack, localSeqUnlift, reinterpret, send)
import Effectful.Dynamic.Utils (ShowEffect (showEffectCons))
import Effectful.Haskeline.Static qualified as Static
import Effectful.Reader.Static (Reader)
import System.Console.Haskeline (InputT)
import System.Console.Haskeline qualified as H
import System.Console.Haskeline.History (History)
import System.Console.Haskeline.ReaderT (InputTEnv)

-- | @since 0.1
type instance DispatchOf Haskeline = Dynamic

-- | Dynamic haskeline effect.
--
-- @since 0.1
data Haskeline :: Effect where
  HaveTerminalUI :: Haskeline m Bool
  GetInputLine :: String -> Haskeline m (Maybe String)
  GetInputLineWithInitial :: String -> (String, String) -> Haskeline m (Maybe String)
  GetInputChar :: String -> Haskeline m (Maybe Char)
  GetPassword :: Maybe Char -> String -> Haskeline m (Maybe String)
  WaitForAnyKey :: String -> Haskeline m Bool
  OutputStr :: String -> Haskeline m ()
  OutputStrLn :: String -> Haskeline m ()
  GetHistory :: Haskeline m History
  PutHistory :: History -> Haskeline m ()
  ModifyHistory :: (History -> History) -> Haskeline m ()
  WithInterrupt :: m a -> Haskeline m a
  HandleInterrupt :: m a -> m a -> Haskeline m a

-- | @since 0.1
instance ShowEffect Haskeline where
  showEffectCons :: forall (m :: * -> *) a. Haskeline m a -> String
showEffectCons = \case
    Haskeline m a
HaveTerminalUI -> String
"HaveTerminalUI"
    GetInputLine String
_ -> String
"GetInputLine"
    GetInputLineWithInitial {} -> String
"GetInputLineWithInitial"
    GetInputChar String
_ -> String
"GetInputChar"
    GetPassword {} -> String
"GetPassword"
    WaitForAnyKey String
_ -> String
"WaitForAnyKey"
    OutputStr String
_ -> String
"OutputStr"
    OutputStrLn String
_ -> String
"OutputStrLn"
    Haskeline m a
GetHistory -> String
"GetHistory"
    PutHistory History
_ -> String
"PutHistory"
    ModifyHistory History -> History
_ -> String
"ModifyHistory"
    WithInterrupt m a
_ -> String
"WithInterrupt"
    HandleInterrupt {} -> String
"HandleInterrupt"

-- | Runs 'Haskeline' in 'IO'.
--
-- @since 0.1
runHaskeline ::
  forall es a.
  ( HasCallStack,
    IOE :> es,
    Reader (InputTEnv IO) :> es
  ) =>
  Eff (Haskeline : es) a ->
  Eff es a
runHaskeline :: forall (es :: [(* -> *) -> * -> *]) a.
(HasCallStack, IOE :> es, Reader (InputTEnv IO) :> es) =>
Eff (Haskeline : es) a -> Eff es a
runHaskeline = (Eff (Haskeline : es) a -> Eff es a)
-> EffectHandler Haskeline (Haskeline : es)
-> Eff (Haskeline : es) a
-> Eff es a
forall (e :: (* -> *) -> * -> *)
       (handlerEs :: [(* -> *) -> * -> *]) a (es :: [(* -> *) -> * -> *])
       b.
(HasCallStack, DispatchOf e ~ 'Dynamic) =>
(Eff handlerEs a -> Eff es b)
-> EffectHandler e handlerEs -> Eff (e : es) a -> Eff es b
reinterpret Eff (Haskeline : es) a -> Eff es a
forall (es :: [(* -> *) -> * -> *]) a.
(HasCallStack, IOE :> es) =>
Eff (Haskeline : es) a -> Eff es a
Static.runHaskeline (EffectHandler Haskeline (Haskeline : es)
 -> Eff (Haskeline : es) a -> Eff es a)
-> EffectHandler Haskeline (Haskeline : es)
-> Eff (Haskeline : es) a
-> Eff es a
forall a b. (a -> b) -> a -> b
$ \LocalEnv localEs (Haskeline : es)
env -> \case
  Haskeline (Eff localEs) a
HaveTerminalUI -> Eff (Haskeline : es) a
Eff (Haskeline : es) Bool
forall (es :: [(* -> *) -> * -> *]).
(HasCallStack, Haskeline :> es, Reader (InputTEnv IO) :> es) =>
Eff es Bool
Static.haveTerminalUI
  GetInputLine String
s -> String -> Eff (Haskeline : es) (Maybe String)
forall (es :: [(* -> *) -> * -> *]).
(HasCallStack, Haskeline :> es, Reader (InputTEnv IO) :> es) =>
String -> Eff es (Maybe String)
Static.getInputLine String
s
  GetInputLineWithInitial String
s (String, String)
t -> String -> (String, String) -> Eff (Haskeline : es) (Maybe String)
forall (es :: [(* -> *) -> * -> *]).
(HasCallStack, Haskeline :> es, Reader (InputTEnv IO) :> es) =>
String -> (String, String) -> Eff es (Maybe String)
Static.getInputLineWithInitial String
s (String, String)
t
  GetInputChar String
s -> String -> Eff (Haskeline : es) (Maybe Char)
forall (es :: [(* -> *) -> * -> *]).
(HasCallStack, Haskeline :> es, Reader (InputTEnv IO) :> es) =>
String -> Eff es (Maybe Char)
Static.getInputChar String
s
  GetPassword Maybe Char
s String
c -> Maybe Char -> String -> Eff (Haskeline : es) (Maybe String)
forall (es :: [(* -> *) -> * -> *]).
(HasCallStack, Haskeline :> es, Reader (InputTEnv IO) :> es) =>
Maybe Char -> String -> Eff es (Maybe String)
Static.getPassword Maybe Char
s String
c
  WaitForAnyKey String
s -> String -> Eff (Haskeline : es) Bool
forall (es :: [(* -> *) -> * -> *]).
(HasCallStack, Haskeline :> es, Reader (InputTEnv IO) :> es) =>
String -> Eff es Bool
Static.waitForAnyKey String
s
  OutputStr String
s -> String -> Eff (Haskeline : es) ()
forall (es :: [(* -> *) -> * -> *]).
(HasCallStack, Haskeline :> es, Reader (InputTEnv IO) :> es) =>
String -> Eff es ()
Static.outputStr String
s
  OutputStrLn String
s -> String -> Eff (Haskeline : es) ()
forall (es :: [(* -> *) -> * -> *]).
(HasCallStack, Haskeline :> es, Reader (InputTEnv IO) :> es) =>
String -> Eff es ()
Static.outputStrLn String
s
  Haskeline (Eff localEs) a
GetHistory -> Eff (Haskeline : es) a
Eff (Haskeline : es) History
forall (es :: [(* -> *) -> * -> *]).
(HasCallStack, Haskeline :> es, Reader (InputTEnv IO) :> es) =>
Eff es History
Static.getHistory
  PutHistory History
h -> History -> Eff (Haskeline : es) ()
forall (es :: [(* -> *) -> * -> *]).
(HasCallStack, Haskeline :> es, Reader (InputTEnv IO) :> es) =>
History -> Eff es ()
Static.putHistory History
h
  ModifyHistory History -> History
f -> (History -> History) -> Eff (Haskeline : es) ()
forall (es :: [(* -> *) -> * -> *]).
(HasCallStack, Haskeline :> es, Reader (InputTEnv IO) :> es) =>
(History -> History) -> Eff es ()
Static.modifyHistory History -> History
f
  WithInterrupt Eff localEs a
m ->
    LocalEnv localEs (Haskeline : es)
-> ((forall r. Eff localEs r -> Eff (Haskeline : es) r)
    -> Eff (Haskeline : es) a)
-> Eff (Haskeline : es) a
forall (es :: [(* -> *) -> * -> *])
       (handlerEs :: [(* -> *) -> * -> *])
       (localEs :: [(* -> *) -> * -> *]) a.
(HasCallStack, SharedSuffix es handlerEs) =>
LocalEnv localEs handlerEs
-> ((forall r. Eff localEs r -> Eff es r) -> Eff es a) -> Eff es a
localSeqUnlift LocalEnv localEs (Haskeline : es)
env (((forall r. Eff localEs r -> Eff (Haskeline : es) r)
  -> Eff (Haskeline : es) a)
 -> Eff (Haskeline : es) a)
-> ((forall r. Eff localEs r -> Eff (Haskeline : es) r)
    -> Eff (Haskeline : es) a)
-> Eff (Haskeline : es) a
forall a b. (a -> b) -> a -> b
$ \forall r. Eff localEs r -> Eff (Haskeline : es) r
runInStatic ->
      Eff (Haskeline : es) a -> Eff (Haskeline : es) a
forall (es :: [(* -> *) -> * -> *]) a.
(HasCallStack, Haskeline :> es, Reader (InputTEnv IO) :> es) =>
Eff es a -> Eff es a
Static.withInterrupt (Eff localEs a -> Eff (Haskeline : es) a
forall r. Eff localEs r -> Eff (Haskeline : es) r
runInStatic Eff localEs a
m)
  HandleInterrupt Eff localEs a
m1 Eff localEs a
m2 ->
    LocalEnv localEs (Haskeline : es)
-> ((forall r. Eff localEs r -> Eff (Haskeline : es) r)
    -> Eff (Haskeline : es) a)
-> Eff (Haskeline : es) a
forall (es :: [(* -> *) -> * -> *])
       (handlerEs :: [(* -> *) -> * -> *])
       (localEs :: [(* -> *) -> * -> *]) a.
(HasCallStack, SharedSuffix es handlerEs) =>
LocalEnv localEs handlerEs
-> ((forall r. Eff localEs r -> Eff es r) -> Eff es a) -> Eff es a
localSeqUnlift LocalEnv localEs (Haskeline : es)
env (((forall r. Eff localEs r -> Eff (Haskeline : es) r)
  -> Eff (Haskeline : es) a)
 -> Eff (Haskeline : es) a)
-> ((forall r. Eff localEs r -> Eff (Haskeline : es) r)
    -> Eff (Haskeline : es) a)
-> Eff (Haskeline : es) a
forall a b. (a -> b) -> a -> b
$ \forall r. Eff localEs r -> Eff (Haskeline : es) r
runInStatic ->
      Eff (Haskeline : es) a
-> Eff (Haskeline : es) a -> Eff (Haskeline : es) a
forall (es :: [(* -> *) -> * -> *]) a.
(HasCallStack, Haskeline :> es, Reader (InputTEnv IO) :> es) =>
Eff es a -> Eff es a -> Eff es a
Static.handleInterrupt (Eff localEs a -> Eff (Haskeline : es) a
forall r. Eff localEs r -> Eff (Haskeline : es) r
runInStatic Eff localEs a
m1) (Eff localEs a -> Eff (Haskeline : es) a
forall r. Eff localEs r -> Eff (Haskeline : es) r
runInStatic Eff localEs a
m2)

-- $reader
--
-- These functions allow eliminating the 'Haskeline' effect in terms of
-- 'Control.Monad.Trans.Reader.ReaderT'.
--
-- __Examples:__
--
-- @
--  app :: (Haskeline :> es) => Eff es String
--  app = do
--    mLine <- getInputLine "Enter your name: "
--    let name = fromMaybe "\<blank\>" mLine
--    outputStrLn $ "Hello: " ++ name
--    pure name
--
--  appIO :: IO String
--  appIO = do
--    runInputTEnv
--      $ \env -> runEffInputTEnv env
--      $ runHaskeline app
--
-- runHaskelinePure :: Eff (Haskeline : es) a -> Eff es a
-- runHaskelinePure = interpret_ $ \\case
--   GetInputLine _ -> pure $ Just "some name"
--   OutputStrLn _ -> pure ()
--   _ -> error "todo"
--
-- appPure :: String
-- appPure = runPureEff $ runHaskelinePure app
-- @

-- | Lifted 'H.haveTerminalUI'.
--
-- @since 0.1
haveTerminalUI :: (HasCallStack, Haskeline :> es) => Eff es Bool
haveTerminalUI :: forall (es :: [(* -> *) -> * -> *]).
(HasCallStack, Haskeline :> es) =>
Eff es Bool
haveTerminalUI = Haskeline (Eff es) Bool -> Eff es Bool
forall (e :: (* -> *) -> * -> *) (es :: [(* -> *) -> * -> *]) a.
(HasCallStack, DispatchOf e ~ 'Dynamic, e :> es) =>
e (Eff es) a -> Eff es a
send Haskeline (Eff es) Bool
forall (m :: * -> *). Haskeline m Bool
HaveTerminalUI

-- | Lifted 'H.getInputLine'.
--
-- @since 0.1
getInputLine ::
  ( HasCallStack,
    Haskeline :> es
  ) =>
  String -> Eff es (Maybe String)
getInputLine :: forall (es :: [(* -> *) -> * -> *]).
(HasCallStack, Haskeline :> es) =>
String -> Eff es (Maybe String)
getInputLine = Haskeline (Eff es) (Maybe String) -> Eff es (Maybe String)
forall (e :: (* -> *) -> * -> *) (es :: [(* -> *) -> * -> *]) a.
(HasCallStack, DispatchOf e ~ 'Dynamic, e :> es) =>
e (Eff es) a -> Eff es a
send (Haskeline (Eff es) (Maybe String) -> Eff es (Maybe String))
-> (String -> Haskeline (Eff es) (Maybe String))
-> String
-> Eff es (Maybe String)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Haskeline (Eff es) (Maybe String)
forall (m :: * -> *). String -> Haskeline m (Maybe String)
GetInputLine

-- | Lifted 'H.getInputLineWithInitial'.
--
-- @since 0.1
getInputLineWithInitial ::
  ( HasCallStack,
    Haskeline :> es
  ) =>
  String ->
  (String, String) ->
  Eff es (Maybe String)
getInputLineWithInitial :: forall (es :: [(* -> *) -> * -> *]).
(HasCallStack, Haskeline :> es) =>
String -> (String, String) -> Eff es (Maybe String)
getInputLineWithInitial String
s = Haskeline (Eff es) (Maybe String) -> Eff es (Maybe String)
forall (e :: (* -> *) -> * -> *) (es :: [(* -> *) -> * -> *]) a.
(HasCallStack, DispatchOf e ~ 'Dynamic, e :> es) =>
e (Eff es) a -> Eff es a
send (Haskeline (Eff es) (Maybe String) -> Eff es (Maybe String))
-> ((String, String) -> Haskeline (Eff es) (Maybe String))
-> (String, String)
-> Eff es (Maybe String)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> (String, String) -> Haskeline (Eff es) (Maybe String)
forall (m :: * -> *).
String -> (String, String) -> Haskeline m (Maybe String)
GetInputLineWithInitial String
s

-- | Lifted 'H.havegetInputCharTerminalUI'.
--
-- @since 0.1
getInputChar :: (HasCallStack, Haskeline :> es) => String -> Eff es (Maybe Char)
getInputChar :: forall (es :: [(* -> *) -> * -> *]).
(HasCallStack, Haskeline :> es) =>
String -> Eff es (Maybe Char)
getInputChar = Haskeline (Eff es) (Maybe Char) -> Eff es (Maybe Char)
forall (e :: (* -> *) -> * -> *) (es :: [(* -> *) -> * -> *]) a.
(HasCallStack, DispatchOf e ~ 'Dynamic, e :> es) =>
e (Eff es) a -> Eff es a
send (Haskeline (Eff es) (Maybe Char) -> Eff es (Maybe Char))
-> (String -> Haskeline (Eff es) (Maybe Char))
-> String
-> Eff es (Maybe Char)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Haskeline (Eff es) (Maybe Char)
forall (m :: * -> *). String -> Haskeline m (Maybe Char)
GetInputChar

-- | Lifted 'H.getPassword'.
--
-- @since 0.1
getPassword ::
  ( HasCallStack,
    Haskeline :> es
  ) =>
  Maybe Char ->
  String ->
  Eff es (Maybe String)
getPassword :: forall (es :: [(* -> *) -> * -> *]).
(HasCallStack, Haskeline :> es) =>
Maybe Char -> String -> Eff es (Maybe String)
getPassword Maybe Char
c = Haskeline (Eff es) (Maybe String) -> Eff es (Maybe String)
forall (e :: (* -> *) -> * -> *) (es :: [(* -> *) -> * -> *]) a.
(HasCallStack, DispatchOf e ~ 'Dynamic, e :> es) =>
e (Eff es) a -> Eff es a
send (Haskeline (Eff es) (Maybe String) -> Eff es (Maybe String))
-> (String -> Haskeline (Eff es) (Maybe String))
-> String
-> Eff es (Maybe String)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe Char -> String -> Haskeline (Eff es) (Maybe String)
forall (m :: * -> *).
Maybe Char -> String -> Haskeline m (Maybe String)
GetPassword Maybe Char
c

-- | Lifted 'H.waitForAnyKey'.
--
-- @since 0.1
waitForAnyKey :: (HasCallStack, Haskeline :> es) => String -> Eff es Bool
waitForAnyKey :: forall (es :: [(* -> *) -> * -> *]).
(HasCallStack, Haskeline :> es) =>
String -> Eff es Bool
waitForAnyKey = Haskeline (Eff es) Bool -> Eff es Bool
forall (e :: (* -> *) -> * -> *) (es :: [(* -> *) -> * -> *]) a.
(HasCallStack, DispatchOf e ~ 'Dynamic, e :> es) =>
e (Eff es) a -> Eff es a
send (Haskeline (Eff es) Bool -> Eff es Bool)
-> (String -> Haskeline (Eff es) Bool) -> String -> Eff es Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Haskeline (Eff es) Bool
forall (m :: * -> *). String -> Haskeline m Bool
WaitForAnyKey

-- | Lifted 'H.outputStr'.
--
-- @since 0.1
outputStr :: (HasCallStack, Haskeline :> es) => String -> Eff es ()
outputStr :: forall (es :: [(* -> *) -> * -> *]).
(HasCallStack, Haskeline :> es) =>
String -> Eff es ()
outputStr = Haskeline (Eff es) () -> Eff es ()
forall (e :: (* -> *) -> * -> *) (es :: [(* -> *) -> * -> *]) a.
(HasCallStack, DispatchOf e ~ 'Dynamic, e :> es) =>
e (Eff es) a -> Eff es a
send (Haskeline (Eff es) () -> Eff es ())
-> (String -> Haskeline (Eff es) ()) -> String -> Eff es ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Haskeline (Eff es) ()
forall (m :: * -> *). String -> Haskeline m ()
OutputStr

-- | Lifted 'H.outputStrLn'.
--
-- @since 0.1
outputStrLn :: (HasCallStack, Haskeline :> es) => String -> Eff es ()
outputStrLn :: forall (es :: [(* -> *) -> * -> *]).
(HasCallStack, Haskeline :> es) =>
String -> Eff es ()
outputStrLn = Haskeline (Eff es) () -> Eff es ()
forall (e :: (* -> *) -> * -> *) (es :: [(* -> *) -> * -> *]) a.
(HasCallStack, DispatchOf e ~ 'Dynamic, e :> es) =>
e (Eff es) a -> Eff es a
send (Haskeline (Eff es) () -> Eff es ())
-> (String -> Haskeline (Eff es) ()) -> String -> Eff es ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Haskeline (Eff es) ()
forall (m :: * -> *). String -> Haskeline m ()
OutputStrLn

-- | Lifted 'H.getHistory'.
--
-- @since 0.1
getHistory :: (HasCallStack, Haskeline :> es) => Eff es History
getHistory :: forall (es :: [(* -> *) -> * -> *]).
(HasCallStack, Haskeline :> es) =>
Eff es History
getHistory = Haskeline (Eff es) History -> Eff es History
forall (e :: (* -> *) -> * -> *) (es :: [(* -> *) -> * -> *]) a.
(HasCallStack, DispatchOf e ~ 'Dynamic, e :> es) =>
e (Eff es) a -> Eff es a
send Haskeline (Eff es) History
forall (m :: * -> *). Haskeline m History
GetHistory

-- | Lifted 'H.putHistory'.
--
-- @since 0.1
putHistory :: (HasCallStack, Haskeline :> es) => History -> Eff es ()
putHistory :: forall (es :: [(* -> *) -> * -> *]).
(HasCallStack, Haskeline :> es) =>
History -> Eff es ()
putHistory = Haskeline (Eff es) () -> Eff es ()
forall (e :: (* -> *) -> * -> *) (es :: [(* -> *) -> * -> *]) a.
(HasCallStack, DispatchOf e ~ 'Dynamic, e :> es) =>
e (Eff es) a -> Eff es a
send (Haskeline (Eff es) () -> Eff es ())
-> (History -> Haskeline (Eff es) ()) -> History -> Eff es ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. History -> Haskeline (Eff es) ()
forall (m :: * -> *). History -> Haskeline m ()
PutHistory

-- | Lifted 'H.modifyHistory'.
--
-- @since 0.1
modifyHistory :: (HasCallStack, Haskeline :> es) => (History -> History) -> Eff es ()
modifyHistory :: forall (es :: [(* -> *) -> * -> *]).
(HasCallStack, Haskeline :> es) =>
(History -> History) -> Eff es ()
modifyHistory = Haskeline (Eff es) () -> Eff es ()
forall (e :: (* -> *) -> * -> *) (es :: [(* -> *) -> * -> *]) a.
(HasCallStack, DispatchOf e ~ 'Dynamic, e :> es) =>
e (Eff es) a -> Eff es a
send (Haskeline (Eff es) () -> Eff es ())
-> ((History -> History) -> Haskeline (Eff es) ())
-> (History -> History)
-> Eff es ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (History -> History) -> Haskeline (Eff es) ()
forall (m :: * -> *). (History -> History) -> Haskeline m ()
ModifyHistory

-- | Lifted 'H.withInterrupt'.
--
-- @since 0.1
withInterrupt :: (HasCallStack, Haskeline :> es) => Eff es a -> Eff es a
withInterrupt :: forall (es :: [(* -> *) -> * -> *]) a.
(HasCallStack, Haskeline :> es) =>
Eff es a -> Eff es a
withInterrupt = Haskeline (Eff es) a -> Eff es a
forall (e :: (* -> *) -> * -> *) (es :: [(* -> *) -> * -> *]) a.
(HasCallStack, DispatchOf e ~ 'Dynamic, e :> es) =>
e (Eff es) a -> Eff es a
send (Haskeline (Eff es) a -> Eff es a)
-> (Eff es a -> Haskeline (Eff es) a) -> Eff es a -> Eff es a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Eff es a -> Haskeline (Eff es) a
forall (m :: * -> *) a. m a -> Haskeline m a
WithInterrupt

-- | Lifted 'H.handleInterrupt'.
--
-- @since 0.1
handleInterrupt ::
  ( HasCallStack,
    Haskeline :> es
  ) =>
  Eff es a ->
  Eff es a ->
  Eff es a
handleInterrupt :: forall (es :: [(* -> *) -> * -> *]) a.
(HasCallStack, Haskeline :> es) =>
Eff es a -> Eff es a -> Eff es a
handleInterrupt Eff es a
m1 = Haskeline (Eff es) a -> Eff es a
forall (e :: (* -> *) -> * -> *) (es :: [(* -> *) -> * -> *]) a.
(HasCallStack, DispatchOf e ~ 'Dynamic, e :> es) =>
e (Eff es) a -> Eff es a
send (Haskeline (Eff es) a -> Eff es a)
-> (Eff es a -> Haskeline (Eff es) a) -> Eff es a -> Eff es a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Eff es a -> Eff es a -> Haskeline (Eff es) a
forall (m :: * -> *) a. m a -> m a -> Haskeline m a
HandleInterrupt Eff es a
m1