Control.Effect.Readline.Internal

__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.

Documentation

data Readline :: Effect where

Constructors

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 ()

getInputLine :: Eff Readline m => String -> m (Maybe String)

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 autoAddHistory == True and the line input is nonblank (i.e., is not all spaces), it will be automatically added to the history.

getInputLineWithInitial :: Eff Readline m => String -> (String, String) -> m (Maybe String)

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 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 Strings. 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.

getInputChar :: Eff Readline m => String -> m (Maybe Char)

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.

getPassword :: Eff Readline m => Maybe Char -> String -> m (Maybe String)

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).

waitForAnyKey :: Eff Readline m => String -> m Bool

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.

outputStr :: Eff Readline m => String -> m ()

Write a Unicode string to the user's standard output.

outputStrLn :: Eff Readline m => String -> m ()

Write a Unicode string to the user's standard output, followed by a newline.

data HandleInterrupt :: Effect where

Constructors

WithInterrupt :: m a -> HandleInterrupt m a

HandleInterrupt :: m a -> m a -> HandleInterrupt m a

Instances

Functor a => Functor (HandleInterrupt a)

Defined in Control.Effect.Readline.Internal

Methods

fmap :: (a0 -> b) -> HandleInterrupt a a0 -> HandleInterrupt a b

(<$) :: a0 -> HandleInterrupt a b -> HandleInterrupt a a0

withInterrupt :: Eff HandleInterrupt m => m a -> 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.

handleInterrupt :: Eff HandleInterrupt m => m a -> m a -> m a

Handle an Interrupt. When an interrupt occurs in the second argument, the first argument will be called.

catchInterrupt :: Eff HandleInterrupt m => m a -> m a -> m a

Specify a continuation that should be called when an Interrupt occurs.

catchInterrupt = flip handleInterrupt

data ReadlineHistory :: Effect where

Constructors

GetHistory :: ReadlineHistory m History

PutHistory :: History -> ReadlineHistory m ()

getHistory :: Eff ReadlineHistory m => m History

Get the History.

putHistory :: Eff ReadlineHistory m => History -> m ()

Set the History.

modifyHistory :: Eff ReadlineHistory m => (History -> History) -> m ()

Modify the History. The modification is not atomic.

newtype EfflyIO m a

newtype that provides MonadIO when Eff (Embed IO) m and otherwise just passes through instances to the base monad

Constructors

EfflyIO

Fields

• unEfflyIO :: m a

Instances

MonadTrans EfflyIO

Defined in Control.Effect.Readline.Internal

Methods

lift :: Monad m => m a -> EfflyIO m a

MonadTransControl EfflyIO

Defined in Control.Effect.Readline.Internal

Associated Types

type StT EfflyIO a

Methods

liftWith :: Monad m => (Run EfflyIO -> m a) -> EfflyIO m a

restoreT :: Monad m => m (StT EfflyIO a) -> EfflyIO m a

MonadBaseControl b m => MonadBaseControl b (EfflyIO m)

Defined in Control.Effect.Readline.Internal

Associated Types

type StM (EfflyIO m) a

Methods

liftBaseWith :: (RunInBase (EfflyIO m) b -> b a) -> EfflyIO m a

restoreM :: StM (EfflyIO m) a -> EfflyIO m a

MonadBase b m => MonadBase b (EfflyIO m)

Defined in Control.Effect.Readline.Internal

Methods

liftBase :: b α -> EfflyIO m α

Monad m => Monad (EfflyIO m)

Defined in Control.Effect.Readline.Internal

Methods

(>>=) :: EfflyIO m a -> (a -> EfflyIO m b) -> EfflyIO m b

(>>) :: EfflyIO m a -> EfflyIO m b -> EfflyIO m b

return :: a -> EfflyIO m a

Functor m => Functor (EfflyIO m)

Defined in Control.Effect.Readline.Internal

Methods

fmap :: (a -> b) -> EfflyIO m a -> EfflyIO m b

(<$) :: a -> EfflyIO m b -> EfflyIO m a

MonadFix m => MonadFix (EfflyIO m)

Defined in Control.Effect.Readline.Internal

Methods

mfix :: (a -> EfflyIO m a) -> EfflyIO m a

MonadFail m => MonadFail (EfflyIO m)

Defined in Control.Effect.Readline.Internal

