{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveFunctor #-}
{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE DerivingVia #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE KindSignatures #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE UndecidableInstances #-}

-- | __WARNING: the API of this module is not included in the PvP versioning of
-- this package.__
--
-- This module mostly exists to break a cyclic dependency between the Carrier
-- instance and 'ReadlineHistory' which isn't exported from
-- "Control.Effect.Readline".
module Control.Effect.Readline.Internal where

import Control.Effect
import Control.Effect.Carrier
import Control.Effect.Optional
import Control.Effect.Type.Bracket
import Control.Effect.Type.Fix
import Control.Effect.Type.Internal.BaseControl
import Control.Effect.Type.ListenPrim
import Control.Effect.Type.Mask
import Control.Effect.Type.Optional
import Control.Effect.Type.ReaderPrim
import Control.Effect.Type.Regional
import Control.Effect.Type.Split
import Control.Effect.Type.Unlift
import Control.Effect.Type.Unravel
import Control.Effect.Type.WriterPrim
import Control.Monad
import Control.Monad.IO.Class
import Control.Monad.Trans.Control hiding (embed)
import qualified System.Console.Haskeline as H
import qualified System.Console.Haskeline.History as H
import Prelude

data Readline :: Effect where
  GetInputLine :: String -> Readline m (Maybe String)
  GetInputLineWithInitial :: String -> (String, String) -> Readline m (Maybe String)
  GetInputChar :: String -> Readline m (Maybe Char)
  GetPassword :: Maybe Char -> String -> Readline m (Maybe String)
  WaitForAnyKey :: String -> Readline m Bool
  OutputStr :: String -> Readline m ()

-- | Reads one line of input. The final newline (if any) is removed. When using
-- terminal-style interaction, this function provides a rich line-editing user
-- interface.
--
-- If @'H.autoAddHistory' == 'True'@ and the line input is nonblank (i.e., is not all
-- spaces), it will be automatically added to the history.
getInputLine :: Eff Readline m => String -> m (Maybe String)
getInputLine :: String -> m (Maybe String)
getInputLine = Readline m (Maybe String) -> m (Maybe String)
forall (e :: Effect) (m :: * -> *) a.
(Member e (Derivs m), Carrier m) =>
e m a -> m a
send (Readline m (Maybe String) -> m (Maybe String))
-> (String -> Readline m (Maybe String))
-> String
-> m (Maybe String)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Readline m (Maybe String)
forall (m :: * -> *). String -> Readline m (Maybe String)
GetInputLine

-- | Reads one line of input and fills the insertion space with initial text. When using
-- terminal-style interaction, this function provides a rich line-editing user interface with the
-- added ability to give the user default values.
--
-- This function behaves in the exact same manner as 'H.getInputLine', except that
-- it pre-populates the input area. The text that resides in the input area is given as a 2-tuple
-- with two 'String's.   The string on the left of the tuple (obtained by calling 'fst') is
-- what will appear to the left of the cursor and the string on the right (obtained by
-- calling 'snd') is what will appear to the right of the cursor.
--
-- Some examples of calling of this function are:
--
-- > getInputLineWithInitial "prompt> " ("left", "") -- The cursor starts at the end of the line.
-- > getInputLineWithInitial "prompt> " ("left ", "right") -- The cursor starts before the second word.
getInputLineWithInitial ::
  Eff Readline m => String -> (String, String) -> m (Maybe String)
getInputLineWithInitial :: String -> (String, String) -> m (Maybe String)
getInputLineWithInitial String
p = Readline m (Maybe String) -> m (Maybe String)
forall (e :: Effect) (m :: * -> *) a.
(Member e (Derivs m), Carrier m) =>
e m a -> m a
send (Readline m (Maybe String) -> m (Maybe String))
-> ((String, String) -> Readline m (Maybe String))
-> (String, String)
-> m (Maybe String)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> (String, String) -> Readline m (Maybe String)
forall (m :: * -> *).
String -> (String, String) -> Readline m (Maybe String)
GetInputLineWithInitial String
p

-- | Reads one character of input.  Ignores non-printable characters.
--
-- When using terminal-style interaction, the character will be read without waiting
-- for a newline.
--
-- When using file-style interaction, a newline will be read if it is immediately
-- available after the input character.
getInputChar :: Eff Readline m => String -> m (Maybe Char)
getInputChar :: String -> m (Maybe Char)
getInputChar = Readline m (Maybe Char) -> m (Maybe Char)
forall (e :: Effect) (m :: * -> *) a.
(Member e (Derivs m), Carrier m) =>
e m a -> m a
send (Readline m (Maybe Char) -> m (Maybe Char))
-> (String -> Readline m (Maybe Char)) -> String -> m (Maybe Char)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Readline m (Maybe Char)
forall (m :: * -> *). String -> Readline m (Maybe Char)
GetInputChar

-- | Reads one line of input, without displaying the input while it is being typed.
-- When using terminal-style interaction, the masking character (if given) will replace each typed character.
--
-- When using file-style interaction, this function turns off echoing while reading
-- the line of input.
--
-- Note that if Haskeline is built against a version of the @Win32@ library
-- earlier than 2.5, 'getPassword' will incorrectly echo back input on MinTTY
-- consoles (such as Cygwin or MSYS).
getPassword :: Eff Readline m => Maybe Char -> String -> m (Maybe String)
getPassword :: Maybe Char -> String -> m (Maybe String)
getPassword Maybe Char
m = Readline m (Maybe String) -> m (Maybe String)
forall (e :: Effect) (m :: * -> *) a.
(Member e (Derivs m), Carrier m) =>
e m a -> m a
send (Readline m (Maybe String) -> m (Maybe String))
-> (String -> Readline m (Maybe String))
-> String
-> m (Maybe String)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe Char -> String -> Readline m (Maybe String)
forall (m :: * -> *).
Maybe Char -> String -> Readline m (Maybe String)
GetPassword Maybe Char
m

-- | Waits for one key to be pressed, then returns.  Ignores the value
-- of the specific key.
--
-- Returns 'True' if it successfully accepted one key.  Returns 'False'
-- if it encountered the end of input; i.e., an @EOF@ in file-style interaction,
-- or a @Ctrl-D@ in terminal-style interaction.
--
-- When using file-style interaction, consumes a single character from the input which may
-- be non-printable.
waitForAnyKey :: Eff Readline m => String -> m Bool
waitForAnyKey :: String -> m Bool
waitForAnyKey = Readline m Bool -> m Bool
forall (e :: Effect) (m :: * -> *) a.
(Member e (Derivs m), Carrier m) =>
e m a -> m a
send (Readline m Bool -> m Bool)
-> (String -> Readline m Bool) -> String -> m Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Readline m Bool
forall (m :: * -> *). String -> Readline m Bool
WaitForAnyKey

-- | Write a Unicode string to the user's standard output.
outputStr :: Eff Readline m => String -> m ()
outputStr :: String -> m ()
outputStr = Readline m () -> m ()
forall (e :: Effect) (m :: * -> *) a.
(Member e (Derivs m), Carrier m) =>
e m a -> m a
send (Readline m () -> m ())
-> (String -> Readline m ()) -> String -> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Readline m ()
forall (m :: * -> *). String -> Readline m ()
OutputStr

-- | Write a Unicode string to the user's standard output, followed by a newline.
outputStrLn :: Eff Readline m => String -> m ()
outputStrLn :: String -> m ()
outputStrLn String
str = String -> m ()
forall (m :: * -> *). Eff Readline m => String -> m ()
outputStr (String
str String -> String -> String
forall a. Semigroup a => a -> a -> a
<> String
"\n")

data HandleInterrupt :: Effect where
  WithInterrupt :: m a -> HandleInterrupt m a
  HandleInterrupt :: m a -> m a -> HandleInterrupt m a

-- | If Ctrl-C is pressed during the given action, enables interrupt handling
-- within the nested scope. For example:
--
-- > tryAction :: Eff '[Readline, HandleInterrupt] m => m ()
-- > tryAction = handleInterrupt (outputStrLn "Cancelled.")
-- >                $ withInterrupt $ someLongAction
--
-- The action can handle the interrupt itself every time Ctrl-C is pressed.
--
-- > {-# LANGUAGE -XBlockArguments #-}
-- > tryAction :: Eff '[Readline, HandleInterrupt] m => m ()
-- > tryAction = withInterrupt loop where
-- >   loop = someLongAction `catchInterrupt` do
-- >     outputStrLn "Cancelled; trying again."
-- >     loop
--
-- This behavior differs from GHC's built-in Ctrl-C handling, which
-- may immediately terminate the program after the second time that the user presses
-- Ctrl-C.
withInterrupt :: Eff HandleInterrupt m => m a -> m a
withInterrupt :: m a -> m a
withInterrupt = HandleInterrupt m a -> m a
forall (e :: Effect) (m :: * -> *) a.
(Member e (Derivs m), Carrier m) =>
e m a -> m a
send (HandleInterrupt m a -> m a)
-> (m a -> HandleInterrupt m a) -> m a -> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m a -> HandleInterrupt m a
forall (m :: * -> *) a. m a -> HandleInterrupt m a
WithInterrupt

-- | Handle an 'H.Interrupt'. When an interrupt occurs in the second argument,
-- the first argument will be called.
handleInterrupt :: Eff HandleInterrupt m => m a -> m a -> m a
handleInterrupt :: m a -> m a -> m a
handleInterrupt m a
handler = HandleInterrupt m a -> m a
forall (e :: Effect) (m :: * -> *) a.
(Member e (Derivs m), Carrier m) =>
e m a -> m a
send (HandleInterrupt m a -> m a)
-> (m a -> HandleInterrupt m a) -> m a -> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m a -> m a -> HandleInterrupt m a
forall (m :: * -> *) a. m a -> m a -> HandleInterrupt m a
HandleInterrupt m a
handler

-- | Specify a continuation that should be called when an 'H.Interrupt' occurs.
--
-- > catchInterrupt = flip handleInterrupt
catchInterrupt :: Eff HandleInterrupt m => m a -> m a -> m a
catchInterrupt :: m a -> m a -> m a
catchInterrupt = (m a -> m a -> m a) -> m a -> m a -> m a
forall a b c. (a -> b -> c) -> b -> a -> c
flip m a -> m a -> m a
forall (m :: * -> *) a. Eff HandleInterrupt m => m a -> m a -> m a
handleInterrupt

data ReadlineHistory :: Effect where
  GetHistory :: ReadlineHistory m H.History
  PutHistory :: H.History -> ReadlineHistory m ()

-- | Get the 'H.History'.
getHistory :: Eff ReadlineHistory m => m H.History
getHistory :: m History
getHistory = ReadlineHistory m History -> m History
forall (e :: Effect) (m :: * -> *) a.
(Member e (Derivs m), Carrier m) =>
e m a -> m a
send ReadlineHistory m History
forall (m :: * -> *). ReadlineHistory m History
GetHistory

-- | Set the 'H.History'.
putHistory :: Eff ReadlineHistory m => H.History -> m ()
putHistory :: History -> m ()
putHistory = ReadlineHistory m () -> m ()
forall (e :: Effect) (m :: * -> *) a.
(Member e (Derivs m), Carrier m) =>
e m a -> m a
send (ReadlineHistory m () -> m ())
-> (History -> ReadlineHistory m ()) -> History -> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. History -> ReadlineHistory m ()
forall (m :: * -> *). History -> ReadlineHistory m ()
PutHistory

-- | Modify the 'H.History'. The modification is not atomic.
modifyHistory :: Eff ReadlineHistory m => (H.History -> H.History) -> m ()
modifyHistory :: (History -> History) -> m ()
modifyHistory History -> History
f = m History
forall (m :: * -> *). Eff ReadlineHistory m => m History
getHistory m History -> (History -> m ()) -> m ()
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= History -> m ()
forall (m :: * -> *). Eff ReadlineHistory m => History -> m ()
putHistory (History -> m ()) -> (History -> History) -> History -> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. History -> History
f

-- Threading constraints + EfflyIO + HelperInputT

-- | newtype that provides MonadIO when Eff (Embed IO) m and otherwise just
-- passes through instances to the base monad
newtype EfflyIO m a = EfflyIO {EfflyIO m a -> m a
unEfflyIO :: m a}
  deriving newtype
    ( a -> EfflyIO m b -> EfflyIO m a
(a -> b) -> EfflyIO m a -> EfflyIO m b
(forall a b. (a -> b) -> EfflyIO m a -> EfflyIO m b)
-> (forall a b. a -> EfflyIO m b -> EfflyIO m a)
-> Functor (EfflyIO m)
forall a b. a -> EfflyIO m b -> EfflyIO m a
forall a b. (a -> b) -> EfflyIO m a -> EfflyIO m b
forall (m :: * -> *) a b.
Functor m =>
a -> EfflyIO m b -> EfflyIO m a
forall (m :: * -> *) a b.
Functor m =>
(a -> b) -> EfflyIO m a -> EfflyIO m b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> EfflyIO m b -> EfflyIO m a
$c<$ :: forall (m :: * -> *) a b.
Functor m =>
a -> EfflyIO m b -> EfflyIO m a
fmap :: (a -> b) -> EfflyIO m a -> EfflyIO m b
$cfmap :: forall (m :: * -> *) a b.
Functor m =>
(a -> b) -> EfflyIO m a -> EfflyIO m b
Functor,
      Functor (EfflyIO m)
a -> EfflyIO m a
Functor (EfflyIO m)
-> (forall a. a -> EfflyIO m a)
-> (forall a b. EfflyIO m (a -> b) -> EfflyIO m a -> EfflyIO m b)
-> (forall a b c.
    (a -> b -> c) -> EfflyIO m a -> EfflyIO m b -> EfflyIO m c)
-> (forall a b. EfflyIO m a -> EfflyIO m b -> EfflyIO m b)
-> (forall a b. EfflyIO m a -> EfflyIO m b -> EfflyIO m a)
-> Applicative (EfflyIO m)
EfflyIO m a -> EfflyIO m b -> EfflyIO m b
EfflyIO m a -> EfflyIO m b -> EfflyIO m a
EfflyIO m (a -> b) -> EfflyIO m a -> EfflyIO m b
(a -> b -> c) -> EfflyIO m a -> EfflyIO m b -> EfflyIO m c
forall a. a -> EfflyIO m a
forall a b. EfflyIO m a -> EfflyIO m b -> EfflyIO m a
forall a b. EfflyIO m a -> EfflyIO m b -> EfflyIO m b
forall a b. EfflyIO m (a -> b) -> EfflyIO m a -> EfflyIO m b
forall a b c.
(a -> b -> c) -> EfflyIO m a -> EfflyIO m b -> EfflyIO m 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
forall (m :: * -> *). Applicative m => Functor (EfflyIO m)
forall (m :: * -> *) a. Applicative m => a -> EfflyIO m a
forall (m :: * -> *) a b.
Applicative m =>
EfflyIO m a -> EfflyIO m b -> EfflyIO m a
forall (m :: * -> *) a b.
Applicative m =>
EfflyIO m a -> EfflyIO m b -> EfflyIO m b
forall (m :: * -> *) a b.
Applicative m =>
EfflyIO m (a -> b) -> EfflyIO m a -> EfflyIO m b
forall (m :: * -> *) a b c.
Applicative m =>
(a -> b -> c) -> EfflyIO m a -> EfflyIO m b -> EfflyIO m c
<* :: EfflyIO m a -> EfflyIO m b -> EfflyIO m a
$c<* :: forall (m :: * -> *) a b.
Applicative m =>
EfflyIO m a -> EfflyIO m b -> EfflyIO m a
*> :: EfflyIO m a -> EfflyIO m b -> EfflyIO m b
$c*> :: forall (m :: * -> *) a b.
Applicative m =>
EfflyIO m a -> EfflyIO m b -> EfflyIO m b
liftA2 :: (a -> b -> c) -> EfflyIO m a -> EfflyIO m b -> EfflyIO m c
$cliftA2 :: forall (m :: * -> *) a b c.
Applicative m =>
(a -> b -> c) -> EfflyIO m a -> EfflyIO m b -> EfflyIO m c
<*> :: EfflyIO m (a -> b) -> EfflyIO m a -> EfflyIO m b
$c<*> :: forall (m :: * -> *) a b.
Applicative m =>
EfflyIO m (a -> b) -> EfflyIO m a -> EfflyIO m b
pure :: a -> EfflyIO m a
$cpure :: forall (m :: * -> *) a. Applicative m => a -> EfflyIO m a
$cp1Applicative :: forall (m :: * -> *). Applicative m => Functor (EfflyIO m)
Applicative,
      Applicative (EfflyIO m)
a -> EfflyIO m a
Applicative (EfflyIO m)
-> (forall a b. EfflyIO m a -> (a -> EfflyIO m b) -> EfflyIO m b)
-> (forall a b. EfflyIO m a -> EfflyIO m b -> EfflyIO m b)
-> (forall a. a -> EfflyIO m a)
-> Monad (EfflyIO m)
EfflyIO m a -> (a -> EfflyIO m b) -> EfflyIO m b
EfflyIO m a -> EfflyIO m b -> EfflyIO m b
forall a. a -> EfflyIO m a
forall a b. EfflyIO m a -> EfflyIO m b -> EfflyIO m b
forall a b. EfflyIO m a -> (a -> EfflyIO m b) -> EfflyIO m b
forall (m :: * -> *). Monad m => Applicative (EfflyIO m)
forall (m :: * -> *) a. Monad m => a -> EfflyIO m a
forall (m :: * -> *) a b.
Monad m =>
EfflyIO m a -> EfflyIO m b -> EfflyIO m b
forall (m :: * -> *) a b.
Monad m =>
EfflyIO m a -> (a -> EfflyIO m b) -> EfflyIO m 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 -> EfflyIO m a
$creturn :: forall (m :: * -> *) a. Monad m => a -> EfflyIO m a
>> :: EfflyIO m a -> EfflyIO m b -> EfflyIO m b
$c>> :: forall (m :: * -> *) a b.
Monad m =>
EfflyIO m a -> EfflyIO m b -> EfflyIO m b
>>= :: EfflyIO m a -> (a -> EfflyIO m b) -> EfflyIO m b
$c>>= :: forall (m :: * -> *) a b.
Monad m =>
EfflyIO m a -> (a -> EfflyIO m b) -> EfflyIO m b
$cp1Monad :: forall (m :: * -> *). Monad m => Applicative (EfflyIO m)
Monad,
      Monad (EfflyIO m)
Monad (EfflyIO m)
-> (forall a. (a -> EfflyIO m a) -> EfflyIO m a)
-> MonadFix (EfflyIO m)
(a -> EfflyIO m a) -> EfflyIO m a
forall a. (a -> EfflyIO m a) -> EfflyIO m a
forall (m :: * -> *).
Monad m -> (forall a. (a -> m a) -> m a) -> MonadFix m
forall (m :: * -> *). MonadFix m => Monad (EfflyIO m)
forall (m :: * -> *) a.
MonadFix m =>
(a -> EfflyIO m a) -> EfflyIO m a
mfix :: (a -> EfflyIO m a) -> EfflyIO m a
$cmfix :: forall (m :: * -> *) a.
MonadFix m =>
(a -> EfflyIO m a) -> EfflyIO m a
$cp1MonadFix :: forall (m :: * -> *). MonadFix m => Monad (EfflyIO m)
MonadFix,
      Monad (EfflyIO m)
Monad (EfflyIO m)
-> (forall a. String -> EfflyIO m a) -> MonadFail (EfflyIO m)
String -> EfflyIO m a
forall a. String -> EfflyIO m a
forall (m :: * -> *).
Monad m -> (forall a. String -> m a) -> MonadFail m
forall (m :: * -> *). MonadFail m => Monad (EfflyIO m)
forall (m :: * -> *) a. MonadFail m => String -> EfflyIO m a
fail :: String -> EfflyIO m a
$cfail :: forall (m :: * -> *) a. MonadFail m => String -> EfflyIO m a
$cp1MonadFail :: forall (m :: * -> *). MonadFail m => Monad (EfflyIO m)
MonadFail,
      Monad (EfflyIO m)
e -> EfflyIO m a
Monad (EfflyIO m)
-> (forall e a. Exception e => e -> EfflyIO m a)
-> MonadThrow (EfflyIO m)
forall e a. Exception e => e -> EfflyIO m a
forall (m :: * -> *).
Monad m -> (forall e a. Exception e => e -> m a) -> MonadThrow m
forall (m :: * -> *). MonadThrow m => Monad (EfflyIO m)
forall (m :: * -> *) e a.
(MonadThrow m, Exception e) =>
e -> EfflyIO m a
throwM :: e -> EfflyIO m a
$cthrowM :: forall (m :: * -> *) e a.
(MonadThrow m, Exception e) =>
e -> EfflyIO m a
$cp1MonadThrow :: forall (m :: * -> *). MonadThrow m => Monad (EfflyIO m)
MonadThrow,
      MonadThrow (EfflyIO m)
MonadThrow (EfflyIO m)
-> (forall e a.
    Exception e =>
    EfflyIO m a -> (e -> EfflyIO m a) -> EfflyIO m a)
-> MonadCatch (EfflyIO m)
EfflyIO m a -> (e -> EfflyIO m a) -> EfflyIO m a
forall e a.
Exception e =>
EfflyIO m a -> (e -> EfflyIO m a) -> EfflyIO m a
forall (m :: * -> *).
MonadThrow m
-> (forall e a. Exception e => m a -> (e -> m a) -> m a)
-> MonadCatch m
forall (m :: * -> *). MonadCatch m => MonadThrow (EfflyIO m)
forall (m :: * -> *) e a.
(MonadCatch m, Exception e) =>
EfflyIO m a -> (e -> EfflyIO m a) -> EfflyIO m a
catch :: EfflyIO m a -> (e -> EfflyIO m a) -> EfflyIO m a
$ccatch :: forall (m :: * -> *) e a.
(MonadCatch m, Exception e) =>
EfflyIO m a -> (e -> EfflyIO m a) -> EfflyIO m a
$cp1MonadCatch :: forall (m :: * -> *). MonadCatch m => MonadThrow (EfflyIO m)
MonadCatch,
      MonadCatch (EfflyIO m)
MonadCatch (EfflyIO m)
-> (forall b.
    ((forall a. EfflyIO m a -> EfflyIO m a) -> EfflyIO m b)
    -> EfflyIO m b)
-> (forall b.
    ((forall a. EfflyIO m a -> EfflyIO m a) -> EfflyIO m b)
    -> EfflyIO m b)
-> (forall a b c.
    EfflyIO m a
    -> (a -> ExitCase b -> EfflyIO m c)
    -> (a -> EfflyIO m b)
    -> EfflyIO m (b, c))
-> MonadMask (EfflyIO m)
EfflyIO m a
-> (a -> ExitCase b -> EfflyIO m c)
-> (a -> EfflyIO m b)
-> EfflyIO m (b, c)
((forall a. EfflyIO m a -> EfflyIO m a) -> EfflyIO m b)
-> EfflyIO m b
((forall a. EfflyIO m a -> EfflyIO m a) -> EfflyIO m b)
-> EfflyIO m b
forall b.
((forall a. EfflyIO m a -> EfflyIO m a) -> EfflyIO m b)
-> EfflyIO m b
forall a b c.
EfflyIO m a
-> (a -> ExitCase b -> EfflyIO m c)
-> (a -> EfflyIO m b)
-> EfflyIO m (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
forall (m :: * -> *). MonadMask m => MonadCatch (EfflyIO m)
forall (m :: * -> *) b.
MonadMask m =>
((forall a. EfflyIO m a -> EfflyIO m a) -> EfflyIO m b)
-> EfflyIO m b
forall (m :: * -> *) a b c.
MonadMask m =>
EfflyIO m a
-> (a -> ExitCase b -> EfflyIO m c)
-> (a -> EfflyIO m b)
-> EfflyIO m (b, c)
generalBracket :: EfflyIO m a
-> (a -> ExitCase b -> EfflyIO m c)
-> (a -> EfflyIO m b)
-> EfflyIO m (b, c)
$cgeneralBracket :: forall (m :: * -> *) a b c.
MonadMask m =>
EfflyIO m a
-> (a -> ExitCase b -> EfflyIO m c)
-> (a -> EfflyIO m b)
-> EfflyIO m (b, c)
uninterruptibleMask :: ((forall a. EfflyIO m a -> EfflyIO m a) -> EfflyIO m b)
-> EfflyIO m b
$cuninterruptibleMask :: forall (m :: * -> *) b.
MonadMask m =>
((forall a. EfflyIO m a -> EfflyIO m a) -> EfflyIO m b)
-> EfflyIO m b
mask :: ((forall a. EfflyIO m a -> EfflyIO m a) -> EfflyIO m b)
-> EfflyIO m b
$cmask :: forall (m :: * -> *) b.
MonadMask m =>
((forall a. EfflyIO m a -> EfflyIO m a) -> EfflyIO m b)
-> EfflyIO m b
$cp1MonadMask :: forall (m :: * -> *). MonadMask m => MonadCatch (EfflyIO m)
MonadMask,
      MonadBase b,
      MonadBaseControl b
    )
  deriving (m a -> EfflyIO m a
(forall (m :: * -> *) a. Monad m => m a -> EfflyIO m a)
-> MonadTrans EfflyIO
forall (m :: * -> *) a. Monad m => m a -> EfflyIO m a
forall (t :: Effect).
(forall (m :: * -> *) a. Monad m => m a -> t m a) -> MonadTrans t
lift :: m a -> EfflyIO m a
$clift :: forall (m :: * -> *) a. Monad m => m a -> EfflyIO m a
MonadTrans, MonadTrans EfflyIO
m (StT EfflyIO a) -> EfflyIO m a
MonadTrans EfflyIO
-> (forall (m :: * -> *) a.
    Monad m =>
    (Run EfflyIO -> m a) -> EfflyIO m a)
-> (forall (m :: * -> *) a.
    Monad m =>
    m (StT EfflyIO a) -> EfflyIO m a)
-> MonadTransControl EfflyIO
(Run EfflyIO -> m a) -> EfflyIO m a
forall (m :: * -> *) a. Monad m => m (StT EfflyIO a) -> EfflyIO m a
forall (m :: * -> *) a.
Monad m =>
(Run EfflyIO -> m a) -> EfflyIO m a
forall (t :: Effect).
MonadTrans t
-> (forall (m :: * -> *) a. Monad m => (Run t -> m a) -> t m a)
-> (forall (m :: * -> *) a. Monad m => m (StT t a) -> t m a)
-> MonadTransControl t
restoreT :: m (StT EfflyIO a) -> EfflyIO m a
$crestoreT :: forall (m :: * -> *) a. Monad m => m (StT EfflyIO a) -> EfflyIO m a
liftWith :: (Run EfflyIO -> m a) -> EfflyIO m a
$cliftWith :: forall (m :: * -> *) a.
Monad m =>
(Run EfflyIO -> m a) -> EfflyIO m a
$cp1MonadTransControl :: MonadTrans EfflyIO
MonadTransControl) via IdentityT

instance Eff (Embed IO) m => MonadIO (EfflyIO m) where
  liftIO :: IO a -> EfflyIO m a
liftIO = m a -> EfflyIO m a
forall (t :: Effect) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> EfflyIO m a) -> (IO a -> m a) -> IO a -> EfflyIO m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. IO a -> m a
forall (b :: * -> *) (m :: * -> *) a. Eff (Embed b) m => b a -> m a
embed

-- | Version of InputT that we "own" so that we can define new instances on it,
-- in particular threading constraints without creating orphan instances.
newtype ReadlineT m a = ReadlineT {ReadlineT m a -> InputT m a
unReadlineT :: H.InputT m a}
  deriving newtype
    ( a -> ReadlineT m b -> ReadlineT m a
(a -> b) -> ReadlineT m a -> ReadlineT m b
(forall a b. (a -> b) -> ReadlineT m a -> ReadlineT m b)
-> (forall a b. a -> ReadlineT m b -> ReadlineT m a)
-> Functor (ReadlineT m)
forall a b. a -> ReadlineT m b -> ReadlineT m a
forall a b. (a -> b) -> ReadlineT m a -> ReadlineT m b
forall (m :: * -> *) a b.
Functor m =>
a -> ReadlineT m b -> ReadlineT m a
forall (m :: * -> *) a b.
Functor m =>
(a -> b) -> ReadlineT m a -> ReadlineT m b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> ReadlineT m b -> ReadlineT m a
$c<$ :: forall (m :: * -> *) a b.
Functor m =>
a -> ReadlineT m b -> ReadlineT m a
fmap :: (a -> b) -> ReadlineT m a -> ReadlineT m b
$cfmap :: forall (m :: * -> *) a b.
Functor m =>
(a -> b) -> ReadlineT m a -> ReadlineT m b
Functor,
      Functor (ReadlineT m)
a -> ReadlineT m a
Functor (ReadlineT m)
-> (forall a. a -> ReadlineT m a)
-> (forall a b.
    ReadlineT m (a -> b) -> ReadlineT m a -> ReadlineT m b)
-> (forall a b c.
    (a -> b -> c) -> ReadlineT m a -> ReadlineT m b -> ReadlineT m c)
-> (forall a b. ReadlineT m a -> ReadlineT m b -> ReadlineT m b)
-> (forall a b. ReadlineT m a -> ReadlineT m b -> ReadlineT m a)
-> Applicative (ReadlineT m)
ReadlineT m a -> ReadlineT m b -> ReadlineT m b
ReadlineT m a -> ReadlineT m b -> ReadlineT m a
ReadlineT m (a -> b) -> ReadlineT m a -> ReadlineT m b
(a -> b -> c) -> ReadlineT m a -> ReadlineT m b -> ReadlineT m c
forall a. a -> ReadlineT m a
forall a b. ReadlineT m a -> ReadlineT m b -> ReadlineT m a
forall a b. ReadlineT m a -> ReadlineT m b -> ReadlineT m b
forall a b. ReadlineT m (a -> b) -> ReadlineT m a -> ReadlineT m b
forall a b c.
(a -> b -> c) -> ReadlineT m a -> ReadlineT m b -> ReadlineT m 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
forall (m :: * -> *). Applicative m => Functor (ReadlineT m)
forall (m :: * -> *) a. Applicative m => a -> ReadlineT m a
forall (m :: * -> *) a b.
Applicative m =>
ReadlineT m a -> ReadlineT m b -> ReadlineT m a
forall (m :: * -> *) a b.
Applicative m =>
ReadlineT m a -> ReadlineT m b -> ReadlineT m b
forall (m :: * -> *) a b.
Applicative m =>
ReadlineT m (a -> b) -> ReadlineT m a -> ReadlineT m b
forall (m :: * -> *) a b c.
Applicative m =>
(a -> b -> c) -> ReadlineT m a -> ReadlineT m b -> ReadlineT m c
<* :: ReadlineT m a -> ReadlineT m b -> ReadlineT m a
$c<* :: forall (m :: * -> *) a b.
Applicative m =>
ReadlineT m a -> ReadlineT m b -> ReadlineT m a
*> :: ReadlineT m a -> ReadlineT m b -> ReadlineT m b
$c*> :: forall (m :: * -> *) a b.
Applicative m =>
ReadlineT m a -> ReadlineT m b -> ReadlineT m b
liftA2 :: (a -> b -> c) -> ReadlineT m a -> ReadlineT m b -> ReadlineT m c
$cliftA2 :: forall (m :: * -> *) a b c.
Applicative m =>
(a -> b -> c) -> ReadlineT m a -> ReadlineT m b -> ReadlineT m c
<*> :: ReadlineT m (a -> b) -> ReadlineT m a -> ReadlineT m b
$c<*> :: forall (m :: * -> *) a b.
Applicative m =>
ReadlineT m (a -> b) -> ReadlineT m a -> ReadlineT m b
pure :: a -> ReadlineT m a
$cpure :: forall (m :: * -> *) a. Applicative m => a -> ReadlineT m a
$cp1Applicative :: forall (m :: * -> *). Applicative m => Functor (ReadlineT m)
Applicative,
      Applicative (ReadlineT m)
a -> ReadlineT m a
Applicative (ReadlineT m)
-> (forall a b.
    ReadlineT m a -> (a -> ReadlineT m b) -> ReadlineT m b)
-> (forall a b. ReadlineT m a -> ReadlineT m b -> ReadlineT m b)
-> (forall a. a -> ReadlineT m a)
-> Monad (ReadlineT m)
ReadlineT m a -> (a -> ReadlineT m b) -> ReadlineT m b
ReadlineT m a -> ReadlineT m b -> ReadlineT m b
forall a. a -> ReadlineT m a
forall a b. ReadlineT m a -> ReadlineT m b -> ReadlineT m b
forall a b. ReadlineT m a -> (a -> ReadlineT m b) -> ReadlineT m b
forall (m :: * -> *). Monad m => Applicative (ReadlineT m)
forall (m :: * -> *) a. Monad m => a -> ReadlineT m a
forall (m :: * -> *) a b.
Monad m =>
ReadlineT m a -> ReadlineT m b -> ReadlineT m b
forall (m :: * -> *) a b.
Monad m =>
ReadlineT m a -> (a -> ReadlineT m b) -> ReadlineT m 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 -> ReadlineT m a
$creturn :: forall (m :: * -> *) a. Monad m => a -> ReadlineT m a
>> :: ReadlineT m a -> ReadlineT m b -> ReadlineT m b
$c>> :: forall (m :: * -> *) a b.
Monad m =>
ReadlineT m a -> ReadlineT m b -> ReadlineT m b
>>= :: ReadlineT m a -> (a -> ReadlineT m b) -> ReadlineT m b
$c>>= :: forall (m :: * -> *) a b.
Monad m =>
ReadlineT m a -> (a -> ReadlineT m b) -> ReadlineT m b
$cp1Monad :: forall (m :: * -> *). Monad m => Applicative (ReadlineT m)
Monad,
      Monad (ReadlineT m)
Monad (ReadlineT m)
-> (forall a. (a -> ReadlineT m a) -> ReadlineT m a)
-> MonadFix (ReadlineT m)
(a -> ReadlineT m a) -> ReadlineT m a
forall a. (a -> ReadlineT m a) -> ReadlineT m a
forall (m :: * -> *).
Monad m -> (forall a. (a -> m a) -> m a) -> MonadFix m
forall (m :: * -> *). MonadFix m => Monad (ReadlineT m)
forall (m :: * -> *) a.
MonadFix m =>
(a -> ReadlineT m a) -> ReadlineT m a
mfix :: (a -> ReadlineT m a) -> ReadlineT m a
$cmfix :: forall (m :: * -> *) a.
MonadFix m =>
(a -> ReadlineT m a) -> ReadlineT m a
$cp1MonadFix :: forall (m :: * -> *). MonadFix m => Monad (ReadlineT m)
MonadFix,
      Monad (ReadlineT m)
Monad (ReadlineT m)
-> (forall a. String -> ReadlineT m a) -> MonadFail (ReadlineT m)
String -> ReadlineT m a
forall a. String -> ReadlineT m a
forall (m :: * -> *).
Monad m -> (forall a. String -> m a) -> MonadFail m
forall (m :: * -> *). MonadFail m => Monad (ReadlineT m)
forall (m :: * -> *) a. MonadFail m => String -> ReadlineT m a
fail :: String -> ReadlineT m a
$cfail :: forall (m :: * -> *) a. MonadFail m => String -> ReadlineT m a
$cp1MonadFail :: forall (m :: * -> *). MonadFail m => Monad (ReadlineT m)
MonadFail,
      Monad (ReadlineT m)
Monad (ReadlineT m)
-> (forall a. IO a -> ReadlineT m a) -> MonadIO (ReadlineT m)
IO a -> ReadlineT m a
forall a. IO a -> ReadlineT m a
forall (m :: * -> *).
Monad m -> (forall a. IO a -> m a) -> MonadIO m
forall (m :: * -> *). MonadIO m => Monad (ReadlineT m)
forall (m :: * -> *) a. MonadIO m => IO a -> ReadlineT m a
liftIO :: IO a -> ReadlineT m a
$cliftIO :: forall (m :: * -> *) a. MonadIO m => IO a -> ReadlineT m a
$cp1MonadIO :: forall (m :: * -> *). MonadIO m => Monad (ReadlineT m)
MonadIO,
      Monad (ReadlineT m)
e -> ReadlineT m a
Monad (ReadlineT m)
-> (forall e a. Exception e => e -> ReadlineT m a)
-> MonadThrow (ReadlineT m)
forall e a. Exception e => e -> ReadlineT m a
forall (m :: * -> *).
Monad m -> (forall e a. Exception e => e -> m a) -> MonadThrow m
forall (m :: * -> *). MonadThrow m => Monad (ReadlineT m)
forall (m :: * -> *) e a.
(MonadThrow m, Exception e) =>
e -> ReadlineT m a
throwM :: e -> ReadlineT m a
$cthrowM :: forall (m :: * -> *) e a.
(MonadThrow m, Exception e) =>
e -> ReadlineT m a
$cp1MonadThrow :: forall (m :: * -> *). MonadThrow m => Monad (ReadlineT m)
MonadThrow,
      MonadThrow (ReadlineT m)
MonadThrow (ReadlineT m)
-> (forall e a.
    Exception e =>
    ReadlineT m a -> (e -> ReadlineT m a) -> ReadlineT m a)
-> MonadCatch (ReadlineT m)
ReadlineT m a -> (e -> ReadlineT m a) -> ReadlineT m a
forall e a.
Exception e =>
ReadlineT m a -> (e -> ReadlineT m a) -> ReadlineT m a
forall (m :: * -> *).
MonadThrow m
-> (forall e a. Exception e => m a -> (e -> m a) -> m a)
-> MonadCatch m
forall (m :: * -> *). MonadCatch m => MonadThrow (ReadlineT m)
forall (m :: * -> *) e a.
(MonadCatch m, Exception e) =>
ReadlineT m a -> (e -> ReadlineT m a) -> ReadlineT m a
catch :: ReadlineT m a -> (e -> ReadlineT m a) -> ReadlineT m a
$ccatch :: forall (m :: * -> *) e a.
(MonadCatch m, Exception e) =>
ReadlineT m a -> (e -> ReadlineT m a) -> ReadlineT m a
$cp1MonadCatch :: forall (m :: * -> *). MonadCatch m => MonadThrow (ReadlineT m)
MonadCatch,
      MonadCatch (ReadlineT m)
MonadCatch (ReadlineT m)
-> (forall b.
    ((forall a. ReadlineT m a -> ReadlineT m a) -> ReadlineT m b)
    -> ReadlineT m b)
-> (forall b.
    ((forall a. ReadlineT m a -> ReadlineT m a) -> ReadlineT m b)
    -> ReadlineT m b)
-> (forall a b c.
    ReadlineT m a
    -> (a -> ExitCase b -> ReadlineT m c)
    -> (a -> ReadlineT m b)
    -> ReadlineT m (b, c))
-> MonadMask (ReadlineT m)
ReadlineT m a
-> (a -> ExitCase b -> ReadlineT m c)
-> (a -> ReadlineT m b)
-> ReadlineT m (b, c)
((forall a. ReadlineT m a -> ReadlineT m a) -> ReadlineT m b)
-> ReadlineT m b
((forall a. ReadlineT m a -> ReadlineT m a) -> ReadlineT m b)
-> ReadlineT m b
forall b.
((forall a. ReadlineT m a -> ReadlineT m a) -> ReadlineT m b)
-> ReadlineT m b
forall a b c.
ReadlineT m a
-> (a -> ExitCase b -> ReadlineT m c)
-> (a -> ReadlineT m b)
-> ReadlineT m (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
forall (m :: * -> *). MonadMask m => MonadCatch (ReadlineT m)
forall (m :: * -> *) b.
MonadMask m =>
((forall a. ReadlineT m a -> ReadlineT m a) -> ReadlineT m b)
-> ReadlineT m b
forall (m :: * -> *) a b c.
MonadMask m =>
ReadlineT m a
-> (a -> ExitCase b -> ReadlineT m c)
-> (a -> ReadlineT m b)
-> ReadlineT m (b, c)
generalBracket :: ReadlineT m a
-> (a -> ExitCase b -> ReadlineT m c)
-> (a -> ReadlineT m b)
-> ReadlineT m (b, c)
$cgeneralBracket :: forall (m :: * -> *) a b c.
MonadMask m =>
ReadlineT m a
-> (a -> ExitCase b -> ReadlineT m c)
-> (a -> ReadlineT m b)
-> ReadlineT m (b, c)
uninterruptibleMask :: ((forall a. ReadlineT m a -> ReadlineT m a) -> ReadlineT m b)
-> ReadlineT m b
$cuninterruptibleMask :: forall (m :: * -> *) b.
MonadMask m =>
((forall a. ReadlineT m a -> ReadlineT m a) -> ReadlineT m b)
-> ReadlineT m b
mask :: ((forall a. ReadlineT m a -> ReadlineT m a) -> ReadlineT m b)
-> ReadlineT m b
$cmask :: forall (m :: * -> *) b.
MonadMask m =>
((forall a. ReadlineT m a -> ReadlineT m a) -> ReadlineT m b)
-> ReadlineT m b
$cp1MonadMask :: forall (m :: * -> *). MonadMask m => MonadCatch (ReadlineT m)
MonadMask,
      m a -> ReadlineT m a
(forall (m :: * -> *) a. Monad m => m a -> ReadlineT m a)
-> MonadTrans ReadlineT
forall (m :: * -> *) a. Monad m => m a -> ReadlineT m a
forall (t :: Effect).
(forall (m :: * -> *) a. Monad m => m a -> t m a) -> MonadTrans t
lift :: m a -> ReadlineT m a
$clift :: forall (m :: * -> *) a. Monad m => m a -> ReadlineT m a
MonadTrans
    )

instance MonadBase b m => MonadBase b (ReadlineT m) where
  liftBase :: b α -> ReadlineT m α
liftBase b α
b = m α -> ReadlineT m α
forall (t :: Effect) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m α -> ReadlineT m α) -> m α -> ReadlineT m α
forall a b. (a -> b) -> a -> b
$ b α -> m α
forall (b :: * -> *) (m :: * -> *) α. MonadBase b m => b α -> m α
liftBase b α
b

instance MonadBaseControl b m => MonadBaseControl b (ReadlineT m) where
  type StM (ReadlineT m) a = StM m a
  liftBaseWith :: (RunInBase (ReadlineT m) b -> b a) -> ReadlineT m a
liftBaseWith RunInBase (ReadlineT m) b -> b a
f =
    InputT m a -> ReadlineT m a
forall (m :: * -> *) a. InputT m a -> ReadlineT m a
ReadlineT (InputT m a -> ReadlineT m a) -> InputT m a -> ReadlineT m a
forall a b. (a -> b) -> a -> b
$
      ((forall a. InputT m a -> m a) -> m a) -> InputT m a
forall (m :: * -> *) b.
Monad m =>
((forall a. InputT m a -> m a) -> m b) -> InputT m b
H.withRunInBase (((forall a. InputT m a -> m a) -> m a) -> InputT m a)
-> ((forall a. InputT m a -> m a) -> m a) -> InputT m a
forall a b. (a -> b) -> a -> b
$ \forall a. InputT m a -> m a
runInputTInBase ->
        (RunInBase m b -> b a) -> m a
forall (b :: * -> *) (m :: * -> *) a.
MonadBaseControl b m =>
(RunInBase m b -> b a) -> m a
liftBaseWith ((RunInBase m b -> b a) -> m a) -> (RunInBase m b -> b a) -> m a
forall a b. (a -> b) -> a -> b
$ \RunInBase m b
runMInBase ->
          RunInBase (ReadlineT m) b -> b a
f (m a -> b (StM m a)
RunInBase m b
runMInBase (m a -> b (StM m a))
-> (ReadlineT m a -> m a) -> ReadlineT m a -> b (StM m a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. InputT m a -> m a
forall a. InputT m a -> m a
runInputTInBase (InputT m a -> m a)
-> (ReadlineT m a -> InputT m a) -> ReadlineT m a -> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ReadlineT m a -> InputT m a
forall (m :: * -> *) a. ReadlineT m a -> InputT m a
unReadlineT)
  restoreM :: StM (ReadlineT m) a -> ReadlineT m a
restoreM = m a -> ReadlineT m a
forall (t :: Effect) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> ReadlineT m a)
-> (StM m a -> m a) -> StM m a -> ReadlineT m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StM m a -> m a
forall (b :: * -> *) (m :: * -> *) a.
MonadBaseControl b m =>
StM m a -> m a
restoreM

instance ThreadsEff ReadlineT (Unravel p) where
  threadEff :: (forall x. Unravel p m x -> m x)
-> Unravel p (ReadlineT m) a -> ReadlineT m a
threadEff forall x. Unravel p m x -> m x
alg (Unravel p a
p ReadlineT m a -> a
cataM ReadlineT m a
main) =
    InputT m a -> ReadlineT m a
forall (m :: * -> *) a. InputT m a -> ReadlineT m a
ReadlineT (InputT m a -> ReadlineT m a) -> InputT m a -> ReadlineT m a
forall a b. (a -> b) -> a -> b
$
      ((forall a. InputT m a -> m a) -> m a) -> InputT m a
forall (m :: * -> *) b.
Monad m =>
((forall a. InputT m a -> m a) -> m b) -> InputT m b
H.withRunInBase (((forall a. InputT m a -> m a) -> m a) -> InputT m a)
-> ((forall a. InputT m a -> m a) -> m a) -> InputT m a
forall a b. (a -> b) -> a -> b
$ \forall a. InputT m a -> m a
runInBase ->
        Unravel p m a -> m a
forall x. Unravel p m x -> m x
alg (Unravel p m a -> m a) -> Unravel p m a -> m a
forall a b. (a -> b) -> a -> b
$ p a -> (m a -> a) -> m a -> Unravel p m a
forall (p :: * -> *) b (a :: * -> *).
p b -> (a b -> b) -> a b -> Unravel p a b
Unravel p a
p (ReadlineT m a -> a
cataM (ReadlineT m a -> a) -> (m a -> ReadlineT m a) -> m a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m a -> ReadlineT m a
forall (t :: Effect) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift) (InputT m a -> m a
forall a. InputT m a -> m a
runInBase (InputT m a -> m a)
-> (ReadlineT m a -> InputT m a) -> ReadlineT m a -> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ReadlineT m a -> InputT m a
forall (m :: * -> *) a. ReadlineT m a -> InputT m a
unReadlineT (ReadlineT m a -> m a) -> ReadlineT m a -> m a
forall a b. (a -> b) -> a -> b
$ ReadlineT m a
main)

instance ThreadsEff ReadlineT (Regional s) where
  threadEff :: (forall x. Regional s m x -> m x)
-> Regional s (ReadlineT m) a -> ReadlineT m a
threadEff = (forall x. Regional s m x -> m x)
-> Regional s (ReadlineT m) a -> ReadlineT m a
forall (t :: Effect) s (m :: * -> *) a.
(ThreadsEff t (Optional (Const s)), Monad m) =>
(forall x. Regional s m x -> m x) -> Regional s (t m) a -> t m a
threadRegionalViaOptional

instance ThreadsEff ReadlineT Mask where
  threadEff :: (forall x. Mask m x -> m x)
-> Mask (ReadlineT m) a -> ReadlineT m a
threadEff = (forall x. Mask m x -> m x)
-> Mask (ReadlineT m) a -> ReadlineT m a
forall (t :: Effect) (m :: * -> *) a.
(Monad m, RepresentationalT t,
 forall (b :: * -> *). MonadMask b => MonadMask (t b)) =>
(forall x. Mask m x -> m x) -> Mask (t m) a -> t m a
threadMaskViaClass

instance Functor s => ThreadsEff ReadlineT (Optional s) where
  threadEff :: (forall x. Optional s m x -> m x)
-> Optional s (ReadlineT m) a -> ReadlineT m a
threadEff = (forall x. Optional s m x -> m x)
-> Optional s (ReadlineT m) a -> ReadlineT m a
forall (s :: * -> *) (t :: Effect) (m :: * -> *) a.
(Functor s, Monad m, Monad (t m), ThreadsEff t (BaseControl m)) =>
(forall x. Optional s m x -> m x) -> Optional s (t m) a -> t m a
threadOptionalViaBaseControl

instance ThreadsEff ReadlineT (ReaderPrim i) where
  threadEff :: (forall x. ReaderPrim i m x -> m x)
-> ReaderPrim i (ReadlineT m) a -> ReadlineT m a
threadEff = (forall x. ReaderPrim i m x -> m x)
-> ReaderPrim i (ReadlineT m) a -> ReadlineT m a
forall i (t :: Effect) (m :: * -> *) a.
(Monad m, MonadTrans t, ThreadsEff t (Regional ())) =>
(forall x. ReaderPrim i m x -> m x)
-> ReaderPrim i (t m) a -> t m a
threadReaderPrimViaRegional

instance Monoid o => ThreadsEff ReadlineT (WriterPrim o) where
  threadEff :: (forall x. WriterPrim o m x -> m x)
-> WriterPrim o (ReadlineT m) a -> ReadlineT m a
threadEff = ((forall x. WriterPrim o m x -> m x)
 -> ReadlineT m (o -> o, a) -> ReadlineT m a)
-> (forall x. WriterPrim o m x -> m x)
-> WriterPrim o (ReadlineT m) a
-> ReadlineT m a
forall o (t :: Effect) (m :: * -> *) a.
(MonadTrans t, ThreadsEff t (ListenPrim o), Monad m) =>
((forall x. WriterPrim o m x -> m x) -> t m (o -> o, a) -> t m a)
-> (forall x. WriterPrim o m x -> m x)
-> WriterPrim o (t m) a
-> t m a
threadWriterPrim (((forall x. WriterPrim o m x -> m x)
  -> ReadlineT m (o -> o, a) -> ReadlineT m a)
 -> (forall x. WriterPrim o m x -> m x)
 -> WriterPrim o (ReadlineT m) a
 -> ReadlineT m a)
-> ((forall x. WriterPrim o m x -> m x)
    -> ReadlineT m (o -> o, a) -> ReadlineT m a)
-> (forall x. WriterPrim o m x -> m x)
-> WriterPrim o (ReadlineT m) a
-> ReadlineT m a
forall a b. (a -> b) -> a -> b
$ \forall x. WriterPrim o m x -> m x
alg ReadlineT m (o -> o, a)
m -> InputT m a -> ReadlineT m a
forall (m :: * -> *) a. InputT m a -> ReadlineT m a
ReadlineT (InputT m a -> ReadlineT m a) -> InputT m a -> ReadlineT m a
forall a b. (a -> b) -> a -> b
$
    ((forall a. InputT m a -> m a) -> m a) -> InputT m a
forall (m :: * -> *) b.
Monad m =>
((forall a. InputT m a -> m a) -> m b) -> InputT m b
H.withRunInBase (((forall a. InputT m a -> m a) -> m a) -> InputT m a)
-> ((forall a. InputT m a -> m a) -> m a) -> InputT m a
forall a b. (a -> b) -> a -> b
$ \forall a. InputT m a -> m a
runInBase ->
      WriterPrim o m a -> m a
forall x. WriterPrim o m x -> m x
alg (WriterPrim o m a -> m a) -> WriterPrim o m a -> m a
forall a b. (a -> b) -> a -> b
$ m (o -> o, a) -> WriterPrim o m a
forall (a :: * -> *) o b. a (o -> o, b) -> WriterPrim o a b
WriterPrimPass (m (o -> o, a) -> WriterPrim o m a)
-> m (o -> o, a) -> WriterPrim o m a
forall a b. (a -> b) -> a -> b
$ InputT m (o -> o, a) -> m (o -> o, a)
forall a. InputT m a -> m a
runInBase (InputT m (o -> o, a) -> m (o -> o, a))
-> (ReadlineT m (o -> o, a) -> InputT m (o -> o, a))
-> ReadlineT m (o -> o, a)
-> m (o -> o, a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ReadlineT m (o -> o, a) -> InputT m (o -> o, a)
forall (m :: * -> *) a. ReadlineT m a -> InputT m a
unReadlineT (ReadlineT m (o -> o, a) -> m (o -> o, a))
-> ReadlineT m (o -> o, a) -> m (o -> o, a)
forall a b. (a -> b) -> a -> b
$ ReadlineT m (o -> o, a)
m

instance ThreadsEff ReadlineT Bracket where
  threadEff :: (forall x. Bracket m x -> m x)
-> Bracket (ReadlineT m) a -> ReadlineT m a
threadEff = (forall x. Bracket m x -> m x)
-> Bracket (ReadlineT m) a -> ReadlineT m a
forall (t :: Effect) (m :: * -> *) a.
(Monad m, RepresentationalT t,
 forall (b :: * -> *). MonadMask b => MonadMask (t b)) =>
(forall x. Bracket m x -> m x) -> Bracket (t m) a -> t m a
threadBracketViaClass

instance ThreadsEff ReadlineT (Unlift b) where
  threadEff :: (forall x. Unlift b m x -> m x)
-> Unlift b (ReadlineT m) a -> ReadlineT m a
threadEff forall x. Unlift b m x -> m x
alg (Unlift (forall x. ReadlineT m x -> b x) -> b a
main) =
    InputT m a -> ReadlineT m a
forall (m :: * -> *) a. InputT m a -> ReadlineT m a
ReadlineT (InputT m a -> ReadlineT m a) -> InputT m a -> ReadlineT m a
forall a b. (a -> b) -> a -> b
$
      ((forall a. InputT m a -> m a) -> m a) -> InputT m a
forall (m :: * -> *) b.
Monad m =>
((forall a. InputT m a -> m a) -> m b) -> InputT m b
H.withRunInBase (((forall a. InputT m a -> m a) -> m a) -> InputT m a)
-> ((forall a. InputT m a -> m a) -> m a) -> InputT m a
forall a b. (a -> b) -> a -> b
$ \forall a. InputT m a -> m a
runInBase ->
        Unlift b m a -> m a
forall x. Unlift b m x -> m x
alg (Unlift b m a -> m a) -> Unlift b m a -> m a
forall a b. (a -> b) -> a -> b
$ ((forall x. m x -> b x) -> b a) -> Unlift b m a
forall (b :: * -> *) (a :: * -> *) c.
((forall x. a x -> b x) -> b c) -> Unlift b a c
Unlift (((forall x. m x -> b x) -> b a) -> Unlift b m a)
-> ((forall x. m x -> b x) -> b a) -> Unlift b m a
forall a b. (a -> b) -> a -> b
$ \forall x. m x -> b x
lower -> (forall x. ReadlineT m x -> b x) -> b a
main (m x -> b x
forall x. m x -> b x
lower (m x -> b x) -> (ReadlineT m x -> m x) -> ReadlineT m x -> b x
forall b c a. (b -> c) -> (a -> b) -> a -> c
. InputT m x -> m x
forall a. InputT m a -> m a
runInBase (InputT m x -> m x)
-> (ReadlineT m x -> InputT m x) -> ReadlineT m x -> m x
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ReadlineT m x -> InputT m x
forall (m :: * -> *) a. ReadlineT m a -> InputT m a
unReadlineT)

instance ThreadsEff ReadlineT Split where
  threadEff :: (forall x. Split m x -> m x)
-> Split (ReadlineT m) a -> ReadlineT m a
threadEff forall x. Split m x -> m x
alg (Split Maybe (a1, ReadlineT m a1) -> a
c ReadlineT m a1
m) =
    InputT m a -> ReadlineT m a
forall (m :: * -> *) a. InputT m a -> ReadlineT m a
ReadlineT (InputT m a -> ReadlineT m a) -> InputT m a -> ReadlineT m a
forall a b. (a -> b) -> a -> b
$
      ((forall a. InputT m a -> m a) -> m a) -> InputT m a
forall (m :: * -> *) b.
Monad m =>
((forall a. InputT m a -> m a) -> m b) -> InputT m b
H.withRunInBase (((forall a. InputT m a -> m a) -> m a) -> InputT m a)
-> ((forall a. InputT m a -> m a) -> m a) -> InputT m a
forall a b. (a -> b) -> a -> b
$ \forall a. InputT m a -> m a
runInBase ->
        Split m a -> m a
forall x. Split m x -> m x
alg (Split m a -> m a) -> Split m a -> m a
forall a b. (a -> b) -> a -> b
$ (Maybe (a1, m a1) -> a) -> m a1 -> Split m a
forall a1 (a :: * -> *) b.
(Maybe (a1, a a1) -> b) -> a a1 -> Split a b
Split (Maybe (a1, ReadlineT m a1) -> a
c (Maybe (a1, ReadlineT m a1) -> a)
-> (Maybe (a1, m a1) -> Maybe (a1, ReadlineT m a1))
-> Maybe (a1, m a1)
-> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (((a1, m a1) -> (a1, ReadlineT m a1))
-> Maybe (a1, m a1) -> Maybe (a1, ReadlineT m a1)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (((a1, m a1) -> (a1, ReadlineT m a1))
 -> Maybe (a1, m a1) -> Maybe (a1, ReadlineT m a1))
-> ((m a1 -> ReadlineT m a1) -> (a1, m a1) -> (a1, ReadlineT m a1))
-> (m a1 -> ReadlineT m a1)
-> Maybe (a1, m a1)
-> Maybe (a1, ReadlineT m a1)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (m a1 -> ReadlineT m a1) -> (a1, m a1) -> (a1, ReadlineT m a1)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap) m a1 -> ReadlineT m a1
forall (t :: Effect) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift) (InputT m a1 -> m a1
forall a. InputT m a -> m a
runInBase (InputT m a1 -> m a1)
-> (ReadlineT m a1 -> InputT m a1) -> ReadlineT m a1 -> m a1
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ReadlineT m a1 -> InputT m a1
forall (m :: * -> *) a. ReadlineT m a -> InputT m a
unReadlineT (ReadlineT m a1 -> m a1) -> ReadlineT m a1 -> m a1
forall a b. (a -> b) -> a -> b
$ ReadlineT m a1
m)

instance Monoid o => ThreadsEff ReadlineT (ListenPrim o) where
  threadEff :: (forall x. ListenPrim o m x -> m x)
-> ListenPrim o (ReadlineT m) a -> ReadlineT m a
threadEff = (forall x.
 (forall x. ListenPrim o m x -> m x)
 -> ReadlineT m x -> ReadlineT m (o, x))
-> (forall x. ListenPrim o m x -> m x)
-> ListenPrim o (ReadlineT m) a
-> ReadlineT m a
forall o (t :: Effect) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
(forall x.
 (forall y. ListenPrim o m y -> m y) -> t m x -> t m (o, x))
-> (forall y. ListenPrim o m y -> m y)
-> ListenPrim o (t m) a
-> t m a
threadListenPrim ((forall x.
  (forall x. ListenPrim o m x -> m x)
  -> ReadlineT m x -> ReadlineT m (o, x))
 -> (forall x. ListenPrim o m x -> m x)
 -> ListenPrim o (ReadlineT m) a
 -> ReadlineT m a)
-> (forall x.
    (forall x. ListenPrim o m x -> m x)
    -> ReadlineT m x -> ReadlineT m (o, x))
-> (forall x. ListenPrim o m x -> m x)
-> ListenPrim o (ReadlineT m) a
-> ReadlineT m a
forall a b. (a -> b) -> a -> b
$ \forall x. ListenPrim o m x -> m x
alg ReadlineT m x
m -> InputT m (o, x) -> ReadlineT m (o, x)
forall (m :: * -> *) a. InputT m a -> ReadlineT m a
ReadlineT (InputT m (o, x) -> ReadlineT m (o, x))
-> InputT m (o, x) -> ReadlineT m (o, x)
forall a b. (a -> b) -> a -> b
$
    ((forall a. InputT m a -> m a) -> m (o, x)) -> InputT m (o, x)
forall (m :: * -> *) b.
Monad m =>
((forall a. InputT m a -> m a) -> m b) -> InputT m b
H.withRunInBase (((forall a. InputT m a -> m a) -> m (o, x)) -> InputT m (o, x))
-> ((forall a. InputT m a -> m a) -> m (o, x)) -> InputT m (o, x)
forall a b. (a -> b) -> a -> b
$ \forall a. InputT m a -> m a
runInBase ->
      ListenPrim o m (o, x) -> m (o, x)
forall x. ListenPrim o m x -> m x
alg (ListenPrim o m (o, x) -> m (o, x))
-> ListenPrim o m (o, x) -> m (o, x)
forall a b. (a -> b) -> a -> b
$ m x -> ListenPrim o m (o, x)
forall (a :: * -> *) a1 o. a a1 -> ListenPrim o a (o, a1)
ListenPrimListen (m x -> ListenPrim o m (o, x)) -> m x -> ListenPrim o m (o, x)
forall a b. (a -> b) -> a -> b
$ InputT m x -> m x
forall a. InputT m a -> m a
runInBase (InputT m x -> m x)
-> (ReadlineT m x -> InputT m x) -> ReadlineT m x -> m x
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ReadlineT m x -> InputT m x
forall (m :: * -> *) a. ReadlineT m a -> InputT m a
unReadlineT (ReadlineT m x -> m x) -> ReadlineT m x -> m x
forall a b. (a -> b) -> a -> b
$ ReadlineT m x
m

instance ThreadsEff ReadlineT (BaseControl b) where
  threadEff :: (forall x. BaseControl b m x -> m x)
-> BaseControl b (ReadlineT m) a -> ReadlineT m a
threadEff = (forall x. BaseControl b m x -> m x)
-> BaseControl b (ReadlineT m) a -> ReadlineT m a
forall (b :: * -> *) (t :: Effect) (m :: * -> *) a.
(MonadTrans t, Monad m,
 forall (z :: * -> *).
 MonadBaseControl b z =>
 MonadBaseControl b (t z),
 forall (z :: * -> *). Coercible z m => Coercible (t z) (t m)) =>
(forall x. BaseControl b m x -> m x)
-> BaseControl b (t m) a -> t m a
threadBaseControlViaClass

instance ThreadsEff ReadlineT Fix where
  threadEff :: (forall x. Fix m x -> m x) -> Fix (ReadlineT m) a -> ReadlineT m a
threadEff = (forall x. Fix m x -> m x) -> Fix (ReadlineT m) a -> ReadlineT m a
forall (m :: * -> *) (t :: Effect) a.
(Monad m, RepresentationalT t,
 forall (b :: * -> *). MonadFix b => MonadFix (t b)) =>
(forall x. Fix m x -> m x) -> Fix (t m) a -> t m a
threadFixViaClass

-- | Threading constraint for handlers using 'H.InputT'/'ReadlineT' internally.
--
-- 'ReadlineThreads' accepts all the primitive effects
-- (intended to be used as such) offered by in-other-words.
--
-- Most notably, 'ReadlineThreads' accepts @'Control.Effect.Unlift.Unlift' b@.
class Threads ReadlineT p => ReadlineThreads p

instance Threads ReadlineT p => ReadlineThreads p

-- -- | A pseudo-effect providing the full haskeline functionality in a single
-- -- effect.
--
-- -- @'Haskeline'@ should only ever be used inside of 'Eff' and 'Effs'
-- -- constraints. It is not a real effect! See 'Control.Effect.Bundle'.
-- type Haskeline = Bundle [Readline, ReadlineHistory, HandleInterrupt]

newtype ReadlineC m a = ReadlineC {ReadlineC m a -> ReadlineT (EfflyIO m) a
unReadlineC :: ReadlineT (EfflyIO m) a}
  deriving newtype
    ( a -> ReadlineC m b -> ReadlineC m a
(a -> b) -> ReadlineC m a -> ReadlineC m b
(forall a b. (a -> b) -> ReadlineC m a -> ReadlineC m b)
-> (forall a b. a -> ReadlineC m b -> ReadlineC m a)
-> Functor (ReadlineC m)
forall a b. a -> ReadlineC m b -> ReadlineC m a
forall a b. (a -> b) -> ReadlineC m a -> ReadlineC m b
forall (m :: * -> *) a b.
Functor m =>
a -> ReadlineC m b -> ReadlineC m a
forall (m :: * -> *) a b.
Functor m =>
(a -> b) -> ReadlineC m a -> ReadlineC m b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> ReadlineC m b -> ReadlineC m a
$c<$ :: forall (m :: * -> *) a b.
Functor m =>
a -> ReadlineC m b -> ReadlineC m a
fmap :: (a -> b) -> ReadlineC m a -> ReadlineC m b
$cfmap :: forall (m :: * -> *) a b.
Functor m =>
(a -> b) -> ReadlineC m a -> ReadlineC m b
Functor,
      Functor (ReadlineC m)
a -> ReadlineC m a
Functor (ReadlineC m)
-> (forall a. a -> ReadlineC m a)
-> (forall a b.
    ReadlineC m (a -> b) -> ReadlineC m a -> ReadlineC m b)
-> (forall a b c.
    (a -> b -> c) -> ReadlineC m a -> ReadlineC m b -> ReadlineC m c)
-> (forall a b. ReadlineC m a -> ReadlineC m b -> ReadlineC m b)
-> (forall a b. ReadlineC m a -> ReadlineC m b -> ReadlineC m a)
-> Applicative (ReadlineC m)
ReadlineC m a -> ReadlineC m b -> ReadlineC m b
ReadlineC m a -> ReadlineC m b -> ReadlineC m a
ReadlineC m (a -> b) -> ReadlineC m a -> ReadlineC m b
(a -> b -> c) -> ReadlineC m a -> ReadlineC m b -> ReadlineC m c
forall a. a -> ReadlineC m a
forall a b. ReadlineC m a -> ReadlineC m b -> ReadlineC m a
forall a b. ReadlineC m a -> ReadlineC m b -> ReadlineC m b
forall a b. ReadlineC m (a -> b) -> ReadlineC m a -> ReadlineC m b
forall a b c.
(a -> b -> c) -> ReadlineC m a -> ReadlineC m b -> ReadlineC m 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
forall (m :: * -> *). Applicative m => Functor (ReadlineC m)
forall (m :: * -> *) a. Applicative m => a -> ReadlineC m a
forall (m :: * -> *) a b.
Applicative m =>
ReadlineC m a -> ReadlineC m b -> ReadlineC m a
forall (m :: * -> *) a b.
Applicative m =>
ReadlineC m a -> ReadlineC m b -> ReadlineC m b
forall (m :: * -> *) a b.
Applicative m =>
ReadlineC m (a -> b) -> ReadlineC m a -> ReadlineC m b
forall (m :: * -> *) a b c.
Applicative m =>
(a -> b -> c) -> ReadlineC m a -> ReadlineC m b -> ReadlineC m c
<* :: ReadlineC m a -> ReadlineC m b -> ReadlineC m a
$c<* :: forall (m :: * -> *) a b.
Applicative m =>
ReadlineC m a -> ReadlineC m b -> ReadlineC m a
*> :: ReadlineC m a -> ReadlineC m b -> ReadlineC m b
$c*> :: forall (m :: * -> *) a b.
Applicative m =>
ReadlineC m a -> ReadlineC m b -> ReadlineC m b
liftA2 :: (a -> b -> c) -> ReadlineC m a -> ReadlineC m b -> ReadlineC m c
$cliftA2 :: forall (m :: * -> *) a b c.
Applicative m =>
(a -> b -> c) -> ReadlineC m a -> ReadlineC m b -> ReadlineC m c
<*> :: ReadlineC m (a -> b) -> ReadlineC m a -> ReadlineC m b
$c<*> :: forall (m :: * -> *) a b.
Applicative m =>
ReadlineC m (a -> b) -> ReadlineC m a -> ReadlineC m b
pure :: a -> ReadlineC m a
$cpure :: forall (m :: * -> *) a. Applicative m => a -> ReadlineC m a
$cp1Applicative :: forall (m :: * -> *). Applicative m => Functor (ReadlineC m)
Applicative,
      Applicative (ReadlineC m)
a -> ReadlineC m a
Applicative (ReadlineC m)
-> (forall a b.
    ReadlineC m a -> (a -> ReadlineC m b) -> ReadlineC m b)
-> (forall a b. ReadlineC m a -> ReadlineC m b -> ReadlineC m b)
-> (forall a. a -> ReadlineC m a)
-> Monad (ReadlineC m)
ReadlineC m a -> (a -> ReadlineC m b) -> ReadlineC m b
ReadlineC m a -> ReadlineC m b -> ReadlineC m b
forall a. a -> ReadlineC m a
forall a b. ReadlineC m a -> ReadlineC m b -> ReadlineC m b
forall a b. ReadlineC m a -> (a -> ReadlineC m b) -> ReadlineC m b
forall (m :: * -> *). Monad m => Applicative (ReadlineC m)
forall (m :: * -> *) a. Monad m => a -> ReadlineC m a
forall (m :: * -> *) a b.
Monad m =>
ReadlineC m a -> ReadlineC m b -> ReadlineC m b
forall (m :: * -> *) a b.
Monad m =>
ReadlineC m a -> (a -> ReadlineC m b) -> ReadlineC m 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 -> ReadlineC m a
$creturn :: forall (m :: * -> *) a. Monad m => a -> ReadlineC m a
>> :: ReadlineC m a -> ReadlineC m b -> ReadlineC m b
$c>> :: forall (m :: * -> *) a b.
Monad m =>
ReadlineC m a -> ReadlineC m b -> ReadlineC m b
>>= :: ReadlineC m a -> (a -> ReadlineC m b) -> ReadlineC m b
$c>>= :: forall (m :: * -> *) a b.
Monad m =>
ReadlineC m a -> (a -> ReadlineC m b) -> ReadlineC m b
$cp1Monad :: forall (m :: * -> *). Monad m => Applicative (ReadlineC m)
Monad,
      Monad (ReadlineC m)
Monad (ReadlineC m)
-> (forall a. (a -> ReadlineC m a) -> ReadlineC m a)
-> MonadFix (ReadlineC m)
(a -> ReadlineC m a) -> ReadlineC m a
forall a. (a -> ReadlineC m a) -> ReadlineC m a
forall (m :: * -> *).
Monad m -> (forall a. (a -> m a) -> m a) -> MonadFix m
forall (m :: * -> *). MonadFix m => Monad (ReadlineC m)
forall (m :: * -> *) a.
MonadFix m =>
(a -> ReadlineC m a) -> ReadlineC m a
mfix :: (a -> ReadlineC m a) -> ReadlineC m a
$cmfix :: forall (m :: * -> *) a.
MonadFix m =>
(a -> ReadlineC m a) -> ReadlineC m a
$cp1MonadFix :: forall (m :: * -> *). MonadFix m => Monad (ReadlineC m)
MonadFix,
      Monad (ReadlineC m)
Monad (ReadlineC m)
-> (forall a. String -> ReadlineC m a) -> MonadFail (ReadlineC m)
String -> ReadlineC m a
forall a. String -> ReadlineC m a
forall (m :: * -> *).
Monad m -> (forall a. String -> m a) -> MonadFail m
forall (m :: * -> *). MonadFail m => Monad (ReadlineC m)
forall (m :: * -> *) a. MonadFail m => String -> ReadlineC m a
fail :: String -> ReadlineC m a
$cfail :: forall (m :: * -> *) a. MonadFail m => String -> ReadlineC m a
$cp1MonadFail :: forall (m :: * -> *). MonadFail m => Monad (ReadlineC m)
MonadFail,
      Monad (ReadlineC m)
e -> ReadlineC m a
Monad (ReadlineC m)
-> (forall e a. Exception e => e -> ReadlineC m a)
-> MonadThrow (ReadlineC m)
forall e a. Exception e => e -> ReadlineC m a
forall (m :: * -> *).
Monad m -> (forall e a. Exception e => e -> m a) -> MonadThrow m
forall (m :: * -> *). MonadThrow m => Monad (ReadlineC m)
forall (m :: * -> *) e a.
(MonadThrow m, Exception e) =>
e -> ReadlineC m a
throwM :: e -> ReadlineC m a
$cthrowM :: forall (m :: * -> *) e a.
(MonadThrow m, Exception e) =>
e -> ReadlineC m a
$cp1MonadThrow :: forall (m :: * -> *). MonadThrow m => Monad (ReadlineC m)
MonadThrow,
      MonadThrow (ReadlineC m)
MonadThrow (ReadlineC m)
-> (forall e a.
    Exception e =>
    ReadlineC m a -> (e -> ReadlineC m a) -> ReadlineC m a)
-> MonadCatch (ReadlineC m)
ReadlineC m a -> (e -> ReadlineC m a) -> ReadlineC m a
forall e a.
Exception e =>
ReadlineC m a -> (e -> ReadlineC m a) -> ReadlineC m a
forall (m :: * -> *).
MonadThrow m
-> (forall e a. Exception e => m a -> (e -> m a) -> m a)
-> MonadCatch m
forall (m :: * -> *). MonadCatch m => MonadThrow (ReadlineC m)
forall (m :: * -> *) e a.
(MonadCatch m, Exception e) =>
ReadlineC m a -> (e -> ReadlineC m a) -> ReadlineC m a
catch :: ReadlineC m a -> (e -> ReadlineC m a) -> ReadlineC m a
$ccatch :: forall (m :: * -> *) e a.
(MonadCatch m, Exception e) =>
ReadlineC m a -> (e -> ReadlineC m a) -> ReadlineC m a
$cp1MonadCatch :: forall (m :: * -> *). MonadCatch m => MonadThrow (ReadlineC m)
MonadCatch,
      MonadCatch (ReadlineC m)
MonadCatch (ReadlineC m)
-> (forall b.
    ((forall a. ReadlineC m a -> ReadlineC m a) -> ReadlineC m b)
    -> ReadlineC m b)
-> (forall b.
    ((forall a. ReadlineC m a -> ReadlineC m a) -> ReadlineC m b)
    -> ReadlineC m b)
-> (forall a b c.
    ReadlineC m a
    -> (a -> ExitCase b -> ReadlineC m c)
    -> (a -> ReadlineC m b)
    -> ReadlineC m (b, c))
-> MonadMask (ReadlineC m)
ReadlineC m a
-> (a -> ExitCase b -> ReadlineC m c)
-> (a -> ReadlineC m b)
-> ReadlineC m (b, c)
((forall a. ReadlineC m a -> ReadlineC m a) -> ReadlineC m b)
-> ReadlineC m b
((forall a. ReadlineC m a -> ReadlineC m a) -> ReadlineC m b)
-> ReadlineC m b
forall b.
((forall a. ReadlineC m a -> ReadlineC m a) -> ReadlineC m b)
-> ReadlineC m b
forall a b c.
ReadlineC m a
-> (a -> ExitCase b -> ReadlineC m c)
-> (a -> ReadlineC m b)
-> ReadlineC m (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
forall (m :: * -> *). MonadMask m => MonadCatch (ReadlineC m)
forall (m :: * -> *) b.
MonadMask m =>
((forall a. ReadlineC m a -> ReadlineC m a) -> ReadlineC m b)
-> ReadlineC m b
forall (m :: * -> *) a b c.
MonadMask m =>
ReadlineC m a
-> (a -> ExitCase b -> ReadlineC m c)
-> (a -> ReadlineC m b)
-> ReadlineC m (b, c)
generalBracket :: ReadlineC m a
-> (a -> ExitCase b -> ReadlineC m c)
-> (a -> ReadlineC m b)
-> ReadlineC m (b, c)
$cgeneralBracket :: forall (m :: * -> *) a b c.
MonadMask m =>
ReadlineC m a
-> (a -> ExitCase b -> ReadlineC m c)
-> (a -> ReadlineC m b)
-> ReadlineC m (b, c)
uninterruptibleMask :: ((forall a. ReadlineC m a -> ReadlineC m a) -> ReadlineC m b)
-> ReadlineC m b
$cuninterruptibleMask :: forall (m :: * -> *) b.
MonadMask m =>
((forall a. ReadlineC m a -> ReadlineC m a) -> ReadlineC m b)
-> ReadlineC m b
mask :: ((forall a. ReadlineC m a -> ReadlineC m a) -> ReadlineC m b)
-> ReadlineC m b
$cmask :: forall (m :: * -> *) b.
MonadMask m =>
((forall a. ReadlineC m a -> ReadlineC m a) -> ReadlineC m b)
-> ReadlineC m b
$cp1MonadMask :: forall (m :: * -> *). MonadMask m => MonadCatch (ReadlineC m)
MonadMask,
      MonadBase b,
      MonadBaseControl b
    )
  deriving (m a -> ReadlineC m a
(forall (m :: * -> *) a. Monad m => m a -> ReadlineC m a)
-> MonadTrans ReadlineC
forall (m :: * -> *) a. Monad m => m a -> ReadlineC m a
forall (t :: Effect).
(forall (m :: * -> *) a. Monad m => m a -> t m a) -> MonadTrans t
lift :: m a -> ReadlineC m a
$clift :: forall (m :: * -> *) a. Monad m => m a -> ReadlineC m a
MonadTrans) via ReadlineT

deriving newtype instance Eff (Embed IO) m => MonadIO (ReadlineC m)

readlineC :: H.InputT (EfflyIO m) a -> ReadlineC m a
readlineC :: InputT (EfflyIO m) a -> ReadlineC m a
readlineC = InputT (EfflyIO m) a -> ReadlineC m a
coerce

runReadlineC ::
  (H.InputT (EfflyIO m) a -> EfflyIO m a) -> ReadlineC m a -> m a
runReadlineC :: (InputT (EfflyIO m) a -> EfflyIO m a) -> ReadlineC m a -> m a
runReadlineC = (InputT (EfflyIO m) a -> EfflyIO m a) -> ReadlineC m a -> m a
coerce

instance
  ( Carrier m,
    Eff (Embed IO) m,
    MonadMask m,
    Threads ReadlineT (Prims m)
  ) =>
  Carrier (ReadlineC m)
  where
  type Derivs (ReadlineC m) = Readline ': ReadlineHistory ': Derivs m
  type Prims (ReadlineC m) = Prims m
  algPrims :: Algebra' (Prims (ReadlineC m)) (ReadlineC m) a
algPrims = (Union (Prims m) (ReadlineT m) a -> ReadlineT m a)
-> Algebra' (Prims m) (ReadlineC m) a
coerce (Algebra (Prims m) m -> Algebra (Prims m) (ReadlineT m)
forall (t :: Effect) (p :: [Effect]) (m :: * -> *).
(Threads t p, Monad m) =>
Algebra p m -> Algebra p (t m)
thread @ReadlineT (Carrier m => Algebra (Prims m) m
forall (m :: * -> *) a. Carrier m => Algebra' (Prims m) m a
algPrims @m))
{- ORMOLU_DISABLE -}
  reformulate :: Reformulation'
  (Derivs (ReadlineC m)) (Prims (ReadlineC m)) (ReadlineC m) z a
reformulate =
    (forall (z :: * -> *) x.
 (Carrier z, Derivs z ~ (ReadlineHistory : Derivs m),
  Prims z ~ Prims m, MonadBase (ReadlineC m) z) =>
 Readline (Effly z) x -> Effly z x)
-> Reformulation
     (ReadlineHistory : Derivs m) (Prims m) (ReadlineC m)
-> Reformulation
     (Readline : ReadlineHistory : Derivs m) (Prims m) (ReadlineC m)
forall (e :: Effect) (m :: * -> *) (r :: [Effect]) (p :: [Effect]).
(RepresentationalEff e, Monad m) =>
(forall (z :: * -> *) x.
 (Carrier z, Derivs z ~ r, Prims z ~ p, MonadBase m z) =>
 e (Effly z) x -> Effly z x)
-> Reformulation r p m -> Reformulation (e : r) p m
addDeriv
      ( \case
          GetInputLine p -> ReadlineC m (Maybe String) -> Effly z (Maybe String)
forall (b :: * -> *) (m :: * -> *) α. MonadBase b m => b α -> m α
liftBase (ReadlineC m (Maybe String) -> Effly z (Maybe String))
-> ReadlineC m (Maybe String) -> Effly z (Maybe String)
forall a b. (a -> b) -> a -> b
$ InputT (EfflyIO m) (Maybe String) -> ReadlineC m (Maybe String)
forall (m :: * -> *) a. InputT (EfflyIO m) a -> ReadlineC m a
readlineC (InputT (EfflyIO m) (Maybe String) -> ReadlineC m (Maybe String))
-> InputT (EfflyIO m) (Maybe String) -> ReadlineC m (Maybe String)
forall a b. (a -> b) -> a -> b
$ String -> InputT (EfflyIO m) (Maybe String)
forall (m :: * -> *).
(MonadIO m, MonadMask m) =>
String -> InputT m (Maybe String)
H.getInputLine String
p
          GetInputLineWithInitial p i -> ReadlineC m (Maybe String) -> Effly z (Maybe String)
forall (b :: * -> *) (m :: * -> *) α. MonadBase b m => b α -> m α
liftBase (ReadlineC m (Maybe String) -> Effly z (Maybe String))
-> ReadlineC m (Maybe String) -> Effly z (Maybe String)
forall a b. (a -> b) -> a -> b
$ InputT (EfflyIO m) (Maybe String) -> ReadlineC m (Maybe String)
forall (m :: * -> *) a. InputT (EfflyIO m) a -> ReadlineC m a
readlineC (InputT (EfflyIO m) (Maybe String) -> ReadlineC m (Maybe String))
-> InputT (EfflyIO m) (Maybe String) -> ReadlineC m (Maybe String)
forall a b. (a -> b) -> a -> b
$ String -> (String, String) -> InputT (EfflyIO m) (Maybe String)
forall (m :: * -> *).
(MonadIO m, MonadMask m) =>
String -> (String, String) -> InputT m (Maybe String)
H.getInputLineWithInitial String
p (String, String)
i
          GetInputChar p -> ReadlineC m (Maybe Char) -> Effly z (Maybe Char)
forall (b :: * -> *) (m :: * -> *) α. MonadBase b m => b α -> m α
liftBase (ReadlineC m (Maybe Char) -> Effly z (Maybe Char))
-> ReadlineC m (Maybe Char) -> Effly z (Maybe Char)
forall a b. (a -> b) -> a -> b
$ InputT (EfflyIO m) (Maybe Char) -> ReadlineC m (Maybe Char)
forall (m :: * -> *) a. InputT (EfflyIO m) a -> ReadlineC m a
readlineC (InputT (EfflyIO m) (Maybe Char) -> ReadlineC m (Maybe Char))
-> InputT (EfflyIO m) (Maybe Char) -> ReadlineC m (Maybe Char)
forall a b. (a -> b) -> a -> b
$ String -> InputT (EfflyIO m) (Maybe Char)
forall (m :: * -> *).
(MonadIO m, MonadMask m) =>
String -> InputT m (Maybe Char)
H.getInputChar String
p
          GetPassword m p -> ReadlineC m (Maybe String) -> Effly z (Maybe String)
forall (b :: * -> *) (m :: * -> *) α. MonadBase b m => b α -> m α
liftBase (ReadlineC m (Maybe String) -> Effly z (Maybe String))
-> ReadlineC m (Maybe String) -> Effly z (Maybe String)
forall a b. (a -> b) -> a -> b
$ InputT (EfflyIO m) (Maybe String) -> ReadlineC m (Maybe String)
forall (m :: * -> *) a. InputT (EfflyIO m) a -> ReadlineC m a
readlineC (InputT (EfflyIO m) (Maybe String) -> ReadlineC m (Maybe String))
-> InputT (EfflyIO m) (Maybe String) -> ReadlineC m (Maybe String)
forall a b. (a -> b) -> a -> b
$ Maybe Char -> String -> InputT (EfflyIO m) (Maybe String)
forall (m :: * -> *).
(MonadIO m, MonadMask m) =>
Maybe Char -> String -> InputT m (Maybe String)
H.getPassword Maybe Char
m String
p
          WaitForAnyKey p -> ReadlineC m Bool -> Effly z Bool
forall (b :: * -> *) (m :: * -> *) α. MonadBase b m => b α -> m α
liftBase (ReadlineC m Bool -> Effly z Bool)
-> ReadlineC m Bool -> Effly z Bool
forall a b. (a -> b) -> a -> b
$ InputT (EfflyIO m) Bool -> ReadlineC m Bool
forall (m :: * -> *) a. InputT (EfflyIO m) a -> ReadlineC m a
readlineC (InputT (EfflyIO m) Bool -> ReadlineC m Bool)
-> InputT (EfflyIO m) Bool -> ReadlineC m Bool
forall a b. (a -> b) -> a -> b
$ String -> InputT (EfflyIO m) Bool
forall (m :: * -> *).
(MonadIO m, MonadMask m) =>
String -> InputT m Bool
H.waitForAnyKey String
p
          OutputStr s -> ReadlineC m () -> Effly z ()
forall (b :: * -> *) (m :: * -> *) α. MonadBase b m => b α -> m α
liftBase (ReadlineC m () -> Effly z ()) -> ReadlineC m () -> Effly z ()
forall a b. (a -> b) -> a -> b
$ InputT (EfflyIO m) () -> ReadlineC m ()
forall (m :: * -> *) a. InputT (EfflyIO m) a -> ReadlineC m a
readlineC (InputT (EfflyIO m) () -> ReadlineC m ())
-> InputT (EfflyIO m) () -> ReadlineC m ()
forall a b. (a -> b) -> a -> b
$ String -> InputT (EfflyIO m) ()
forall (m :: * -> *). MonadIO m => String -> InputT m ()
H.outputStr String
s
      ) (Reformulation (ReadlineHistory : Derivs m) (Prims m) (ReadlineC m)
 -> Reformulation
      (Readline : ReadlineHistory : Derivs m) (Prims m) (ReadlineC m))
-> Reformulation
     (ReadlineHistory : Derivs m) (Prims m) (ReadlineC m)
-> Reformulation
     (Readline : ReadlineHistory : Derivs m) (Prims m) (ReadlineC m)
forall a b. (a -> b) -> a -> b
$
    (forall (z :: * -> *) x.
 (Carrier z, Derivs z ~ Derivs m, Prims z ~ Prims m,
  MonadBase (ReadlineC m) z) =>
 ReadlineHistory (Effly z) x -> Effly z x)
-> Reformulation (Derivs m) (Prims m) (ReadlineC m)
-> Reformulation
     (ReadlineHistory : Derivs m) (Prims m) (ReadlineC m)
forall (e :: Effect) (m :: * -> *) (r :: [Effect]) (p :: [Effect]).
(RepresentationalEff e, Monad m) =>
(forall (z :: * -> *) x.
 (Carrier z, Derivs z ~ r, Prims z ~ p, MonadBase m z) =>
 e (Effly z) x -> Effly z x)
-> Reformulation r p m -> Reformulation (e : r) p m
addDeriv
      ( \case
          ReadlineHistory (Effly z) x
GetHistory -> ReadlineC m History -> Effly z History
forall (b :: * -> *) (m :: * -> *) α. MonadBase b m => b α -> m α
liftBase (ReadlineC m History -> Effly z History)
-> ReadlineC m History -> Effly z History
forall a b. (a -> b) -> a -> b
$ InputT (EfflyIO m) History -> ReadlineC m History
forall (m :: * -> *) a. InputT (EfflyIO m) a -> ReadlineC m a
readlineC InputT (EfflyIO m) History
forall (m :: * -> *). MonadIO m => InputT m History
H.getHistory
          PutHistory h -> ReadlineC m () -> Effly z ()
forall (b :: * -> *) (m :: * -> *) α. MonadBase b m => b α -> m α
liftBase (ReadlineC m () -> Effly z ()) -> ReadlineC m () -> Effly z ()
forall a b. (a -> b) -> a -> b
$ InputT (EfflyIO m) () -> ReadlineC m ()
forall (m :: * -> *) a. InputT (EfflyIO m) a -> ReadlineC m a
readlineC (InputT (EfflyIO m) () -> ReadlineC m ())
-> InputT (EfflyIO m) () -> ReadlineC m ()
forall a b. (a -> b) -> a -> b
$ History -> InputT (EfflyIO m) ()
forall (m :: * -> *). MonadIO m => History -> InputT m ()
H.putHistory History
h
      ) (Reformulation (Derivs m) (Prims m) (ReadlineC m)
 -> Reformulation
      (ReadlineHistory : Derivs m) (Prims m) (ReadlineC m))
-> Reformulation (Derivs m) (Prims m) (ReadlineC m)
-> Reformulation
     (ReadlineHistory : Derivs m) (Prims m) (ReadlineC m)
forall a b. (a -> b) -> a -> b
$
    Reformulation' (Derivs m) (Prims m) m z x
-> Reformulation' (Derivs m) (Prims m) (ReadlineC m) z x
forall (t :: Effect) (m :: * -> *) (r :: [Effect]) (p :: [Effect])
       (z :: * -> *) a.
(MonadTrans t, Monad m) =>
Reformulation' r p m z a -> Reformulation' r p (t m) z a
liftReform (Reformulation' (Derivs m) (Prims m) m z x
 -> Reformulation' (Derivs m) (Prims m) (ReadlineC m) z x)
-> Reformulation' (Derivs m) (Prims m) m z x
-> Reformulation' (Derivs m) (Prims m) (ReadlineC m) z x
forall a b. (a -> b) -> a -> b
$
    forall (z :: * -> *) a.
(Carrier m, Monad z) =>
Reformulation' (Derivs m) (Prims m) m z a
forall (m :: * -> *) (z :: * -> *) a.
(Carrier m, Monad z) =>
Reformulation' (Derivs m) (Prims m) m z a
reformulate @m
{- ORMOLU_ENABLE -}

newtype ReadlineInterruptC m a = ReadlineInterruptC {ReadlineInterruptC m a -> ReadlineT (EfflyIO m) a
unReadlineInterruptC :: ReadlineT (EfflyIO m) a}
  deriving newtype
    ( a -> ReadlineInterruptC m b -> ReadlineInterruptC m a
(a -> b) -> ReadlineInterruptC m a -> ReadlineInterruptC m b
(forall a b.
 (a -> b) -> ReadlineInterruptC m a -> ReadlineInterruptC m b)
-> (forall a b.
    a -> ReadlineInterruptC m b -> ReadlineInterruptC m a)
-> Functor (ReadlineInterruptC m)
forall a b. a -> ReadlineInterruptC m b -> ReadlineInterruptC m a
forall a b.
(a -> b) -> ReadlineInterruptC m a -> ReadlineInterruptC m b
forall (m :: * -> *) a b.
Functor m =>
a -> ReadlineInterruptC m b -> ReadlineInterruptC m a
forall (m :: * -> *) a b.
Functor m =>
(a -> b) -> ReadlineInterruptC m a -> ReadlineInterruptC m b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> ReadlineInterruptC m b -> ReadlineInterruptC m a
$c<$ :: forall (m :: * -> *) a b.
Functor m =>
a -> ReadlineInterruptC m b -> ReadlineInterruptC m a
fmap :: (a -> b) -> ReadlineInterruptC m a -> ReadlineInterruptC m b
$cfmap :: forall (m :: * -> *) a b.
Functor m =>
(a -> b) -> ReadlineInterruptC m a -> ReadlineInterruptC m b
Functor,
      Functor (ReadlineInterruptC m)
a -> ReadlineInterruptC m a
Functor (ReadlineInterruptC m)
-> (forall a. a -> ReadlineInterruptC m a)
-> (forall a b.
    ReadlineInterruptC m (a -> b)
    -> ReadlineInterruptC m a -> ReadlineInterruptC m b)
-> (forall a b c.
    (a -> b -> c)
    -> ReadlineInterruptC m a
    -> ReadlineInterruptC m b
    -> ReadlineInterruptC m c)
-> (forall a b.
    ReadlineInterruptC m a
    -> ReadlineInterruptC m b -> ReadlineInterruptC m b)
-> (forall a b.
    ReadlineInterruptC m a
    -> ReadlineInterruptC m b -> ReadlineInterruptC m a)
-> Applicative (ReadlineInterruptC m)
ReadlineInterruptC m a
-> ReadlineInterruptC m b -> ReadlineInterruptC m b
ReadlineInterruptC m a
-> ReadlineInterruptC m b -> ReadlineInterruptC m a
ReadlineInterruptC m (a -> b)
-> ReadlineInterruptC m a -> ReadlineInterruptC m b
(a -> b -> c)
-> ReadlineInterruptC m a
-> ReadlineInterruptC m b
-> ReadlineInterruptC m c
forall a. a -> ReadlineInterruptC m a
forall a b.
ReadlineInterruptC m a
-> ReadlineInterruptC m b -> ReadlineInterruptC m a
forall a b.
ReadlineInterruptC m a
-> ReadlineInterruptC m b -> ReadlineInterruptC m b
forall a b.
ReadlineInterruptC m (a -> b)
-> ReadlineInterruptC m a -> ReadlineInterruptC m b
forall a b c.
(a -> b -> c)
-> ReadlineInterruptC m a
-> ReadlineInterruptC m b
-> ReadlineInterruptC m 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
forall (m :: * -> *).
Applicative m =>
Functor (ReadlineInterruptC m)
forall (m :: * -> *) a.
Applicative m =>
a -> ReadlineInterruptC m a
forall (m :: * -> *) a b.
Applicative m =>
ReadlineInterruptC m a
-> ReadlineInterruptC m b -> ReadlineInterruptC m a
forall (m :: * -> *) a b.
Applicative m =>
ReadlineInterruptC m a
-> ReadlineInterruptC m b -> ReadlineInterruptC m b
forall (m :: * -> *) a b.
Applicative m =>
ReadlineInterruptC m (a -> b)
-> ReadlineInterruptC m a -> ReadlineInterruptC m b
forall (m :: * -> *) a b c.
Applicative m =>
(a -> b -> c)
-> ReadlineInterruptC m a
-> ReadlineInterruptC m b
-> ReadlineInterruptC m c
<* :: ReadlineInterruptC m a
-> ReadlineInterruptC m b -> ReadlineInterruptC m a
$c<* :: forall (m :: * -> *) a b.
Applicative m =>
ReadlineInterruptC m a
-> ReadlineInterruptC m b -> ReadlineInterruptC m a
*> :: ReadlineInterruptC m a
-> ReadlineInterruptC m b -> ReadlineInterruptC m b
$c*> :: forall (m :: * -> *) a b.
Applicative m =>
ReadlineInterruptC m a
-> ReadlineInterruptC m b -> ReadlineInterruptC m b
liftA2 :: (a -> b -> c)
-> ReadlineInterruptC m a
-> ReadlineInterruptC m b
-> ReadlineInterruptC m c
$cliftA2 :: forall (m :: * -> *) a b c.
Applicative m =>
(a -> b -> c)
-> ReadlineInterruptC m a
-> ReadlineInterruptC m b
-> ReadlineInterruptC m c
<*> :: ReadlineInterruptC m (a -> b)
-> ReadlineInterruptC m a -> ReadlineInterruptC m b
$c<*> :: forall (m :: * -> *) a b.
Applicative m =>
ReadlineInterruptC m (a -> b)
-> ReadlineInterruptC m a -> ReadlineInterruptC m b
pure :: a -> ReadlineInterruptC m a
$cpure :: forall (m :: * -> *) a.
Applicative m =>
a -> ReadlineInterruptC m a
$cp1Applicative :: forall (m :: * -> *).
Applicative m =>
Functor (ReadlineInterruptC m)
Applicative,
      Applicative (ReadlineInterruptC m)
a -> ReadlineInterruptC m a
Applicative (ReadlineInterruptC m)
-> (forall a b.
    ReadlineInterruptC m a
    -> (a -> ReadlineInterruptC m b) -> ReadlineInterruptC m b)
-> (forall a b.
    ReadlineInterruptC m a
    -> ReadlineInterruptC m b -> ReadlineInterruptC m b)
-> (forall a. a -> ReadlineInterruptC m a)
-> Monad (ReadlineInterruptC m)
ReadlineInterruptC m a
-> (a -> ReadlineInterruptC m b) -> ReadlineInterruptC m b
ReadlineInterruptC m a
-> ReadlineInterruptC m b -> ReadlineInterruptC m b
forall a. a -> ReadlineInterruptC m a
forall a b.
ReadlineInterruptC m a
-> ReadlineInterruptC m b -> ReadlineInterruptC m b
forall a b.
ReadlineInterruptC m a
-> (a -> ReadlineInterruptC m b) -> ReadlineInterruptC m b
forall (m :: * -> *). Monad m => Applicative (ReadlineInterruptC m)
forall (m :: * -> *) a. Monad m => a -> ReadlineInterruptC m a
forall (m :: * -> *) a b.
Monad m =>
ReadlineInterruptC m a
-> ReadlineInterruptC m b -> ReadlineInterruptC m b
forall (m :: * -> *) a b.
Monad m =>
ReadlineInterruptC m a
-> (a -> ReadlineInterruptC m b) -> ReadlineInterruptC m 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 -> ReadlineInterruptC m a
$creturn :: forall (m :: * -> *) a. Monad m => a -> ReadlineInterruptC m a
>> :: ReadlineInterruptC m a
-> ReadlineInterruptC m b -> ReadlineInterruptC m b
$c>> :: forall (m :: * -> *) a b.
Monad m =>
ReadlineInterruptC m a
-> ReadlineInterruptC m b -> ReadlineInterruptC m b
>>= :: ReadlineInterruptC m a
-> (a -> ReadlineInterruptC m b) -> ReadlineInterruptC m b
$c>>= :: forall (m :: * -> *) a b.
Monad m =>
ReadlineInterruptC m a
-> (a -> ReadlineInterruptC m b) -> ReadlineInterruptC m b
$cp1Monad :: forall (m :: * -> *). Monad m => Applicative (ReadlineInterruptC m)
Monad,
      Monad (ReadlineInterruptC m)
Monad (ReadlineInterruptC m)
-> (forall a.
    (a -> ReadlineInterruptC m a) -> ReadlineInterruptC m a)
-> MonadFix (ReadlineInterruptC m)
(a -> ReadlineInterruptC m a) -> ReadlineInterruptC m a
forall a. (a -> ReadlineInterruptC m a) -> ReadlineInterruptC m a
forall (m :: * -> *).
Monad m -> (forall a. (a -> m a) -> m a) -> MonadFix m
forall (m :: * -> *). MonadFix m => Monad (ReadlineInterruptC m)
forall (m :: * -> *) a.
MonadFix m =>
(a -> ReadlineInterruptC m a) -> ReadlineInterruptC m a
mfix :: (a -> ReadlineInterruptC m a) -> ReadlineInterruptC m a
$cmfix :: forall (m :: * -> *) a.
MonadFix m =>
(a -> ReadlineInterruptC m a) -> ReadlineInterruptC m a
$cp1MonadFix :: forall (m :: * -> *). MonadFix m => Monad (ReadlineInterruptC m)
MonadFix,
      Monad (ReadlineInterruptC m)
Monad (ReadlineInterruptC m)
-> (forall a. String -> ReadlineInterruptC m a)
-> MonadFail (ReadlineInterruptC m)
String -> ReadlineInterruptC m a
forall a. String -> ReadlineInterruptC m a
forall (m :: * -> *).
Monad m -> (forall a. String -> m a) -> MonadFail m
forall (m :: * -> *). MonadFail m => Monad (ReadlineInterruptC m)
forall (m :: * -> *) a.
MonadFail m =>
String -> ReadlineInterruptC m a
fail :: String -> ReadlineInterruptC m a
$cfail :: forall (m :: * -> *) a.
MonadFail m =>
String -> ReadlineInterruptC m a
$cp1MonadFail :: forall (m :: * -> *). MonadFail m => Monad (ReadlineInterruptC m)
MonadFail,
      Monad (ReadlineInterruptC m)
e -> ReadlineInterruptC m a
Monad (ReadlineInterruptC m)
-> (forall e a. Exception e => e -> ReadlineInterruptC m a)
-> MonadThrow (ReadlineInterruptC m)
forall e a. Exception e => e -> ReadlineInterruptC m a
forall (m :: * -> *).
Monad m -> (forall e a. Exception e => e -> m a) -> MonadThrow m
forall (m :: * -> *). MonadThrow m => Monad (ReadlineInterruptC m)
forall (m :: * -> *) e a.
(MonadThrow m, Exception e) =>
e -> ReadlineInterruptC m a
throwM :: e -> ReadlineInterruptC m a
$cthrowM :: forall (m :: * -> *) e a.
(MonadThrow m, Exception e) =>
e -> ReadlineInterruptC m a
$cp1MonadThrow :: forall (m :: * -> *). MonadThrow m => Monad (ReadlineInterruptC m)
MonadThrow,
      MonadThrow (ReadlineInterruptC m)
MonadThrow (ReadlineInterruptC m)
-> (forall e a.
    Exception e =>
    ReadlineInterruptC m a
    -> (e -> ReadlineInterruptC m a) -> ReadlineInterruptC m a)
-> MonadCatch (ReadlineInterruptC m)
ReadlineInterruptC m a
-> (e -> ReadlineInterruptC m a) -> ReadlineInterruptC m a
forall e a.
Exception e =>
ReadlineInterruptC m a
-> (e -> ReadlineInterruptC m a) -> ReadlineInterruptC m a
forall (m :: * -> *).
MonadThrow m
-> (forall e a. Exception e => m a -> (e -> m a) -> m a)
-> MonadCatch m
forall (m :: * -> *).
MonadCatch m =>
MonadThrow (ReadlineInterruptC m)
forall (m :: * -> *) e a.
(MonadCatch m, Exception e) =>
ReadlineInterruptC m a
-> (e -> ReadlineInterruptC m a) -> ReadlineInterruptC m a
catch :: ReadlineInterruptC m a
-> (e -> ReadlineInterruptC m a) -> ReadlineInterruptC m a
$ccatch :: forall (m :: * -> *) e a.
(MonadCatch m, Exception e) =>
ReadlineInterruptC m a
-> (e -> ReadlineInterruptC m a) -> ReadlineInterruptC m a
$cp1MonadCatch :: forall (m :: * -> *).
MonadCatch m =>
MonadThrow (ReadlineInterruptC m)
MonadCatch,
      MonadCatch (ReadlineInterruptC m)
MonadCatch (ReadlineInterruptC m)
-> (forall b.
    ((forall a. ReadlineInterruptC m a -> ReadlineInterruptC m a)
     -> ReadlineInterruptC m b)
    -> ReadlineInterruptC m b)
-> (forall b.
    ((forall a. ReadlineInterruptC m a -> ReadlineInterruptC m a)
     -> ReadlineInterruptC m b)
    -> ReadlineInterruptC m b)
-> (forall a b c.
    ReadlineInterruptC m a
    -> (a -> ExitCase b -> ReadlineInterruptC m c)
    -> (a -> ReadlineInterruptC m b)
    -> ReadlineInterruptC m (b, c))
-> MonadMask (ReadlineInterruptC m)
ReadlineInterruptC m a
-> (a -> ExitCase b -> ReadlineInterruptC m c)
-> (a -> ReadlineInterruptC m b)
-> ReadlineInterruptC m (b, c)
((forall a. ReadlineInterruptC m a -> ReadlineInterruptC m a)
 -> ReadlineInterruptC m b)
-> ReadlineInterruptC m b
((forall a. ReadlineInterruptC m a -> ReadlineInterruptC m a)
 -> ReadlineInterruptC m b)
-> ReadlineInterruptC m b
forall b.
((forall a. ReadlineInterruptC m a -> ReadlineInterruptC m a)
 -> ReadlineInterruptC m b)
-> ReadlineInterruptC m b
forall a b c.
ReadlineInterruptC m a
-> (a -> ExitCase b -> ReadlineInterruptC m c)
-> (a -> ReadlineInterruptC m b)
-> ReadlineInterruptC m (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
forall (m :: * -> *).
MonadMask m =>
MonadCatch (ReadlineInterruptC m)
forall (m :: * -> *) b.
MonadMask m =>
((forall a. ReadlineInterruptC m a -> ReadlineInterruptC m a)
 -> ReadlineInterruptC m b)
-> ReadlineInterruptC m b
forall (m :: * -> *) a b c.
MonadMask m =>
ReadlineInterruptC m a
-> (a -> ExitCase b -> ReadlineInterruptC m c)
-> (a -> ReadlineInterruptC m b)
-> ReadlineInterruptC m (b, c)
generalBracket :: ReadlineInterruptC m a
-> (a -> ExitCase b -> ReadlineInterruptC m c)
-> (a -> ReadlineInterruptC m b)
-> ReadlineInterruptC m (b, c)
$cgeneralBracket :: forall (m :: * -> *) a b c.
MonadMask m =>
ReadlineInterruptC m a
-> (a -> ExitCase b -> ReadlineInterruptC m c)
-> (a -> ReadlineInterruptC m b)
-> ReadlineInterruptC m (b, c)
uninterruptibleMask :: ((forall a. ReadlineInterruptC m a -> ReadlineInterruptC m a)
 -> ReadlineInterruptC m b)
-> ReadlineInterruptC m b
$cuninterruptibleMask :: forall (m :: * -> *) b.
MonadMask m =>
((forall a. ReadlineInterruptC m a -> ReadlineInterruptC m a)
 -> ReadlineInterruptC m b)
-> ReadlineInterruptC m b
mask :: ((forall a. ReadlineInterruptC m a -> ReadlineInterruptC m a)
 -> ReadlineInterruptC m b)
-> ReadlineInterruptC m b
$cmask :: forall (m :: * -> *) b.
MonadMask m =>
((forall a. ReadlineInterruptC m a -> ReadlineInterruptC m a)
 -> ReadlineInterruptC m b)
-> ReadlineInterruptC m b
$cp1MonadMask :: forall (m :: * -> *).
MonadMask m =>
MonadCatch (ReadlineInterruptC m)
MonadMask,
      MonadBase b,
      MonadBaseControl b
    )
  deriving (m a -> ReadlineInterruptC m a
(forall (m :: * -> *) a. Monad m => m a -> ReadlineInterruptC m a)
-> MonadTrans ReadlineInterruptC
forall (m :: * -> *) a. Monad m => m a -> ReadlineInterruptC m a
forall (t :: Effect).
(forall (m :: * -> *) a. Monad m => m a -> t m a) -> MonadTrans t
lift :: m a -> ReadlineInterruptC m a
$clift :: forall (m :: * -> *) a. Monad m => m a -> ReadlineInterruptC m a
MonadTrans) via ReadlineT

deriving newtype instance Eff (Embed IO) m => MonadIO (ReadlineInterruptC m)

readlineInterruptC :: H.InputT (EfflyIO m) a -> ReadlineInterruptC m a
readlineInterruptC :: InputT (EfflyIO m) a -> ReadlineInterruptC m a
readlineInterruptC = InputT (EfflyIO m) a -> ReadlineInterruptC m a
coerce

runReadlineInterruptC ::
  (H.InputT (EfflyIO m) a -> EfflyIO m a) -> ReadlineInterruptC m a -> m a
runReadlineInterruptC :: (InputT (EfflyIO m) a -> EfflyIO m a)
-> ReadlineInterruptC m a -> m a
runReadlineInterruptC = (InputT (EfflyIO m) a -> EfflyIO m a)
-> ReadlineInterruptC m a -> m a
coerce

-- | Type for denoting which kind of 'Optional' we are inside of.
data WithOrHandleInterrupt a
  = WithInterrupts
  | OnInterruptContinueWith a
  deriving (a -> WithOrHandleInterrupt b -> WithOrHandleInterrupt a
(a -> b) -> WithOrHandleInterrupt a -> WithOrHandleInterrupt b
(forall a b.
 (a -> b) -> WithOrHandleInterrupt a -> WithOrHandleInterrupt b)
-> (forall a b.
    a -> WithOrHandleInterrupt b -> WithOrHandleInterrupt a)
-> Functor WithOrHandleInterrupt
forall a b. a -> WithOrHandleInterrupt b -> WithOrHandleInterrupt a
forall a b.
(a -> b) -> WithOrHandleInterrupt a -> WithOrHandleInterrupt b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> WithOrHandleInterrupt b -> WithOrHandleInterrupt a
$c<$ :: forall a b. a -> WithOrHandleInterrupt b -> WithOrHandleInterrupt a
fmap :: (a -> b) -> WithOrHandleInterrupt a -> WithOrHandleInterrupt b
$cfmap :: forall a b.
(a -> b) -> WithOrHandleInterrupt a -> WithOrHandleInterrupt b
Functor)

instance
  ( Carrier m,
    Eff (Embed IO) m,
    MonadMask m,
    Threads ReadlineT (Prims m)
  ) =>
  Carrier (ReadlineInterruptC m)
  where
  type Derivs (ReadlineInterruptC m) = HandleInterrupt ': Derivs (ReadlineC m)
  type Prims (ReadlineInterruptC m) = Optional WithOrHandleInterrupt ': Prims (ReadlineC m)
  algPrims :: Algebra' (Prims (ReadlineInterruptC m)) (ReadlineInterruptC m) a
algPrims = Algebra' (Prims m) (ReadlineInterruptC m) a
-> (Optional WithOrHandleInterrupt (ReadlineInterruptC m) a
    -> ReadlineInterruptC m a)
-> Algebra'
     (Optional WithOrHandleInterrupt : Prims m) (ReadlineInterruptC m) a
forall (e :: Effect) (r :: [Effect]) (m :: * -> *) a.
RepresentationalEff e =>
Algebra' r m a -> (e m a -> m a) -> Algebra' (e : r) m a
powerAlg (Algebra' (Prims m) (ReadlineC m) a
-> Algebra' (Prims m) (ReadlineInterruptC m) a
coerce (forall a.
Carrier (ReadlineC m) =>
Algebra' (Prims (ReadlineC m)) (ReadlineC m) a
forall (m :: * -> *) a. Carrier m => Algebra' (Prims m) m a
algPrims @(ReadlineC m))) ((Optional WithOrHandleInterrupt (ReadlineInterruptC m) a
  -> ReadlineInterruptC m a)
 -> Algebra'
      (Optional WithOrHandleInterrupt : Prims m)
      (ReadlineInterruptC m)
      a)
-> (Optional WithOrHandleInterrupt (ReadlineInterruptC m) a
    -> ReadlineInterruptC m a)
-> Algebra'
     (Optional WithOrHandleInterrupt : Prims m) (ReadlineInterruptC m) a
forall a b. (a -> b) -> a -> b
$ \case
    Optionally WithOrHandleInterrupt a
WithInterrupts ReadlineInterruptC m a
a ->
      InputT (EfflyIO m) a -> ReadlineInterruptC m a
forall (m :: * -> *) a.
InputT (EfflyIO m) a -> ReadlineInterruptC m a
readlineInterruptC (InputT (EfflyIO m) a -> ReadlineInterruptC m a)
-> InputT (EfflyIO m) a -> ReadlineInterruptC m a
forall a b. (a -> b) -> a -> b
$ InputT (EfflyIO m) a -> InputT (EfflyIO m) a
forall (m :: * -> *) a.
(MonadIO m, MonadMask m) =>
InputT m a -> InputT m a
H.withInterrupt (ReadlineT (EfflyIO m) a -> InputT (EfflyIO m) a
forall (m :: * -> *) a. ReadlineT m a -> InputT m a
unReadlineT (ReadlineT (EfflyIO m) a -> InputT (EfflyIO m) a)
-> ReadlineT (EfflyIO m) a -> InputT (EfflyIO m) a
forall a b. (a -> b) -> a -> b
$ ReadlineInterruptC m a -> ReadlineT (EfflyIO m) a
forall (m :: * -> *) a.
ReadlineInterruptC m a -> ReadlineT (EfflyIO m) a
unReadlineInterruptC ReadlineInterruptC m a
a)
    Optionally (OnInterruptContinueWith a
c) ReadlineInterruptC m a
a ->
      InputT (EfflyIO m) a -> ReadlineInterruptC m a
forall (m :: * -> *) a.
InputT (EfflyIO m) a -> ReadlineInterruptC m a
readlineInterruptC (InputT (EfflyIO m) a -> ReadlineInterruptC m a)
-> InputT (EfflyIO m) a -> ReadlineInterruptC m a
forall a b. (a -> b) -> a -> b
$ InputT (EfflyIO m) a
-> InputT (EfflyIO m) a -> InputT (EfflyIO m) a
forall (m :: * -> *) a. MonadMask m => m a -> m a -> m a
H.handleInterrupt (a -> InputT (EfflyIO m) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
c) (ReadlineT (EfflyIO m) a -> InputT (EfflyIO m) a
forall (m :: * -> *) a. ReadlineT m a -> InputT m a
unReadlineT (ReadlineT (EfflyIO m) a -> InputT (EfflyIO m) a)
-> ReadlineT (EfflyIO m) a -> InputT (EfflyIO m) a
forall a b. (a -> b) -> a -> b
$ ReadlineInterruptC m a -> ReadlineT (EfflyIO m) a
forall (m :: * -> *) a.
ReadlineInterruptC m a -> ReadlineT (EfflyIO m) a
unReadlineInterruptC ReadlineInterruptC m a
a)
{- ORMOLU_DISABLE -}
  reformulate :: Reformulation'
  (Derivs (ReadlineInterruptC m))
  (Prims (ReadlineInterruptC m))
  (ReadlineInterruptC m)
  z
  a
reformulate =
    Reformulation'
  (HandleInterrupt
     : Optional WithOrHandleInterrupt : Readline : ReadlineHistory
     : Derivs m)
  (Optional WithOrHandleInterrupt : Prims m)
  (ReadlineInterruptC m)
  z
  a
-> Reformulation'
     (HandleInterrupt : Readline : ReadlineHistory : Derivs m)
     (Optional WithOrHandleInterrupt : Prims m)
     (ReadlineInterruptC m)
     z
     a
forall (e' :: Effect) (e :: Effect) (r :: [Effect]) (p :: [Effect])
       (m :: * -> *) (z :: * -> *) a.
Reformulation' (e : e' : r) p m z a
-> Reformulation' (e : r) p m z a
weakenReformUnder1 (Reformulation'
   (HandleInterrupt
      : Optional WithOrHandleInterrupt : Readline : ReadlineHistory
      : Derivs m)
   (Optional WithOrHandleInterrupt : Prims m)
   (ReadlineInterruptC m)
   z
   a
 -> Reformulation'
      (HandleInterrupt : Readline : ReadlineHistory : Derivs m)
      (Optional WithOrHandleInterrupt : Prims m)
      (ReadlineInterruptC m)
      z
      a)
-> Reformulation'
     (HandleInterrupt
        : Optional WithOrHandleInterrupt : Readline : ReadlineHistory
        : Derivs m)
     (Optional WithOrHandleInterrupt : Prims m)
     (ReadlineInterruptC m)
     z
     a
-> Reformulation'
     (HandleInterrupt : Readline : ReadlineHistory : Derivs m)
     (Optional WithOrHandleInterrupt : Prims m)
     (ReadlineInterruptC m)
     z
     a
forall a b. (a -> b) -> a -> b
$
    (forall (z :: * -> *) x.
 (Carrier z,
  Derivs z
  ~ (Optional WithOrHandleInterrupt
       : Readline : ReadlineHistory : Derivs m),
  Prims z ~ (Optional WithOrHandleInterrupt : Prims m),
  MonadBase (ReadlineInterruptC m) z) =>
 HandleInterrupt (Effly z) x -> Effly z x)
-> Reformulation
     (Optional WithOrHandleInterrupt
        : Readline : ReadlineHistory : Derivs m)
     (Optional WithOrHandleInterrupt : Prims m)
     (ReadlineInterruptC m)
-> Reformulation
     (HandleInterrupt
        : Optional WithOrHandleInterrupt : Readline : ReadlineHistory
        : Derivs m)
     (Optional WithOrHandleInterrupt : Prims m)
     (ReadlineInterruptC m)
forall (e :: Effect) (m :: * -> *) (r :: [Effect]) (p :: [Effect]).
(RepresentationalEff e, Monad m) =>
(forall (z :: * -> *) x.
 (Carrier z, Derivs z ~ r, Prims z ~ p, MonadBase m z) =>
 e (Effly z) x -> Effly z x)
-> Reformulation r p m -> Reformulation (e : r) p m
addDeriv
      ( \case
          WithInterrupt a -> Effly z (Effly z x) -> Effly z x
forall (m :: * -> *) a. Monad m => m (m a) -> m a
join (Effly z (Effly z x) -> Effly z x)
-> Effly z (Effly z x) -> Effly z x
forall a b. (a -> b) -> a -> b
$ WithOrHandleInterrupt (Effly z x)
-> Effly z (Effly z x) -> Effly z (Effly z x)
forall (s :: * -> *) (m :: * -> *) a.
Eff (Optional s) m =>
s a -> m a -> m a
optionally WithOrHandleInterrupt (Effly z x)
forall a. WithOrHandleInterrupt a
WithInterrupts ((x -> Effly z x) -> Effly z x -> Effly z (Effly z x)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap x -> Effly z x
forall (f :: * -> *) a. Applicative f => a -> f a
pure Effly z x
a)
          HandleInterrupt c a ->
            Effly z (Effly z x) -> Effly z x
forall (m :: * -> *) a. Monad m => m (m a) -> m a
join (Effly z (Effly z x) -> Effly z x)
-> Effly z (Effly z x) -> Effly z x
forall a b. (a -> b) -> a -> b
$ WithOrHandleInterrupt (Effly z x)
-> Effly z (Effly z x) -> Effly z (Effly z x)
forall (s :: * -> *) (m :: * -> *) a.
Eff (Optional s) m =>
s a -> m a -> m a
optionally (Effly z x -> WithOrHandleInterrupt (Effly z x)
forall a. a -> WithOrHandleInterrupt a
OnInterruptContinueWith Effly z x
c) ((x -> Effly z x) -> Effly z x -> Effly z (Effly z x)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap x -> Effly z x
forall (f :: * -> *) a. Applicative f => a -> f a
pure Effly z x
a)
      ) (Reformulation
   (Optional WithOrHandleInterrupt
      : Readline : ReadlineHistory : Derivs m)
   (Optional WithOrHandleInterrupt : Prims m)
   (ReadlineInterruptC m)
 -> Reformulation
      (HandleInterrupt
         : Optional WithOrHandleInterrupt : Readline : ReadlineHistory
         : Derivs m)
      (Optional WithOrHandleInterrupt : Prims m)
      (ReadlineInterruptC m))
-> Reformulation
     (Optional WithOrHandleInterrupt
        : Readline : ReadlineHistory : Derivs m)
     (Optional WithOrHandleInterrupt : Prims m)
     (ReadlineInterruptC m)
-> Reformulation
     (HandleInterrupt
        : Optional WithOrHandleInterrupt : Readline : ReadlineHistory
        : Derivs m)
     (Optional WithOrHandleInterrupt : Prims m)
     (ReadlineInterruptC m)
forall a b. (a -> b) -> a -> b
$
    Reformulation'
  (Readline : ReadlineHistory : Derivs m)
  (Prims m)
  (ReadlineInterruptC m)
  z
  x
-> Reformulation'
     (Optional WithOrHandleInterrupt
        : Readline : ReadlineHistory : Derivs m)
     (Optional WithOrHandleInterrupt : Prims m)
     (ReadlineInterruptC m)
     z
     x
forall (e :: Effect) (r :: [Effect]) (p :: [Effect]) (m :: * -> *)
       (z :: * -> *) a.
Monad z =>
Reformulation' r p m z a -> Reformulation' (e : r) (e : p) m z a
addPrim (Reformulation'
   (Readline : ReadlineHistory : Derivs m)
   (Prims m)
   (ReadlineInterruptC m)
   z
   x
 -> Reformulation'
      (Optional WithOrHandleInterrupt
         : Readline : ReadlineHistory : Derivs m)
      (Optional WithOrHandleInterrupt : Prims m)
      (ReadlineInterruptC m)
      z
      x)
-> Reformulation'
     (Readline : ReadlineHistory : Derivs m)
     (Prims m)
     (ReadlineInterruptC m)
     z
     x
-> Reformulation'
     (Optional WithOrHandleInterrupt
        : Readline : ReadlineHistory : Derivs m)
     (Optional WithOrHandleInterrupt : Prims m)
     (ReadlineInterruptC m)
     z
     x
forall a b. (a -> b) -> a -> b
$
    Reformulation'
  (Readline : ReadlineHistory : Derivs m) (Prims m) (ReadlineC m) z x
-> Reformulation'
     (Readline : ReadlineHistory : Derivs m)
     (Prims m)
     (ReadlineInterruptC m)
     z
     x
forall (m :: * -> *) (n :: * -> *) (r :: [Effect]) (p :: [Effect])
       (z :: * -> *) a.
Coercible m n =>
Reformulation' r p m z a -> Reformulation' r p n z a
coerceReform (Reformulation'
   (Readline : ReadlineHistory : Derivs m) (Prims m) (ReadlineC m) z x
 -> Reformulation'
      (Readline : ReadlineHistory : Derivs m)
      (Prims m)
      (ReadlineInterruptC m)
      z
      x)
-> Reformulation'
     (Readline : ReadlineHistory : Derivs m) (Prims m) (ReadlineC m) z x
-> Reformulation'
     (Readline : ReadlineHistory : Derivs m)
     (Prims m)
     (ReadlineInterruptC m)
     z
     x
forall a b. (a -> b) -> a -> b
$
    forall (z :: * -> *) a.
(Carrier (ReadlineC m), Monad z) =>
Reformulation'
  (Derivs (ReadlineC m)) (Prims (ReadlineC m)) (ReadlineC m) z a
forall (m :: * -> *) (z :: * -> *) a.
(Carrier m, Monad z) =>
Reformulation' (Derivs m) (Prims m) m z a
reformulate @(ReadlineC m)
{- ORMOLU_ENABLE -}

-- | Main interpreter for 'Readline', 'ReadlineHistory', and 'HandleInterrupt'
-- effects. 'H.defaultSettings' exists as a default for settings.
--
-- Example usage:
--
-- > import Control.Effect
-- > import Control.Effect.Readline
-- >
-- > repl :: Effs '[Readline, HandleInterrupt] m => m ()
-- > repl = handleInterrupt (outputStrLn "Interrupt!" *> repl) $
-- >   withInterrupt $ do
-- >     mline <- getInputLine "> "
-- >     case mline of
-- >       Nothing -> pure ()
-- >       Just line -> outputStrLn line *> repl
-- >
-- > main :: IO ()
-- > main = runM $ runReadline defaultSettings repl
runReadline ::
  (Eff (Embed IO) m, MonadMask m, Carrier m, Threaders '[ReadlineThreads] m p) =>
  H.Settings m ->
  ReadlineInterruptC m a ->
  m a
runReadline :: Settings m -> ReadlineInterruptC m a -> m a
runReadline Settings m
settings =
  EfflyIO m a -> m a
forall (m :: * -> *) a. EfflyIO m a -> m a
unEfflyIO (EfflyIO m a -> m a)
-> (ReadlineInterruptC m a -> EfflyIO m a)
-> ReadlineInterruptC m a
-> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Settings (EfflyIO m) -> InputT (EfflyIO m) a -> EfflyIO m a
forall (m :: * -> *) a.
(MonadIO m, MonadMask m) =>
Settings m -> InputT m a -> m a
H.runInputT (Settings m -> Settings (EfflyIO m)
coerce Settings m
settings) (InputT (EfflyIO m) a -> EfflyIO m a)
-> (ReadlineInterruptC m a -> InputT (EfflyIO m) a)
-> ReadlineInterruptC m a
-> EfflyIO m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ReadlineT (EfflyIO m) a -> InputT (EfflyIO m) a
forall (m :: * -> *) a. ReadlineT m a -> InputT m a
unReadlineT (ReadlineT (EfflyIO m) a -> InputT (EfflyIO m) a)
-> (ReadlineInterruptC m a -> ReadlineT (EfflyIO m) a)
-> ReadlineInterruptC m a
-> InputT (EfflyIO m) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ReadlineInterruptC m a -> ReadlineT (EfflyIO m) a
forall (m :: * -> *) a.
ReadlineInterruptC m a -> ReadlineT (EfflyIO m) a
unReadlineInterruptC

-- | Like 'runReadline' but additionally allows specifying a 'H.Behavior'.
runReadlineBehavior ::
  (Eff (Embed IO) m, MonadMask m, Carrier m, Threaders '[ReadlineThreads] m p) =>
  H.Behavior ->
  H.Settings m ->
  ReadlineInterruptC m a ->
  m a
runReadlineBehavior :: Behavior -> Settings m -> ReadlineInterruptC m a -> m a
runReadlineBehavior Behavior
behavior Settings m
settings =
  (InputT (EfflyIO m) a -> EfflyIO m a)
-> ReadlineInterruptC m a -> m a
forall (m :: * -> *) a.
(InputT (EfflyIO m) a -> EfflyIO m a)
-> ReadlineInterruptC m a -> m a
runReadlineInterruptC ((InputT (EfflyIO m) a -> EfflyIO m a)
 -> ReadlineInterruptC m a -> m a)
-> (InputT (EfflyIO m) a -> EfflyIO m a)
-> ReadlineInterruptC m a
-> m a
forall a b. (a -> b) -> a -> b
$ Behavior
-> Settings (EfflyIO m) -> InputT (EfflyIO m) a -> EfflyIO m a
forall (m :: * -> *) a.
(MonadIO m, MonadMask m) =>
Behavior -> Settings m -> InputT m a -> m a
H.runInputTBehavior Behavior
behavior (Settings m -> Settings (EfflyIO m)
coerce Settings m
settings)

-- | Like 'runReadline' but additionally allows specifying a 'H.Prefs'.
runReadlineWithPrefs ::
  (Eff (Embed IO) m, MonadMask m, Carrier m, Threaders '[ReadlineThreads] m p) =>
  H.Prefs ->
  H.Settings m ->
  ReadlineInterruptC m a ->
  m a
runReadlineWithPrefs :: Prefs -> Settings m -> ReadlineInterruptC m a -> m a
runReadlineWithPrefs Prefs
prefs Settings m
settings =
  (InputT (EfflyIO m) a -> EfflyIO m a)
-> ReadlineInterruptC m a -> m a
forall (m :: * -> *) a.
(InputT (EfflyIO m) a -> EfflyIO m a)
-> ReadlineInterruptC m a -> m a
runReadlineInterruptC ((InputT (EfflyIO m) a -> EfflyIO m a)
 -> ReadlineInterruptC m a -> m a)
-> (InputT (EfflyIO m) a -> EfflyIO m a)
-> ReadlineInterruptC m a
-> m a
forall a b. (a -> b) -> a -> b
$ Prefs
-> Settings (EfflyIO m) -> InputT (EfflyIO m) a -> EfflyIO m a
forall (m :: * -> *) a.
(MonadIO m, MonadMask m) =>
Prefs -> Settings m -> InputT m a -> m a
H.runInputTWithPrefs Prefs
prefs (Settings m -> Settings (EfflyIO m)
coerce Settings m
settings)

-- | Like 'runReadline' but additionally allows specifying a 'H.Behavior' and a
-- 'H.Prefs'.
runReadlineBehaviorWithPrefs ::
  (Eff (Embed IO) m, MonadMask m, Carrier m, Threaders '[ReadlineThreads] m p) =>
  H.Behavior ->
  H.Prefs ->
  H.Settings m ->
  ReadlineInterruptC m a ->
  m a
runReadlineBehaviorWithPrefs :: Behavior -> Prefs -> Settings m -> ReadlineInterruptC m a -> m a
runReadlineBehaviorWithPrefs Behavior
behavior Prefs
prefs Settings m
settings =
  (InputT (EfflyIO m) a -> EfflyIO m a)
-> ReadlineInterruptC m a -> m a
forall (m :: * -> *) a.
(InputT (EfflyIO m) a -> EfflyIO m a)
-> ReadlineInterruptC m a -> m a
runReadlineInterruptC ((InputT (EfflyIO m) a -> EfflyIO m a)
 -> ReadlineInterruptC m a -> m a)
-> (InputT (EfflyIO m) a -> EfflyIO m a)
-> ReadlineInterruptC m a
-> m a
forall a b. (a -> b) -> a -> b
$ Behavior
-> Prefs
-> Settings (EfflyIO m)
-> InputT (EfflyIO m) a
-> EfflyIO m a
forall (m :: * -> *) a.
(MonadIO m, MonadMask m) =>
Behavior -> Prefs -> Settings m -> InputT m a -> m a
H.runInputTBehaviorWithPrefs Behavior
behavior Prefs
prefs (Settings m -> Settings (EfflyIO m)
coerce Settings m
settings)

-- | Weaker version of 'runReadline' intended for circumstances where the
-- primitive effect 'Optional' can't be threaded. This version is incapable of
-- interpreting 'HandleInterrupt' though.
runReadline' ::
  (Eff (Embed IO) m, MonadMask m, Carrier m, Threaders '[ReadlineThreads] m p) =>
  H.Settings m ->
  ReadlineC m a ->
  m a
runReadline' :: Settings m -> ReadlineC m a -> m a
runReadline' Settings m
settings = (InputT (EfflyIO m) a -> EfflyIO m a) -> ReadlineC m a -> m a
forall (m :: * -> *) a.
(InputT (EfflyIO m) a -> EfflyIO m a) -> ReadlineC m a -> m a
runReadlineC ((InputT (EfflyIO m) a -> EfflyIO m a) -> ReadlineC m a -> m a)
-> (InputT (EfflyIO m) a -> EfflyIO m a) -> ReadlineC m a -> m a
forall a b. (a -> b) -> a -> b
$ Settings (EfflyIO m) -> InputT (EfflyIO m) a -> EfflyIO m a
forall (m :: * -> *) a.
(MonadIO m, MonadMask m) =>
Settings m -> InputT m a -> m a
H.runInputT (Settings m -> Settings (EfflyIO m)
coerce Settings m
settings)

-- | Weaker version of 'runReadlineBehavior' intended for circumstances where
-- the primitive effect 'Optional' can't be threaded. This version is incapable
-- of interpreting 'HandleInterrupt' though.
runReadlineBehavior' ::
  (Eff (Embed IO) m, MonadMask m, Carrier m, Threaders '[ReadlineThreads] m p) =>
  H.Behavior ->
  H.Settings m ->
  ReadlineC m a ->
  m a
runReadlineBehavior' :: Behavior -> Settings m -> ReadlineC m a -> m a
runReadlineBehavior' Behavior
behavior Settings m
settings =
  (InputT (EfflyIO m) a -> EfflyIO m a) -> ReadlineC m a -> m a
forall (m :: * -> *) a.
(InputT (EfflyIO m) a -> EfflyIO m a) -> ReadlineC m a -> m a
runReadlineC ((InputT (EfflyIO m) a -> EfflyIO m a) -> ReadlineC m a -> m a)
-> (InputT (EfflyIO m) a -> EfflyIO m a) -> ReadlineC m a -> m a
forall a b. (a -> b) -> a -> b
$ Behavior
-> Settings (EfflyIO m) -> InputT (EfflyIO m) a -> EfflyIO m a
forall (m :: * -> *) a.
(MonadIO m, MonadMask m) =>
Behavior -> Settings m -> InputT m a -> m a
H.runInputTBehavior Behavior
behavior (Settings m -> Settings (EfflyIO m)
coerce Settings m
settings)

-- | Weaker version of 'runReadlineWithPrefs' intended for circumstances where
-- the primitive effect 'Optional' can't be threaded. This version is incapable
-- of interpreting 'HandleInterrupt' though.
runReadlineWithPrefs' ::
  (Eff (Embed IO) m, MonadMask m, Carrier m, Threaders '[ReadlineThreads] m p) =>
  H.Prefs ->
  H.Settings m ->
  ReadlineC m a ->
  m a
runReadlineWithPrefs' :: Prefs -> Settings m -> ReadlineC m a -> m a
runReadlineWithPrefs' Prefs
prefs Settings m
settings =
  (InputT (EfflyIO m) a -> EfflyIO m a) -> ReadlineC m a -> m a
forall (m :: * -> *) a.
(InputT (EfflyIO m) a -> EfflyIO m a) -> ReadlineC m a -> m a
runReadlineC ((InputT (EfflyIO m) a -> EfflyIO m a) -> ReadlineC m a -> m a)
-> (InputT (EfflyIO m) a -> EfflyIO m a) -> ReadlineC m a -> m a
forall a b. (a -> b) -> a -> b
$ Prefs
-> Settings (EfflyIO m) -> InputT (EfflyIO m) a -> EfflyIO m a
forall (m :: * -> *) a.
(MonadIO m, MonadMask m) =>
Prefs -> Settings m -> InputT m a -> m a
H.runInputTWithPrefs Prefs
prefs (Settings m -> Settings (EfflyIO m)
coerce Settings m
settings)

-- | Weaker version of 'runReadlineBehaviorWithPrefs' intended for
-- circumstances where the primitive effect 'Optional' can't be threaded. This
-- version is incapable of interpreting 'HandleInterrupt' though.
runReadlineBehaviorWithPrefs' ::
  (Eff (Embed IO) m, MonadMask m, Carrier m, Threaders '[ReadlineThreads] m p) =>
  H.Behavior ->
  H.Prefs ->
  H.Settings m ->
  ReadlineC m a ->
  m a
runReadlineBehaviorWithPrefs' :: Behavior -> Prefs -> Settings m -> ReadlineC m a -> m a
runReadlineBehaviorWithPrefs' Behavior
behavior Prefs
prefs Settings m
settings =
  (InputT (EfflyIO m) a -> EfflyIO m a) -> ReadlineC m a -> m a
forall (m :: * -> *) a.
(InputT (EfflyIO m) a -> EfflyIO m a) -> ReadlineC m a -> m a
runReadlineC ((InputT (EfflyIO m) a -> EfflyIO m a) -> ReadlineC m a -> m a)
-> (InputT (EfflyIO m) a -> EfflyIO m a) -> ReadlineC m a -> m a
forall a b. (a -> b) -> a -> b
$ Behavior
-> Prefs
-> Settings (EfflyIO m)
-> InputT (EfflyIO m) a
-> EfflyIO m a
forall (m :: * -> *) a.
(MonadIO m, MonadMask m) =>
Behavior -> Prefs -> Settings m -> InputT m a -> m a
H.runInputTBehaviorWithPrefs Behavior
behavior Prefs
prefs (Settings m -> Settings (EfflyIO m)
coerce Settings m
settings)