HORIZON HASKELLDocslts/ghc-9.10.xc74966e2026-09-27Search names, modules, packages, or :: a typeCtrl K

GHC 9.10.3 · lts/ghc-9.10.x · c74966e · 2026-09-27

Modulehaskeline-0.8.2.1Haskell98

System.Console.Haskeline

A rich user interface for line input in command-line programs. Haskeline is Unicode-aware and runs both on POSIX-compatible systems and on Windows.

Users may customize the interface with a ~/.haskeline file; see https://github.com/judah/haskeline/wiki/UserPreferences for more information.

An example use of this library for a simple read-eval-print loop (REPL) is the following:

import System.Console.Haskeline

main :: IO ()
main = runInputT defaultSettings loop
   where
       loop :: InputT IO ()
       loop = do
           minput <- getInputLine "% "
           case minput of
               Nothing -> return ()
               Just "quit" -> return ()
               Just input -> do outputStrLn $ "Input was: " ++ input
                                loop
  • 5 types
  • 28 values
  • Packagehaskeline-0.8.2.1
  • Exports33
  • LanguageHaskell98
  • LicenceBSD-3-Clause
  • SourceHaskeline.hs

Interactive sessions

0 declarations

The InputT monad transformer

newtypenewtype InputT (m :: Type -> Type) a
#

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

Instances10MonadTrans, Monad, Functor, MonadFix, MonadFail, Applicative, …
valuerunInputT :: (MonadIO m, MonadMask m) => Settings m -> InputT m a -> m a
#

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.

valuemapInputT :: (forall b. m b -> m b) -> InputT m a -> InputT m a
#

Map a user interaction by modifying the base monad computation.

Behaviors

datadata Behavior
#

Haskeline has two ways of interacting with the user:

  • "Terminal-style" interaction provides an rich user interface by connecting to the user's terminal (which may be different than stdin or stdout).

  • "File-style" interaction treats the input as a simple stream of characters, for example when reading from a file or pipe. Input functions (e.g., getInputLine) print the prompt to stdout.

A Behavior is a method for deciding at run-time which type of interaction to use.

For most applications (e.g., a REPL), defaultBehavior should have the correct effect.

valuerunInputTBehavior
  1. :: (MonadIO m, MonadMask m)
  2. => Behavior
  3. -> Settings m
  4. -> InputT m a
  5. -> m a
#

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.

valuedefaultBehavior :: Behavior
#

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.

valuepreferTerm :: Behavior
#

Use terminal-style interaction whenever possible, even if stdin and/or stdout are not terminals.

If it cannot open the user's terminal, use file-style interaction, reading input from stdin.

User interaction functions

0 declarations

Reading user input

The following functions read one line or character of input from the user.

They return Nothing if they encounter the end of input. More specifically:

  • When using terminal-style interaction, they return Nothing if the user pressed Ctrl-D when the input text was empty.

  • When using file-style interaction, they return Nothing if an EOF was encountered before any characters were read.

valuegetInputLine
  1. :: (MonadIO m, MonadMask m)
  2. => String

    The input prompt

  3. -> InputT 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.

valuegetInputLineWithInitial
  1. :: (MonadIO m, MonadMask m)
  2. => String

    The input prompt

  3. -> (String, String)

    The initial value left and right of the cursor

  4. -> InputT 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.
valuegetInputChar
  1. :: (MonadIO m, MonadMask m)
  2. => String

    The input prompt

  3. -> InputT 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.

valuegetPassword
  1. :: (MonadIO m, MonadMask m)
  2. => Maybe Char

    A masking character; e.g., Just '*'

  3. -> String
  4. -> InputT 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).

valuewaitForAnyKey
  1. :: (MonadIO m, MonadMask m)
  2. => String

    The input prompt

  3. -> InputT 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.

Outputting text

The following functions enable cross-platform output of text that may contain Unicode characters.

valuegetExternalPrint :: MonadIO m => InputT m (String -> IO ())
#

Return a printing function, which in terminal-style interactions is thread-safe and may be run concurrently with user input without affecting the prompt.

Customization

0 declarations

Settings

datadata Settings (m :: Type -> Type)
#

Application-specific customizations to the user interface.

Constructors

Instances1CommandMonad
  • (MonadIO m, MonadMask m) => CommandMonad (InputCmdT m)Defined in haskeline-0.8.2.1 · System.Console.Haskeline.InputT
valuedefaultSettings :: MonadIO m => Settings m
#

A useful default. In particular:

defaultSettings = Settings {
          complete = completeFilename,
          historyFile = Nothing,
          autoAddHistory = True
          }
valuesetComplete :: CompletionFunc m -> Settings m -> Settings m
#

Because complete is the only field of Settings depending on m, the expression defaultSettings {completionFunc = f} leads to a type error from being too general. This function works around that issue, and may become unnecessary if another field depending on m is added.

User preferences

datadata Prefs
#

Prefs allow the user to customize the terminal-style line-editing interface. They are read by default from ~/.haskeline; to override that behavior, use readPrefs and runInputTWithPrefs.

Each line of a .haskeline file defines one field of the Prefs datatype; field names are case-insensitive and unparseable lines are ignored. For example:

editMode: Vi
completionType: MenuCompletion
maxhistorysize: Just 40
Instances2Show, CommandMonad
  • Show PrefsDefined in haskeline-0.8.2.1 · System.Console.Haskeline.Prefs
  • (MonadIO m, MonadMask m) => CommandMonad (InputCmdT m)Defined in haskeline-0.8.2.1 · System.Console.Haskeline.InputT
valuedefaultPrefs :: Prefs
#

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

valuewithRunInBase
  1. :: Monad m
  2. => (forall a. InputT m a -> m a) -> m b
  3. -> InputT m b
#

Run an action in the underlying monad, as per lift, passing it a runner function which restores the current InputT context. This can be used in the event that we have some function that takes an action in the underlying monad as an argument (such as lift, hoist, forkIO, etc) and we want to compose it with actions in InputT.

History

The InputT monad transformer provides direct, low-level access to the user's line history state.

However, for most applications, it should suffice to just use the autoAddHistory and historyFile flags.

Ctrl-C handling

3 declarations
valuewithInterrupt :: (MonadIO m, MonadMask m) => InputT m a -> InputT m a
#

If Ctrl-C is pressed during the given action, throw an exception of type Interrupt. For example:

tryAction :: InputT IO ()
tryAction = handle (\Interrupt -> outputStrLn "Cancelled.")
               $ withInterrupt $ someLongAction

The action can handle the interrupt itself; a new Interrupt exception will be thrown every time Ctrl-C is pressed.

tryAction :: InputT IO ()
tryAction = withInterrupt loop
    where loop = handle (\Interrupt -> outputStrLn "Cancelled; try again." >> loop)
                   someLongAction

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.

Additional submodules

0 declarations

module System.Console.Haskeline.Completion