Methods

fail :: String -> EfflyIO m a

Applicative m => Applicative (EfflyIO m)

Defined in Control.Effect.Readline.Internal

Methods

pure :: a -> EfflyIO m a

(<*>) :: EfflyIO m (a -> b) -> EfflyIO m a -> EfflyIO m b

liftA2 :: (a -> b -> c) -> EfflyIO m a -> EfflyIO m b -> EfflyIO m c

(*>) :: EfflyIO m a -> EfflyIO m b -> EfflyIO m b

(<*) :: EfflyIO m a -> EfflyIO m b -> EfflyIO m a

Eff (Embed IO) m => MonadIO (EfflyIO m)

Defined in Control.Effect.Readline.Internal

Methods

liftIO :: IO a -> EfflyIO m a

MonadThrow m => MonadThrow (EfflyIO m)

Defined in Control.Effect.Readline.Internal

Methods

throwM :: Exception e => e -> EfflyIO m a

MonadCatch m => MonadCatch (EfflyIO m)

Defined in Control.Effect.Readline.Internal

Methods

catch :: Exception e => EfflyIO m a -> (e -> EfflyIO m a) -> EfflyIO m a

MonadMask m => MonadMask (EfflyIO m)

Defined in Control.Effect.Readline.Internal

Methods

mask :: ((forall a. EfflyIO m a -> EfflyIO m a) -> EfflyIO m b) -> EfflyIO m b

uninterruptibleMask :: ((forall a. EfflyIO m a -> EfflyIO m a) -> EfflyIO m b) -> EfflyIO m b

generalBracket :: EfflyIO m a -> (a -> ExitCase b -> EfflyIO m c) -> (a -> EfflyIO m b) -> EfflyIO m (b, c)

type StT EfflyIO a

Defined in Control.Effect.Readline.Internal

type StT EfflyIO a = StT (IdentityT :: (Type -> Type) -> Type -> Type) a

type StM (EfflyIO m) a

Defined in Control.Effect.Readline.Internal

type StM (EfflyIO m) a = StM m a

newtype ReadlineT m a

Version of InputT that we "own" so that we can define new instances on it, in particular threading constraints without creating orphan instances.

Constructors

ReadlineT

Fields

• unReadlineT :: InputT m a

Instances

MonadTrans ReadlineT

Defined in Control.Effect.Readline.Internal

Methods

lift :: Monad m => m a -> ReadlineT m a

ThreadsEff ReadlineT Split

Defined in Control.Effect.Readline.Internal

Methods

threadEff :: Monad m => (forall x. Split m x -> m x) -> Split (ReadlineT m) a -> ReadlineT m a

ThreadsEff ReadlineT Mask

Defined in Control.Effect.Readline.Internal

Methods

threadEff :: Monad m => (forall x. Mask m x -> m x) -> Mask (ReadlineT m) a -> ReadlineT m a

ThreadsEff ReadlineT Fix

Defined in Control.Effect.Readline.Internal

Methods

threadEff :: Monad m => (forall x. Fix m x -> m x) -> Fix (ReadlineT m) a -> ReadlineT m a

ThreadsEff ReadlineT Bracket

Defined in Control.Effect.Readline.Internal

Methods

threadEff :: Monad m => (forall x. Bracket m x -> m x) -> Bracket (ReadlineT m) a -> ReadlineT m a

Monoid o => ThreadsEff ReadlineT (WriterPrim o)

Defined in Control.Effect.Readline.Internal

Methods

threadEff :: Monad m => (forall x. WriterPrim o m x -> m x) -> WriterPrim o (ReadlineT m) a -> ReadlineT m a

ThreadsEff ReadlineT (Unravel p)

Defined in Control.Effect.Readline.Internal

Methods

threadEff :: Monad m => (forall x. Unravel p m x -> m x) -> Unravel p (ReadlineT m) a -> ReadlineT m a

ThreadsEff ReadlineT (Unlift b)

Defined in Control.Effect.Readline.Internal

Methods

threadEff :: Monad m => (forall x. Unlift b m x -> m x) -> Unlift b (ReadlineT m) a -> ReadlineT m a

ThreadsEff ReadlineT (BaseControl b)

Defined in Control.Effect.Readline.Internal

Methods

