Safe Haskell	None
Language	GHC2021

Effectful.Haskeline.Static

Contents

Effect
- Handlers
Reader
Haskeline Re-exports

Description

Provides a static effect for haskeline.

Since: 0.1

Synopsis

data Haskeline (a :: Type -> Type) b
haveTerminalUI :: forall (es :: [Effect]). (HasCallStack, Haskeline :> es, Reader (InputTEnv IO) :> es) => Eff es Bool
getInputLine :: forall (es :: [Effect]). (HasCallStack, Haskeline :> es, Reader (InputTEnv IO) :> es) => String -> Eff es (Maybe String)
getInputLineWithInitial :: forall (es :: [Effect]). (HasCallStack, Haskeline :> es, Reader (InputTEnv IO) :> es) => String -> (String, String) -> Eff es (Maybe String)
getInputChar :: forall (es :: [Effect]). (HasCallStack, Haskeline :> es, Reader (InputTEnv IO) :> es) => String -> Eff es (Maybe Char)
getPassword :: forall (es :: [Effect]). (HasCallStack, Haskeline :> es, Reader (InputTEnv IO) :> es) => Maybe Char -> String -> Eff es (Maybe String)
waitForAnyKey :: forall (es :: [Effect]). (HasCallStack, Haskeline :> es, Reader (InputTEnv IO) :> es) => String -> Eff es Bool
outputStr :: forall (es :: [Effect]). (HasCallStack, Haskeline :> es, Reader (InputTEnv IO) :> es) => String -> Eff es ()
outputStrLn :: forall (es :: [Effect]). (HasCallStack, Haskeline :> es, Reader (InputTEnv IO) :> es) => String -> Eff es ()
getHistory :: forall (es :: [Effect]). (HasCallStack, Haskeline :> es, Reader (InputTEnv IO) :> es) => Eff es History
putHistory :: forall (es :: [Effect]). (HasCallStack, Haskeline :> es, Reader (InputTEnv IO) :> es) => History -> Eff es ()
modifyHistory :: forall (es :: [Effect]). (HasCallStack, Haskeline :> es, Reader (InputTEnv IO) :> es) => (History -> History) -> Eff es ()
withInterrupt :: forall (es :: [Effect]) a. (HasCallStack, Haskeline :> es, Reader (InputTEnv IO) :> es) => Eff es a -> Eff es a
handleInterrupt :: forall (es :: [Effect]) a. (HasCallStack, Haskeline :> es, Reader (InputTEnv IO) :> es) => Eff es a -> Eff es a -> Eff es a
runHaskeline :: forall (es :: [Effect]) a. (HasCallStack, IOE :> es) => Eff (Haskeline ': es) a -> Eff es a
runEffInputTEnv :: forall (m :: Type -> Type) a. HasCallStack => InputTEnv m -> Eff '[Reader (InputTEnv m), IOE] a -> IO a
runInputTEnv :: (HasCallStack, MonadIO m, MonadMask m) => (InputTEnv m -> m a) -> m a
runInputTEnvWith :: HasCallStack => (InputT m a -> m a) -> (InputTEnv m -> m a) -> m a
data InputT (m :: Type -> Type) a
data InputTEnv (m :: Type -> Type)
runInputT :: (MonadIO m, MonadMask m) => Settings m -> InputT m a -> m a
runInputTBehavior :: (MonadIO m, MonadMask m) => Behavior -> Settings m -> InputT m a -> m a
runInputTBehaviorWithPrefs :: (MonadIO m, MonadMask m) => Behavior -> Prefs -> Settings m -> InputT m a -> m a
defaultSettings :: forall (m :: Type -> Type). MonadIO m => Settings m
defaultBehavior :: Behavior
defaultPrefs :: Prefs

Effect

data Haskeline (a :: Type -> Type) b Source #

Static haskeline effect.

Since: 0.1

Instances

Instances details

type DispatchOf Haskeline Source #
Instance details Defined in Effectful.Haskeline.Static type DispatchOf Haskeline = 'Static 'WithSideEffects
data StaticRep Haskeline Source #
Instance details Defined in Effectful.Haskeline.Static data StaticRep Haskeline = MkHaskeline

haveTerminalUI :: forall (es :: [Effect]). (HasCallStack, Haskeline :> es, Reader (InputTEnv IO) :> es) => Eff es Bool Source #

Lifted haveTerminalUI.

Since: 0.1

getInputLine :: forall (es :: [Effect]). (HasCallStack, Haskeline :> es, Reader (InputTEnv IO) :> es) => String -> Eff es (Maybe String) Source #

Lifted getInputLine.

Since: 0.1

getInputLineWithInitial :: forall (es :: [Effect]). (HasCallStack, Haskeline :> es, Reader (InputTEnv IO) :> es) => String -> (String, String) -> Eff es (Maybe String) Source #

Lifted getInputLineWithInitial.

Since: 0.1

getInputChar :: forall (es :: [Effect]). (HasCallStack, Haskeline :> es, Reader (InputTEnv IO) :> es) => String -> Eff es (Maybe Char) Source #

Lifted getInputChar.

Since: 0.1

getPassword :: forall (es :: [Effect]). (HasCallStack, Haskeline :> es, Reader (InputTEnv IO) :> es) => Maybe Char -> String -> Eff es (Maybe String) Source #

Lifted getPassword.

Since: 0.1

waitForAnyKey :: forall (es :: [Effect]). (HasCallStack, Haskeline :> es, Reader (InputTEnv IO) :> es) => String -> Eff es Bool Source #

Lifted waitForAnyKey.

Since: 0.1

outputStr :: forall (es :: [Effect]). (HasCallStack, Haskeline :> es, Reader (InputTEnv IO) :> es) => String -> Eff es () Source #

Lifted outputStr.

Since: 0.1

outputStrLn :: forall (es :: [Effect]). (HasCallStack, Haskeline :> es, Reader (InputTEnv IO) :> es) => String -> Eff es () Source #

Lifted outputStrLn.

Since: 0.1

getHistory :: forall (es :: [Effect]). (HasCallStack, Haskeline :> es, Reader (InputTEnv IO) :> es) => Eff es History Source #

Lifted getHistory.

Since: 0.1

putHistory :: forall (es :: [Effect]). (HasCallStack, Haskeline :> es, Reader (InputTEnv IO) :> es) => History -> Eff es () Source #

Lifted putHistory.

Since: 0.1

modifyHistory :: forall (es :: [Effect]). (HasCallStack, Haskeline :> es, Reader (InputTEnv IO) :> es) => (History -> History) -> Eff es () Source #

Lifted modifyHistory.

Since: 0.1

withInterrupt :: forall (es :: [Effect]) a. (HasCallStack, Haskeline :> es, Reader (InputTEnv IO) :> es) => Eff es a -> Eff es a Source #

Lifted withInterrupt.

Since: 0.1

handleInterrupt :: forall (es :: [Effect]) a. (HasCallStack, Haskeline :> es, Reader (InputTEnv IO) :> es) => Eff es a -> Eff es a -> Eff es a Source #

Lifted handleInterrupt.

Since: 0.1

Handlers

runHaskeline :: forall (es :: [Effect]) a. (HasCallStack, IOE :> es) => Eff (Haskeline ': es) a -> Eff es a Source #

Runs Haskeline in IO.

Since: 0.1

Reader

These functions allow eliminating the Haskeline effect in terms of ReaderT.

Examples:

 app :: (Haskeline :> es, Reader (InputTEnv IO) :> es) => Eff es String
 app = do
   mLine <- getInputLine "Enter your name: "
   let name = fromMaybe "<blank>" mLine
   outputStrLn $ "Hello: " ++ name
   pure name

 appIO :: IO String
 appIO = do
   runInputTEnv
     $ env -> runEffInputTEnv env
     $ runHaskeline app

runEffInputTEnv Source #

Arguments

:: forall (m :: Type -> Type) a. HasCallStack
=> InputTEnv m	The `InputT` environment.
-> Eff '[Reader (InputTEnv m), IOE] a	Eff action that requires the `InputTEnv` environment.
-> IO a	IO result.

Runner for Eff with InputTEnv. Intended for usage with runInputTEnv or runInputTEnvWith.

Since: 0.1

runInputTEnv Source #

Arguments

:: (HasCallStack, MonadIO m, MonadMask m)
=> (InputTEnv m -> m a)	Action.
-> m a	IO result.

runInputTEnvWith with default haskeline settings.

Examples:

-- eff :: Eff [Reader (InputTEnv m), IOE] a
runInputTEnv $ env -> runEffInputTEnv env eff

Since: 0.1

runInputTEnvWith Source #

Arguments

:: HasCallStack
=> (InputT m a -> m a)	`InputT` runner.
-> (InputTEnv m -> m a)	Action.
-> m a	IO result.

Runs ReaderT InputTEnv in IO with InputT runner.

Examples:

-- eff :: Eff [Reader (InputTEnv m), IOE] a
runInputTEnvWith runInput $ env -> runEffInputTEnv env eff

Since: 0.1

Haskeline Re-exports

Types

data InputT (m :: Type -> Type) a Source #

A monad transformer which carries all of the state and settings relevant to a line-reading application.

Instances

Instances details

MonadTrans InputT Source #
Instance details Defined in System.Console.Haskeline.InputT Methods lift :: Monad m => m a -> InputT m a #
MonadCatch m => MonadCatch (InputT m) Source #
Instance details Defined in System.Console.Haskeline.InputT Methods catch :: (HasCallStack, Exception e) => InputT m a -> (e -> InputT m a) -> InputT m a #
MonadMask m => MonadMask (InputT m) Source #
Instance details Defined in System.Console.Haskeline.InputT Methods mask :: HasCallStack => ((forall a. InputT m a -> InputT m a) -> InputT m b) -> InputT m b # uninterruptibleMask :: HasCallStack => ((forall a. InputT m a -> InputT m a) -> InputT m b) -> InputT m b # generalBracket :: HasCallStack => InputT m a -> (a -> ExitCase b -> InputT m c) -> (a -> InputT m b) -> InputT m (b, c) #
MonadThrow m => MonadThrow (InputT m) Source #
Instance details Defined in System.Console.Haskeline.InputT Methods throwM :: (HasCallStack, Exception e) => e -> InputT m a #
Applicative m => Applicative (InputT m) Source #
Instance details Defined in System.Console.Haskeline.InputT Methods pure :: a -> InputT m a # (<>) :: InputT m (a -> b) -> InputT m a -> InputT m b # liftA2 :: (a -> b -> c) -> InputT m a -> InputT m b -> InputT m c # (>) :: InputT m a -> InputT m b -> InputT m b # (<*) :: InputT m a -> InputT m b -> InputT m a #
Functor m => Functor (InputT m) Source #
Instance details Defined in System.Console.Haskeline.InputT Methods fmap :: (a -> b) -> InputT m a -> InputT m b # (<$) :: a -> InputT m b -> InputT m a #
Monad m => Monad (InputT m) Source #
Instance details Defined in System.Console.Haskeline.InputT Methods (>>=) :: InputT m a -> (a -> InputT m b) -> InputT m b # (>>) :: InputT m a -> InputT m b -> InputT m b # return :: a -> InputT m a #
MonadFail m => MonadFail (InputT m) Source #
Instance details Defined in System.Console.Haskeline.InputT Methods fail :: String -> InputT m a #
MonadFix m => MonadFix (InputT m) Source #
Instance details Defined in System.Console.Haskeline.InputT Methods mfix :: (a -> InputT m a) -> InputT m a #
MonadIO m => MonadIO (InputT m) Source #
Instance details Defined in System.Console.Haskeline.InputT Methods liftIO :: IO a -> InputT m a #

data InputTEnv (m :: Type -> Type) Source #

The abstract environment used by InputT, for ReaderT usage.

Since: haskeline-0.8.4.0

IO Runners

runInputT :: (MonadIO m, MonadMask m) => Settings m -> InputT m a -> m a Source #

Run a line-reading application. This function should suffice for most applications.

This function is equivalent to runInputTBehavior defaultBehavior. It uses terminal-style interaction if stdin is connected to a terminal and has echoing enabled. Otherwise (e.g., if stdin is a pipe), it uses file-style interaction.

If it uses terminal-style interaction, Prefs will be read from the user's ~/.haskeline file (if present). If it uses file-style interaction, Prefs are not relevant and will not be read.

runInputTBehavior :: (MonadIO m, MonadMask m) => Behavior -> Settings m -> InputT m a -> m a Source #

Run a line-reading application according to the given behavior.

If it uses terminal-style interaction, Prefs will be read from the user's ~/.haskeline file (if present). If it uses file-style interaction, Prefs are not relevant and will not be read.

runInputTBehaviorWithPrefs :: (MonadIO m, MonadMask m) => Behavior -> Prefs -> Settings m -> InputT m a -> m a Source #

Run a line-reading application.

Config

defaultSettings :: forall (m :: Type -> Type). MonadIO m => Settings m Source #

A useful default. In particular:

defaultSettings = Settings {
          complete = completeFilename,
          historyFile = Nothing,
          autoAddHistory = True
          }

defaultBehavior :: Behavior Source #

Read input from stdin. Use terminal-style interaction if stdin is connected to a terminal and has echoing enabled. Otherwise (e.g., if stdin is a pipe), use file-style interaction.

This behavior should suffice for most applications.

defaultPrefs :: Prefs Source #

The default preferences which may be overwritten in the .haskeline file.