threadEff :: Monad m => (forall x. BaseControl b m x -> m x) -> BaseControl b (ReadlineT m) a -> ReadlineT m a

Functor s => ThreadsEff ReadlineT (Optional s)

Defined in Control.Effect.Readline.Internal

Methods

threadEff :: Monad m => (forall x. Optional s m x -> m x) -> Optional s (ReadlineT m) a -> ReadlineT m a

ThreadsEff ReadlineT (ReaderPrim i)

Defined in Control.Effect.Readline.Internal

Methods

threadEff :: Monad m => (forall x. ReaderPrim i m x -> m x) -> ReaderPrim i (ReadlineT m) a -> ReadlineT m a

ThreadsEff ReadlineT (Regional s)

Defined in Control.Effect.Readline.Internal

Methods

threadEff :: Monad m => (forall x. Regional s m x -> m x) -> Regional s (ReadlineT m) a -> ReadlineT m a

Monoid o => ThreadsEff ReadlineT (ListenPrim o)

Defined in Control.Effect.Readline.Internal

Methods

threadEff :: Monad m => (forall x. ListenPrim o m x -> m x) -> ListenPrim o (ReadlineT m) a -> ReadlineT m a

MonadBaseControl b m => MonadBaseControl b (ReadlineT m)

Defined in Control.Effect.Readline.Internal

Associated Types

type StM (ReadlineT m) a

Methods

liftBaseWith :: (RunInBase (ReadlineT m) b -> b a) -> ReadlineT m a

restoreM :: StM (ReadlineT m) a -> ReadlineT m a

MonadBase b m => MonadBase b (ReadlineT m)

Defined in Control.Effect.Readline.Internal

Methods

liftBase :: b α -> ReadlineT m α

Monad m => Monad (ReadlineT m)

Defined in Control.Effect.Readline.Internal

Methods

(>>=) :: ReadlineT m a -> (a -> ReadlineT m b) -> ReadlineT m b

(>>) :: ReadlineT m a -> ReadlineT m b -> ReadlineT m b

return :: a -> ReadlineT m a

Functor m => Functor (ReadlineT m)

Defined in Control.Effect.Readline.Internal

Methods

fmap :: (a -> b) -> ReadlineT m a -> ReadlineT m b

(<$) :: a -> ReadlineT m b -> ReadlineT m a

MonadFix m => MonadFix (ReadlineT m)

Defined in Control.Effect.Readline.Internal

Methods

mfix :: (a -> ReadlineT m a) -> ReadlineT m a

MonadFail m => MonadFail (ReadlineT m)

Defined in Control.Effect.Readline.Internal

Methods

fail :: String -> ReadlineT m a

Applicative m => Applicative (ReadlineT m)

Defined in Control.Effect.Readline.Internal

Methods

pure :: a -> ReadlineT m a

(<*>) :: ReadlineT m (a -> b) -> ReadlineT m a -> ReadlineT m b

liftA2 :: (a -> b -> c) -> ReadlineT m a -> ReadlineT m b -> ReadlineT m c

(*>) :: ReadlineT m a -> ReadlineT m b -> ReadlineT m b

(<*) :: ReadlineT m a -> ReadlineT m b -> ReadlineT m a

MonadIO m => MonadIO (ReadlineT m)

Defined in Control.Effect.Readline.Internal

Methods

liftIO :: IO a -> ReadlineT m a

MonadThrow m => MonadThrow (ReadlineT m)

Defined in Control.Effect.Readline.Internal

Methods

throwM :: Exception e => e -> ReadlineT m a

MonadCatch m => MonadCatch (ReadlineT m)

Defined in Control.Effect.Readline.Internal

Methods

catch :: Exception e => ReadlineT m a -> (e -> ReadlineT m a) -> ReadlineT m a

MonadMask m => MonadMask (ReadlineT m)

Defined in Control.Effect.Readline.Internal

Methods

mask :: ((forall a. ReadlineT m a -> ReadlineT m a) -> ReadlineT m b) -> ReadlineT m b

uninterruptibleMask :: ((forall a. ReadlineT m a -> ReadlineT m a) -> ReadlineT m b) -> ReadlineT m b

generalBracket :: ReadlineT m a -> (a -> ExitCase b -> ReadlineT m c) -> (a -> ReadlineT m b) -> ReadlineT m (b, c)

type StM (ReadlineT m) a

Defined in Control.Effect.Readline.Internal

type StM (ReadlineT m) a = StM m a

class Threads ReadlineT p => ReadlineThreads p

Threading constraint for handlers using InputT/ReadlineT internally.

ReadlineThreads accepts all the primitive effects (intended to be used as such) offered by in-other-words.

Most notably, ReadlineThreads accepts Unlift b.

Instances

Threads ReadlineT p => ReadlineThreads p

Defined in Control.Effect.Readline.Internal

newtype ReadlineC m a

Constructors

ReadlineC

Fields

• unReadlineC :: ReadlineT (EfflyIO m) a

Instances

MonadTrans ReadlineC

Defined in Control.Effect.Readline.Internal

Methods

lift :: Monad m => m a -> ReadlineC m a

MonadBaseControl b m => MonadBaseControl b (ReadlineC m)

Defined in Control.Effect.Readline.Internal

Associated Types

type StM (ReadlineC m) a

Methods

liftBaseWith :: (RunInBase (ReadlineC m) b -> b a) -> ReadlineC m a

restoreM :: StM (ReadlineC m) a -> ReadlineC m a

MonadBase b m => MonadBase b (ReadlineC m)

Defined in Control.Effect.Readline.Internal

Methods

liftBase :: b α -> ReadlineC m α

Monad m => Monad (ReadlineC m)

Defined in Control.Effect.Readline.Internal

Methods

(>>=) :: ReadlineC m a -> (a -> ReadlineC m b) -> ReadlineC m b

(>>) :: ReadlineC m a -> ReadlineC m b -> ReadlineC m b

return :: a -> ReadlineC m a

Functor m => Functor (ReadlineC m)

Defined in Control.Effect.Readline.Internal

Methods

fmap :: (a -> b) -> ReadlineC m a -> ReadlineC m b

(<$) :: a -> ReadlineC m b -> ReadlineC m a

MonadFix m => MonadFix (ReadlineC m)

Defined in Control.Effect.Readline.Internal

Methods

mfix :: (a -> ReadlineC m a) -> ReadlineC m a

MonadFail m => MonadFail (ReadlineC m)

Defined in Control.Effect.Readline.Internal

Methods

fail :: String -> ReadlineC m a

Applicative m => Applicative (ReadlineC m)

Defined in Control.Effect.Readline.Internal

Methods

pure :: a -> ReadlineC m a

(<*>) :: ReadlineC m (a -> b) -> ReadlineC m a -> ReadlineC m b

liftA2 :: (a -> b -> c) -> ReadlineC m a -> ReadlineC m b -> ReadlineC m c

(*>) :: ReadlineC m a -> ReadlineC m b -> ReadlineC m b

(<*) :: ReadlineC m a -> ReadlineC m b -> ReadlineC m a

Eff (Embed IO) m => MonadIO (ReadlineC m)

Defined in Control.Effect.Readline.Internal

Methods

liftIO :: IO a -> ReadlineC m a

MonadThrow m => MonadThrow (ReadlineC m)

Defined in Control.Effect.Readline.Internal

Methods

throwM :: Exception e => e -> ReadlineC m a

MonadCatch m => MonadCatch (ReadlineC m)

Defined in Control.Effect.Readline.Internal

Methods

catch :: Exception e => ReadlineC m a -> (e -> ReadlineC m a) -> ReadlineC m a

MonadMask m => MonadMask (ReadlineC m)

Defined in Control.Effect.Readline.Internal

Methods

mask :: ((forall a. ReadlineC m a -> ReadlineC m a) -> ReadlineC m b) -> ReadlineC m b

uninterruptibleMask :: ((forall a. ReadlineC m a -> ReadlineC m a) -> ReadlineC m b) -> ReadlineC m b

generalBracket :: ReadlineC m a -> (a -> ExitCase b -> ReadlineC m c) -> (a -> ReadlineC m b) -> ReadlineC m (b, c)

(Carrier m, Eff (Embed IO) m, MonadMask m, Threads ReadlineT (Prims m)) => Carrier (ReadlineC m)

Defined in Control.Effect.Readline.Internal

Associated Types

type Derivs (ReadlineC m) :: [Effect]

type Prims (ReadlineC m) :: [Effect]

Methods

algPrims :: Algebra' (Prims (ReadlineC m)) (ReadlineC m) a

reformulate :: Monad z => Reformulation' (Derivs (ReadlineC m)) (Prims (ReadlineC m)) (ReadlineC m) z a

algDerivs :: Algebra' (Derivs (ReadlineC m)) (ReadlineC m) a

type Prims (ReadlineC m)

Defined in Control.Effect.Readline.Internal

type Prims (ReadlineC m) = Prims m

type Derivs (ReadlineC m)

Defined in Control.Effect.Readline.Internal

type Derivs (ReadlineC m) = Readline ': (ReadlineHistory ': Derivs m)

type StM (ReadlineC m) a

Defined in Control.Effect.Readline.Internal

type StM (ReadlineC m) a = StM (ReadlineT (EfflyIO m)) a

readlineC :: InputT (EfflyIO m) a -> ReadlineC m a

runReadlineC :: (InputT (EfflyIO m) a -> EfflyIO m a) -> ReadlineC m a -> m a

newtype ReadlineInterruptC m a

Constructors

ReadlineInterruptC

Fields

• unReadlineInterruptC :: ReadlineT (EfflyIO m) a

Instances

MonadTrans ReadlineInterruptC

Defined in Control.Effect.Readline.Internal

Methods

lift :: Monad m => m a -> ReadlineInterruptC m a

MonadBaseControl b m => MonadBaseControl b (ReadlineInterruptC m)

Defined in Control.Effect.Readline.Internal

Associated Types

type StM (ReadlineInterruptC m) a

Methods

liftBaseWith :: (RunInBase (ReadlineInterruptC m) b -> b a) -> ReadlineInterruptC m a

restoreM :: StM (ReadlineInterruptC m) a -> ReadlineInterruptC m a

MonadBase b m => MonadBase b (ReadlineInterruptC m)

Defined in Control.Effect.Readline.Internal

Methods

liftBase :: b α -> ReadlineInterruptC m α

Monad m => Monad (ReadlineInterruptC m)

Defined in Control.Effect.Readline.Internal

Methods

(>>=) :: ReadlineInterruptC m a -> (a -> ReadlineInterruptC m b) -> ReadlineInterruptC m b

(>>) :: ReadlineInterruptC m a -> ReadlineInterruptC m b -> ReadlineInterruptC m b

return :: a -> ReadlineInterruptC m a

Functor m => Functor (ReadlineInterruptC m)

Defined in Control.Effect.Readline.Internal

Methods

fmap :: (a -> b) -> ReadlineInterruptC m a -> ReadlineInterruptC m b

(<$) :: a -> ReadlineInterruptC m b -> ReadlineInterruptC m a

MonadFix m => MonadFix (ReadlineInterruptC m)

Defined in Control.Effect.Readline.Internal

Methods

mfix :: (a -> ReadlineInterruptC m a) -> ReadlineInterruptC m a

MonadFail m => MonadFail (ReadlineInterruptC m)

Defined in Control.Effect.Readline.Internal

Methods

fail :: String -> ReadlineInterruptC m a

Applicative m => Applicative (ReadlineInterruptC m)

Defined in Control.Effect.Readline.Internal

Methods

pure :: a -> ReadlineInterruptC m a

(<*>) :: ReadlineInterruptC m (a -> b) -> ReadlineInterruptC m a -> ReadlineInterruptC m b

liftA2 :: (a -> b -> c) -> ReadlineInterruptC m a -> ReadlineInterruptC m b -> ReadlineInterruptC m c

(*>) :: ReadlineInterruptC m a -> ReadlineInterruptC m b -> ReadlineInterruptC m b

(<*) :: ReadlineInterruptC m a -> ReadlineInterruptC m b -> ReadlineInterruptC m a

Eff (Embed IO) m => MonadIO (ReadlineInterruptC m)

Defined in Control.Effect.Readline.Internal

Methods

liftIO :: IO a -> ReadlineInterruptC m a

MonadThrow m => MonadThrow (ReadlineInterruptC m)

Defined in Control.Effect.Readline.Internal

Methods

throwM :: Exception e => e -> ReadlineInterruptC m a

MonadCatch m => MonadCatch (ReadlineInterruptC m)

Defined in Control.Effect.Readline.Internal

Methods

catch :: Exception e => ReadlineInterruptC m a -> (e -> ReadlineInterruptC m a) -> ReadlineInterruptC m a

MonadMask m => MonadMask (ReadlineInterruptC m)

Defined in Control.Effect.Readline.Internal

Methods

mask :: ((forall a. ReadlineInterruptC m a -> ReadlineInterruptC m a) -> ReadlineInterruptC m b) -> ReadlineInterruptC m b

uninterruptibleMask :: ((forall a. ReadlineInterruptC m a -> ReadlineInterruptC m a) -> ReadlineInterruptC m b) -> ReadlineInterruptC m b

generalBracket :: ReadlineInterruptC m a -> (a -> ExitCase b -> ReadlineInterruptC m c) -> (a -> ReadlineInterruptC m b) -> ReadlineInterruptC m (b, c)

(Carrier m, Eff (Embed IO) m, MonadMask m, Threads ReadlineT (Prims m)) => Carrier (ReadlineInterruptC m)

Defined in Control.Effect.Readline.Internal

Associated Types

type Derivs (ReadlineInterruptC m) :: [Effect]

type Prims (ReadlineInterruptC m) :: [Effect]

Methods

algPrims :: Algebra' (Prims (ReadlineInterruptC m)) (ReadlineInterruptC m) a

reformulate :: Monad z => Reformulation' (Derivs (ReadlineInterruptC m)) (Prims (ReadlineInterruptC m)) (ReadlineInterruptC m) z a

algDerivs :: Algebra' (Derivs (ReadlineInterruptC m)) (ReadlineInterruptC m) a

type Prims (ReadlineInterruptC m)

Defined in Control.Effect.Readline.Internal

type Prims (ReadlineInterruptC m) = Optional WithOrHandleInterrupt ': Prims (ReadlineC m)

type Derivs (ReadlineInterruptC m)

Defined in Control.Effect.Readline.Internal

type Derivs (ReadlineInterruptC m) = HandleInterrupt ': Derivs (ReadlineC m)

type StM (ReadlineInterruptC m) a

Defined in Control.Effect.Readline.Internal

type StM (ReadlineInterruptC m) a = StM (ReadlineT (EfflyIO m)) a

readlineInterruptC :: InputT (EfflyIO m) a -> ReadlineInterruptC m a

runReadlineInterruptC :: (InputT (EfflyIO m) a -> EfflyIO m a) -> ReadlineInterruptC m a -> m a

data WithOrHandleInterrupt a

Type for denoting which kind of Optional we are inside of.

Constructors

WithInterrupts

OnInterruptContinueWith a

runReadline :: (Eff (Embed IO) m, MonadMask m, Carrier m, Threaders '[ReadlineThreads] m p) => Settings m -> ReadlineInterruptC m a -> m a

Main interpreter for Readline, ReadlineHistory, and HandleInterrupt effects. 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

runReadlineBehavior :: (Eff (Embed IO) m, MonadMask m, Carrier m, Threaders '[ReadlineThreads] m p) => Behavior -> Settings m -> ReadlineInterruptC m a -> m a

Like runReadline but additionally allows specifying a Behavior.

runReadlineWithPrefs :: (Eff (Embed IO) m, MonadMask m, Carrier m, Threaders '[ReadlineThreads] m p) => Prefs -> Settings m -> ReadlineInterruptC m a -> m a

Like runReadline but additionally allows specifying a Prefs.

runReadlineBehaviorWithPrefs :: (Eff (Embed IO) m, MonadMask m, Carrier m, Threaders '[ReadlineThreads] m p) => Behavior -> Prefs -> Settings m -> ReadlineInterruptC m a -> m a

Like runReadline but additionally allows specifying a Behavior and a Prefs.

runReadline' :: (Eff (Embed IO) m, MonadMask m, Carrier m, Threaders '[ReadlineThreads] m p) => Settings m -> ReadlineC m a -> m a

Weaker version of runReadline 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) => Behavior -> Settings m -> ReadlineC m a -> m a

Weaker version of runReadlineBehavior 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) => Prefs -> Settings m -> ReadlineC m a -> m a

Weaker version of runReadlineWithPrefs 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) => Behavior -> Prefs -> Settings m -> ReadlineC m a -> m a

Weaker version of runReadlineBehaviorWithPrefs intended for circumstances where the primitive effect Optional can't be threaded. This version is incapable of interpreting HandleInterrupt though.