Control.Monad.Terminal

Getting started

TerminalT

data TerminalT m a

Instances

MonadTrans TerminalT

Defined in Control.Monad.Terminal.TerminalT

Methods

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

Eq (Annotation (TerminalT m))

Defined in Control.Monad.Terminal.TerminalT

Methods

(==) :: Annotation (TerminalT m) -> Annotation (TerminalT m) -> Bool

(/=) :: Annotation (TerminalT m) -> Annotation (TerminalT m) -> Bool

Monad m => Monad (TerminalT m)

Defined in Control.Monad.Terminal.TerminalT

Methods

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

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

return :: a -> TerminalT m a

fail :: String -> TerminalT m a

Functor m => Functor (TerminalT m)

Defined in Control.Monad.Terminal.TerminalT

Methods

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

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

Ord (Annotation (TerminalT m))

Defined in Control.Monad.Terminal.TerminalT

Methods

compare :: Annotation (TerminalT m) -> Annotation (TerminalT m) -> Ordering

(<) :: Annotation (TerminalT m) -> Annotation (TerminalT m) -> Bool

(<=) :: Annotation (TerminalT m) -> Annotation (TerminalT m) -> Bool

(>) :: Annotation (TerminalT m) -> Annotation (TerminalT m) -> Bool

(>=) :: Annotation (TerminalT m) -> Annotation (TerminalT m) -> Bool

max :: Annotation (TerminalT m) -> Annotation (TerminalT m) -> Annotation (TerminalT m)

min :: Annotation (TerminalT m) -> Annotation (TerminalT m) -> Annotation (TerminalT m)

Show (Annotation (TerminalT m))

Defined in Control.Monad.Terminal.TerminalT

Methods

showsPrec :: Int -> Annotation (TerminalT m) -> ShowS

show :: Annotation (TerminalT m) -> String

showList :: [Annotation (TerminalT m)] -> ShowS

Applicative m => Applicative (TerminalT m)

Defined in Control.Monad.Terminal.TerminalT

Methods

pure :: a -> TerminalT m a

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

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

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

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

MonadIO m => MonadIO (TerminalT m)

Defined in Control.Monad.Terminal.TerminalT

Methods

liftIO :: IO a -> TerminalT m a

MonadThrow m => MonadThrow (TerminalT m)

Defined in Control.Monad.Terminal.TerminalT

Methods

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

MonadCatch m => MonadCatch (TerminalT m)

Defined in Control.Monad.Terminal.TerminalT

Methods

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

MonadMask m => MonadMask (TerminalT m)

Defined in Control.Monad.Terminal.TerminalT

Methods

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

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

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

MonadIO m => MonadInput (TerminalT m)

Defined in Control.Monad.Terminal.TerminalT

Methods

waitMapInterruptAndEvents :: (STM () -> STM Event -> STM a) -> TerminalT m a

(MonadIO m, MonadThrow m) => MonadColorPrinter (TerminalT m)

Defined in Control.Monad.Terminal.TerminalT

Methods

inverted :: Annotation (TerminalT m)

foreground :: Color -> Annotation (TerminalT m)

background :: Color -> Annotation (TerminalT m)

(MonadIO m, MonadThrow m) => MonadFormatPrinter (TerminalT m)

Defined in Control.Monad.Terminal.TerminalT

Methods

bold :: Annotation (TerminalT m)

italic :: Annotation (TerminalT m)

underlined :: Annotation (TerminalT m)

(MonadIO m, MonadThrow m) => MonadPrettyPrinter (TerminalT m)

Defined in Control.Monad.Terminal.TerminalT

Associated Types

data Annotation (TerminalT m) :: Type

Methods

putDoc :: Doc (Annotation (TerminalT m)) -> TerminalT m ()

putDocLn :: Doc (Annotation (TerminalT m)) -> TerminalT m ()

setAnnotation :: Annotation (TerminalT m) -> TerminalT m ()

resetAnnotation :: Annotation (TerminalT m) -> TerminalT m ()

resetAnnotations :: TerminalT m ()

(MonadIO m, MonadThrow m) => MonadPrinter (TerminalT m)

Defined in Control.Monad.Terminal.TerminalT

Methods

putLn :: TerminalT m ()

putChar :: Char -> TerminalT m ()

putString :: String -> TerminalT m ()

putStringLn :: String -> TerminalT m ()

putText :: Text -> TerminalT m ()

putTextLn :: Text -> TerminalT m ()

flush :: TerminalT m ()

getLineWidth :: TerminalT m Int

(MonadIO m, MonadThrow m) => MonadTerminal (TerminalT m)

Defined in Control.Monad.Terminal.TerminalT

Methods

moveCursorUp :: Int -> TerminalT m ()

moveCursorDown :: Int -> TerminalT m ()

moveCursorLeft :: Int -> TerminalT m ()

moveCursorRight :: Int -> TerminalT m ()

getCursorPosition :: TerminalT m (Int, Int)

setCursorPosition :: (Int, Int) -> TerminalT m ()

setCursorPositionVertical :: Int -> TerminalT m ()

setCursorPositionHorizontal :: Int -> TerminalT m ()

saveCursorPosition :: TerminalT m ()

restoreCursorPosition :: TerminalT m ()

showCursor :: TerminalT m ()

hideCursor :: TerminalT m ()

clearLine :: TerminalT m ()

clearLineLeft :: TerminalT m ()

clearLineRight :: TerminalT m ()

clearScreen :: TerminalT m ()

clearScreenAbove :: TerminalT m ()

clearScreenBelow :: TerminalT m ()

getScreenSize :: TerminalT m (Int, Int)

useAlternateScreenBuffer :: Bool -> TerminalT m ()

data Annotation (TerminalT m)

Defined in Control.Monad.Terminal.TerminalT

data Annotation (TerminalT m)

• = Bold
• | Italic
• | Underlined
• | Inverted
• | Foreground Color
• | Background Color

runTerminalT :: (MonadIO m, MonadMask m) => TerminalT m a -> Terminal -> m a

Printing & Screen Modification

MonadPrinter

class Monad m => MonadPrinter m where

This class describes an environment that Unicode text can be printed to. This might either be file or a terminal.

• Instances shall implement the concept of lines and line width.
• Instances shall implement the concept of a carriage that can be set to the beginning of the next line.
• It is assumed that the carriage automatically moves to the beginning of the next line if the end of the current line is reached.
• Instances shall be Unicode aware or must at least be able to print a replacement character.
• Implementations must be aware of infinite lazy Strings and long Texts. Strings should be printed character wise as evaluating them might trigger exceptions at any point. Long text should be printed chunk wise in order to stay interruptible.
• Implementations must not use an unbounded output buffer. Print operations shall block and be interruptible when the output buffer is full.
• Instances shall not interpret any control characters but \n (new line, as generated by putLn, and \t (horizontal tabulator).
• Especially escape sequences shall be filtered or at least defused by removing the leading \ESC. Text formatting shall be done with the designated classes like MonadPrettyPrinter, MonadFormatPrinter and MonadColorPrinter. Allowing control sequences would cause a dependency on certain terminal types, but might also be an underrated security risk as modern terminals are highly programmable and should not be fed with untrusted input.

Minimal complete definition

putChar, getLineWidth

Methods

putLn :: m ()

Move the carriage to the beginning of the next line.

putChar :: Char -> m ()

Print a single printable character or one of the allowed control characters.

putString :: String -> m ()

Print a String.

putStringLn :: String -> m ()

Print a String and an additional newline.

putText :: Text -> m ()

Print a Text.

putTextLn :: Text -> m ()

Print a Text and an additional newline.

flush :: m ()

Flush the output buffer and make the all previous output actually visible after a reasonably short amount of time.

• The operation may return before the buffer has actually been flushed.

getLineWidth :: m Int

Get the current line width.

• The operation may return the last known line width and may not be completely precise when I/O is asynchronous.
• This operations shall not block too long and rather be called more often in order to adapt to changes in line width.

Instances

(MonadIO m, MonadThrow m) => MonadPrinter (TerminalT m)

Defined in Control.Monad.Terminal.TerminalT

Methods

putLn :: TerminalT m ()

putChar :: Char -> TerminalT m ()

putString :: String -> TerminalT m ()

putStringLn :: String -> TerminalT m ()

putText :: Text -> TerminalT m ()

putTextLn :: Text -> TerminalT m ()

flush :: TerminalT m ()

getLineWidth :: TerminalT m Int

MonadPrettyPrinter

class MonadPrinter m => MonadPrettyPrinter m where

This class is the foundation for all environments that allow annotated text and Documents to be printed to.

• Prefer using the Doc module and the putDoc operation whenever trying to print structured or formatted text as it automatically deals with nested annotations and the current line width.

Minimal complete definition

putDoc, setAnnotation, resetAnnotation, resetAnnotations

Associated Types

data Annotation m

This associated type represents all possible annotations that are available in the current environment.

When writing polymorphic code against these monadic interfaces the concrete instantiation of this type is usually unknown and class instances are generally advised to not expose value constructors for this type.

Instead, subclasses like MonadFormatPrinter and MonadColorPrinter offer abstract value constructors like bold, underlined, inverted which are then given meaning by the concrete class instance. The environment AnsiTerminalT for example implements all of these classes.

Methods

putDoc :: Doc (Annotation m) -> m ()

Print an annotated Doc.

• This operation performs resetAnnotations on entry and on exit.
• This operation can deal with nested annotations (see example).

Example:

{--}
import Control.Monad.Terminal
import Data.Text.Prettyprint.Doc

printer :: (MonadFormatPrinter m, MonadColorPrinter m) => m ()
printer = putDoc $ annotate (foreground $ bright Blue) "This is blue!" <> line
                <> annotate bold ("Just bold!" <> otherDoc <> "..just bold again")

otherDoc :: (MonadColorPrinter m, Annotation m ~ ann) => Doc ann
otherDoc = annotate (background $ dull Red) " BOLD ON RED BACKGROUND "

Note the necessary unification of Annotation m and ann in the definition of otherDoc!

putDocLn :: Doc (Annotation m) -> m ()

Like putDoc but adds an additional newline.

setAnnotation :: Annotation m -> m ()

Set an annotation so that it affects subsequent output.

resetAnnotation :: Annotation m -> m ()

Reset an annotation so that it does no longer affect subsequent output.

• Binary attributes like bold or underlined shall just be reset to their opposite.
• For non-binary attributes like colors all of their possible values shall be treated as equal, so that

  setAnnotation (foreground $ bright Blue) >> resetAnnotation (foreground $ dull Red)
  

results in the foreground color attribute reset afterwards whereas after

  setAnnotation (foreground $ bright Blue) >> resetAnnotation (background $ dull Red)
  

the foreground color is still set as bright Blue.

resetAnnotations :: m ()

Reset all annotations to their default.

Instances

(MonadIO m, MonadThrow m) => MonadPrettyPrinter (TerminalT m)

Defined in Control.Monad.Terminal.TerminalT

Associated Types

data Annotation (TerminalT m) :: Type

Methods

putDoc :: Doc (Annotation (TerminalT m)) -> TerminalT m ()

putDocLn :: Doc (Annotation (TerminalT m)) -> TerminalT m ()

setAnnotation :: Annotation (TerminalT m) -> TerminalT m ()

resetAnnotation :: Annotation (TerminalT m) -> TerminalT m ()

resetAnnotations :: TerminalT m ()

pprint :: (MonadPrettyPrinter m, Pretty a) => a -> m ()

MonadFormatPrinter

class MonadPrettyPrinter m => MonadFormatPrinter m where

This class offers abstract constructors for text formatting annotations.

Methods

bold :: Annotation m

This annotation makes text appear bold.

italic :: Annotation m

This annotation makes text appear italic.

underlined :: Annotation m

This annotation makes text appear underlined.

Instances

(MonadIO m, MonadThrow m) => MonadFormatPrinter (TerminalT m)

Defined in Control.Monad.Terminal.TerminalT

Methods

bold :: Annotation (TerminalT m)

italic :: Annotation (TerminalT m)

underlined :: Annotation (TerminalT m)

MonadColorPrinter

class MonadPrettyPrinter m => MonadColorPrinter m where

This class offers abstract value constructors for foreground and background coloring.

Methods

inverted :: Annotation m

This annotation swaps foreground and background color.

• This operation is idempotent: Applying the annotation a second time won't swap it back. Use resetAnnotation instead.

foreground :: Color -> Annotation m

This annotation sets the foreground color (the text color).

background :: Color -> Annotation m

This annotation sets the background color.

Instances

(MonadIO m, MonadThrow m) => MonadColorPrinter (TerminalT m)

Defined in Control.Monad.Terminal.TerminalT

Methods

inverted :: Annotation (TerminalT m)

foreground :: Color -> Annotation (TerminalT m)

background :: Color -> Annotation (TerminalT m)

dull :: BasicColor -> Color

bright :: BasicColor -> Color

data BasicColor

Constructors

Black

Red

Green

Yellow

Blue

Magenta

Cyan

White

Instances

Eq BasicColor

Defined in Control.Monad.Terminal.Printer

Methods

(==) :: BasicColor -> BasicColor -> Bool

(/=) :: BasicColor -> BasicColor -> Bool

Ord BasicColor

Defined in Control.Monad.Terminal.Printer

Methods

compare :: BasicColor -> BasicColor -> Ordering

(<) :: BasicColor -> BasicColor -> Bool

(<=) :: BasicColor -> BasicColor -> Bool

(>) :: BasicColor -> BasicColor -> Bool

(>=) :: BasicColor -> BasicColor -> Bool

max :: BasicColor -> BasicColor -> BasicColor

min :: BasicColor -> BasicColor -> BasicColor

Show BasicColor

Defined in Control.Monad.Terminal.Printer

Methods

showsPrec :: Int -> BasicColor -> ShowS

show :: BasicColor -> String

showList :: [BasicColor] -> ShowS

data Color

Constructors

Color ColorMode BasicColor

Instances

Eq Color

Defined in Control.Monad.Terminal.Printer

Methods

(==) :: Color -> Color -> Bool

(/=) :: Color -> Color -> Bool

Ord Color

Defined in Control.Monad.Terminal.Printer

Methods

compare :: Color -> Color -> Ordering

(<) :: Color -> Color -> Bool

(<=) :: Color -> Color -> Bool

(>) :: Color -> Color -> Bool

(>=) :: Color -> Color -> Bool

max :: Color -> Color -> Color

min :: Color -> Color -> Color

Show Color

Defined in Control.Monad.Terminal.Printer

Methods

showsPrec :: Int -> Color -> ShowS

show :: Color -> String

showList :: [Color] -> ShowS

data ColorMode

Constructors

Dull

Bright

Instances

Eq ColorMode

Defined in Control.Monad.Terminal.Printer

Methods

(==) :: ColorMode -> ColorMode -> Bool

(/=) :: ColorMode -> ColorMode -> Bool

Ord ColorMode

Defined in Control.Monad.Terminal.Printer

Methods

compare :: ColorMode -> ColorMode -> Ordering

(<) :: ColorMode -> ColorMode -> Bool

(<=) :: ColorMode -> ColorMode -> Bool

(>) :: ColorMode -> ColorMode -> Bool

(>=) :: ColorMode -> ColorMode -> Bool

max :: ColorMode -> ColorMode -> ColorMode

min :: ColorMode -> ColorMode -> ColorMode

Show ColorMode

Defined in Control.Monad.Terminal.Printer

Methods

showsPrec :: Int -> ColorMode -> ShowS

show :: ColorMode -> String

showList :: [ColorMode] -> ShowS

MonadTerminal

class (MonadInput m, MonadPrettyPrinter m, MonadFormatPrinter m, MonadColorPrinter m) => MonadTerminal m where

Methods

moveCursorUp :: Int -> m ()

Move the cursor n lines up. Do not change column.

moveCursorDown :: Int -> m ()

Move the cursor n lines down. Do not change column.

moveCursorLeft :: Int -> m ()

Move the cursor n columns to the left. Do not change line.

moveCursorRight :: Int -> m ()

Move the cursor n columns to the right. Do not change line.

getCursorPosition :: m (Int, Int)

Get the current cursor position. `(0,0) is the upper left of the screen.

setCursorPosition :: (Int, Int) -> m ()

Set the cursor position. `(0,0)` is the upper left of the screen.

setCursorPositionVertical :: Int -> m ()

Set the vertical cursor position to the nth line. Do not change column.

setCursorPositionHorizontal :: Int -> m ()

Set the horizontal cursor position to the nth column. Do not change line.

saveCursorPosition :: m ()

Save the current cursor position to be restored later by restoreCursorPosition.

restoreCursorPosition :: m ()

Restore cursor to position previously saved by saveCursorPosition.

showCursor :: m ()

Show the cursor.

hideCursor :: m ()

Hide the cursor.

clearLine :: m ()

Clear the entire line containing the cursor.

clearLineLeft :: m ()

Clear the line from cursor left.

clearLineRight :: m ()

Clear the line from cursor right.

clearScreen :: m ()

Clear the entire screen.

clearScreenAbove :: m ()

Clear the screen above the cursor.

clearScreenBelow :: m ()

Clear the screen below the cursor.

getScreenSize :: m (Int, Int)

useAlternateScreenBuffer :: Bool -> m ()

Whether or not to use the alternate screen buffer.

• The main screen buffer content is preserved and restored when leaving the alternate screen screen buffer.
• The dimensions of the alternate screen buffer are exactly those of the screen.

Instances

(MonadIO m, MonadThrow m) => MonadTerminal (TerminalT m)

Defined in Control.Monad.Terminal.TerminalT

Methods

moveCursorUp :: Int -> TerminalT m ()

moveCursorDown :: Int -> TerminalT m ()

moveCursorLeft :: Int -> TerminalT m ()

moveCursorRight :: Int -> TerminalT m ()

getCursorPosition :: TerminalT m (Int, Int)

setCursorPosition :: (Int, Int) -> TerminalT m ()

setCursorPositionVertical :: Int -> TerminalT m ()

setCursorPositionHorizontal :: Int -> TerminalT m ()

saveCursorPosition :: TerminalT m ()

restoreCursorPosition :: TerminalT m ()

showCursor :: TerminalT m ()

hideCursor :: TerminalT m ()

clearLine :: TerminalT m ()

clearLineLeft :: TerminalT m ()

clearLineRight :: TerminalT m ()

clearScreen :: TerminalT m ()

clearScreenAbove :: TerminalT m ()

clearScreenBelow :: TerminalT m ()

getScreenSize :: TerminalT m (Int, Int)

useAlternateScreenBuffer :: Bool -> TerminalT m ()

Event Processing

MonadInput

class MonadIO m => MonadInput m where

This monad describes an environment that maintains a stream of Events and offers out-of-band signaling for interrupts.

• An interrupt shall occur if the user either presses CTRL+C or any other mechanism the environment designates for that purpose.
• Implementations shall maintain an interrupt flag that is set when an interrupt occurs. Computations in this monad shall check and reset this flag regularly. If the execution environment finds this flag still set when trying to signal another interrupt, it shall throw UserInterrupt to the seemingly unresponsive computation.
• When an interrupt is signaled through the flag, an InterruptEvent must be added to the event stream in the same transaction. This allows to flush all unprocessed events from the stream that occured before the interrupt.

Methods

waitMapInterruptAndEvents :: (STM () -> STM Event -> STM a) -> m a

Wait for the next interrupt or the next event transformed by a given mapper.

• The first mapper parameter is a transaction that succeeds as soon as the interrupt flag gets set. Executing this transaction resets the interrupt flag. If the interrupt flag is not reset before a second interrupt occurs, the current thread shall receive an UserInterrupt.
• The second mapper parameter is a transaction that succeeds as as soon as the next event arrives and removes that event from the stream of events. It may be executed several times within the same transaction, but might not succeed every time.

Instances

MonadIO m => MonadInput (TerminalT m)

Defined in Control.Monad.Terminal.TerminalT

Methods

waitMapInterruptAndEvents :: (STM () -> STM Event -> STM a) -> TerminalT m a

waitEvent

waitEvent :: MonadInput m => m Event

Wait for the next event.

• Returns as soon as an event occurs.
• This operation resets the interrupt flag it returns, signaling responsiveness to the execution environment.
• InterruptEvents occur in the event stream at their correct position wrt to ordering of events. They are returned as regular events. This is eventually not desired when trying to handle interrupts with highest priority and waitInterruptOrElse should be considered then.

waitEventOrElse

waitEventOrElse :: MonadInput m => STM a -> m (Either Event a)

Wait simultaneously for the next event or a given transaction.

• Returns as soon as either an event occurs or the given transaction succeeds.
• This operation resets the interrupt flag whenever it returns, signaling responsiveness to the execution environment.
• InterruptEvents occur in the event stream at their correct position wrt to ordering of events. They are returned as regular events. This is eventually not desired when trying to handle interrupts with highest priority and waitInterruptOrElse should be considered then.

waitInterruptOrElse

waitInterruptOrElse :: MonadInput m => STM a -> m (Maybe a)

Wait simultaneously for the next interrupt or a given transaction.

• Returns Nothing on interrupt and Just when the supplied transaction succeeds first.
• This operation resets the interrupt flag, signaling responsiveness to the execution environment.
• All pending events up to and including the InterruptEvent are flushed from the event stream in case of an interrupt.

Events

data Event

Constructors

KeyEvent Key Modifiers

MouseEvent MouseEvent

WindowEvent WindowEvent

DeviceEvent DeviceEvent

InterruptEvent

OtherEvent String

Instances

Eq Event

Defined in Control.Monad.Terminal.Input

Methods

(==) :: Event -> Event -> Bool

(/=) :: Event -> Event -> Bool

Ord Event

Defined in Control.Monad.Terminal.Input

Methods

compare :: Event -> Event -> Ordering

(<) :: Event -> Event -> Bool

(<=) :: Event -> Event -> Bool

(>) :: Event -> Event -> Bool

(>=) :: Event -> Event -> Bool

max :: Event -> Event -> Event

min :: Event -> Event -> Event

Show Event

Defined in Control.Monad.Terminal.Input

Methods

showsPrec :: Int -> Event -> ShowS

show :: Event -> String

showList :: [Event] -> ShowS

Keys & Modifiers

data Key

Constructors

CharKey Char

TabKey

SpaceKey

BackspaceKey

EnterKey

InsertKey

DeleteKey

HomeKey

Pos 1

BeginKey

EndKey

PageUpKey

PageDownKey

EscapeKey

PrintKey

PauseKey

ArrowKey Direction

FunctionKey Int

Instances

Eq Key

Defined in Control.Monad.Terminal.Input

Methods

(==) :: Key -> Key -> Bool

(/=) :: Key -> Key -> Bool

Ord Key

Defined in Control.Monad.Terminal.Input

Methods

compare :: Key -> Key -> Ordering

(<) :: Key -> Key -> Bool

(<=) :: Key -> Key -> Bool

(>) :: Key -> Key -> Bool

(>=) :: Key -> Key -> Bool

max :: Key -> Key -> Key

min :: Key -> Key -> Key

Show Key

Defined in Control.Monad.Terminal.Input

Methods

showsPrec :: Int -> Key -> ShowS

show :: Key -> String

showList :: [Key] -> ShowS

data Direction

Constructors

Upwards

Downwards

Leftwards

Rightwards

Instances

Eq Direction

Defined in Control.Monad.Terminal.Input

Methods

(==) :: Direction -> Direction -> Bool

(/=) :: Direction -> Direction -> Bool

Ord Direction

Defined in Control.Monad.Terminal.Input

Methods

compare :: Direction -> Direction -> Ordering

(<) :: Direction -> Direction -> Bool

(<=) :: Direction -> Direction -> Bool

(>) :: Direction -> Direction -> Bool

(>=) :: Direction -> Direction -> Bool

max :: Direction -> Direction -> Direction

min :: Direction -> Direction -> Direction

Show Direction

Defined in Control.Monad.Terminal.Input

Methods

showsPrec :: Int -> Direction -> ShowS

show :: Direction -> String

showList :: [Direction] -> ShowS

data Modifiers

Instances

Eq Modifiers

Defined in Control.Monad.Terminal.Input

Methods

(==) :: Modifiers -> Modifiers -> Bool

(/=) :: Modifiers -> Modifiers -> Bool

Ord Modifiers

Defined in Control.Monad.Terminal.Input

Methods

compare :: Modifiers -> Modifiers -> Ordering

(<) :: Modifiers -> Modifiers -> Bool

(<=) :: Modifiers -> Modifiers -> Bool

(>) :: Modifiers -> Modifiers -> Bool

(>=) :: Modifiers -> Modifiers -> Bool

max :: Modifiers -> Modifiers -> Modifiers

min :: Modifiers -> Modifiers -> Modifiers

Show Modifiers

Defined in Control.Monad.Terminal.Input

Methods

showsPrec :: Int -> Modifiers -> ShowS

show :: Modifiers -> String

showList :: [Modifiers] -> ShowS

Semigroup Modifiers

Defined in Control.Monad.Terminal.Input

Methods

(<>) :: Modifiers -> Modifiers -> Modifiers

sconcat :: NonEmpty Modifiers -> Modifiers

stimes :: Integral b => b -> Modifiers -> Modifiers

Monoid Modifiers

Defined in Control.Monad.Terminal.Input

Methods

mempty :: Modifiers

mappend :: Modifiers -> Modifiers -> Modifiers

mconcat :: [Modifiers] -> Modifiers

Bits Modifiers

Defined in Control.Monad.Terminal.Input

Methods

(.&.) :: Modifiers -> Modifiers -> Modifiers

(.|.) :: Modifiers -> Modifiers -> Modifiers

xor :: Modifiers -> Modifiers -> Modifiers

complement :: Modifiers -> Modifiers

shift :: Modifiers -> Int -> Modifiers

rotate :: Modifiers -> Int -> Modifiers

zeroBits :: Modifiers

bit :: Int -> Modifiers

setBit :: Modifiers -> Int -> Modifiers

clearBit :: Modifiers -> Int -> Modifiers

complementBit :: Modifiers -> Int -> Modifiers

testBit :: Modifiers -> Int -> Bool

bitSizeMaybe :: Modifiers -> Maybe Int

bitSize :: Modifiers -> Int

isSigned :: Modifiers -> Bool

shiftL :: Modifiers -> Int -> Modifiers

unsafeShiftL :: Modifiers -> Int -> Modifiers

shiftR :: Modifiers -> Int -> Modifiers

unsafeShiftR :: Modifiers -> Int -> Modifiers

rotateL :: Modifiers -> Int -> Modifiers

rotateR :: Modifiers -> Int -> Modifiers

popCount :: Modifiers -> Int

shiftKey :: Modifiers

ctrlKey :: Modifiers

altKey :: Modifiers

metaKey :: Modifiers

Mouse Events

data MouseEvent

Constructors

MouseMoved (Int, Int)

MouseButtonPressed (Int, Int) MouseButton

MouseButtonReleased (Int, Int) MouseButton

MouseButtonClicked (Int, Int) MouseButton

MouseWheeled (Int, Int) Direction

Instances

Eq MouseEvent

Defined in Control.Monad.Terminal.Input

Methods

(==) :: MouseEvent -> MouseEvent -> Bool

(/=) :: MouseEvent -> MouseEvent -> Bool

Ord MouseEvent

Defined in Control.Monad.Terminal.Input

Methods

compare :: MouseEvent -> MouseEvent -> Ordering

(<) :: MouseEvent -> MouseEvent -> Bool

(<=) :: MouseEvent -> MouseEvent -> Bool

(>) :: MouseEvent -> MouseEvent -> Bool

(>=) :: MouseEvent -> MouseEvent -> Bool

max :: MouseEvent -> MouseEvent -> MouseEvent

min :: MouseEvent -> MouseEvent -> MouseEvent

Show MouseEvent

Defined in Control.Monad.Terminal.Input

Methods

showsPrec :: Int -> MouseEvent -> ShowS

show :: MouseEvent -> String

showList :: [MouseEvent] -> ShowS

data MouseButton

Constructors

LeftMouseButton

RightMouseButton

OtherMouseButton

Instances

Eq MouseButton

Defined in Control.Monad.Terminal.Input

Methods

(==) :: MouseButton -> MouseButton -> Bool

(/=) :: MouseButton -> MouseButton -> Bool

Ord MouseButton

Defined in Control.Monad.Terminal.Input

Methods

compare :: MouseButton -> MouseButton -> Ordering

(<) :: MouseButton -> MouseButton -> Bool

(<=) :: MouseButton -> MouseButton -> Bool

(>) :: MouseButton -> MouseButton -> Bool

(>=) :: MouseButton -> MouseButton -> Bool

max :: MouseButton -> MouseButton -> MouseButton

min :: MouseButton -> MouseButton -> MouseButton

Show MouseButton

Defined in Control.Monad.Terminal.Input

Methods

showsPrec :: Int -> MouseButton -> ShowS

show :: MouseButton -> String

showList :: [MouseButton] -> ShowS

Window Events

data WindowEvent

Constructors

WindowLostFocus

WindowGainedFocus

WindowSizeChanged (Int, Int)

Instances

Eq WindowEvent

Defined in Control.Monad.Terminal.Input

Methods

(==) :: WindowEvent -> WindowEvent -> Bool

(/=) :: WindowEvent -> WindowEvent -> Bool

Ord WindowEvent

Defined in Control.Monad.Terminal.Input

Methods

compare :: WindowEvent -> WindowEvent -> Ordering

(<) :: WindowEvent -> WindowEvent -> Bool

(<=) :: WindowEvent -> WindowEvent -> Bool

(>) :: WindowEvent -> WindowEvent -> Bool

(>=) :: WindowEvent -> WindowEvent -> Bool

max :: WindowEvent -> WindowEvent -> WindowEvent

min :: WindowEvent -> WindowEvent -> WindowEvent

Show WindowEvent

Defined in Control.Monad.Terminal.Input

Methods

showsPrec :: Int -> WindowEvent -> ShowS

show :: WindowEvent -> String

showList :: [WindowEvent] -> ShowS

Device Events

data DeviceEvent

Constructors

DeviceAttributesReport String

CursorPositionReport (Int, Int)

Instances

Eq DeviceEvent

Defined in Control.Monad.Terminal.Input

Methods

(==) :: DeviceEvent -> DeviceEvent -> Bool

(/=) :: DeviceEvent -> DeviceEvent -> Bool

Ord DeviceEvent

Defined in Control.Monad.Terminal.Input

Methods

compare :: DeviceEvent -> DeviceEvent -> Ordering

(<) :: DeviceEvent -> DeviceEvent -> Bool

(<=) :: DeviceEvent -> DeviceEvent -> Bool

(>) :: DeviceEvent -> DeviceEvent -> Bool

(>=) :: DeviceEvent -> DeviceEvent -> Bool

max :: DeviceEvent -> DeviceEvent -> DeviceEvent

min :: DeviceEvent -> DeviceEvent -> DeviceEvent

Show DeviceEvent

Defined in Control.Monad.Terminal.Input

Methods

showsPrec :: Int -> DeviceEvent -> ShowS

show :: DeviceEvent -> String

showList :: [DeviceEvent] -> ShowS

Low-Level

Terminal

data Terminal

Constructors

Terminal

Fields

• termType :: ByteString

  The terminal identification string usually extracted from the environment variable TERM. Should contain values like xterm or `rxvt-unicode`.

• termInput :: STM Event

  A stream of input events. The transaction will succeed as soon as the next input event becomes available.

  Note: Trying to read more than one event within the same transaction might be successfull, but might also lead to undesired behaviour as the transaction will block until all of its preconditions are fulfilled. Some form of orElse needs to be used in a correct way for reading several events at once.

• termOutput :: Text -> STM ()

  This transaction appends a piece of Text to the output buffer. It shall block when the buffer exeeded its capacity and unblock as soon as space becomes available again.

  Note: All implementations must limit the size of the output buffer or the application is at risk of running out of memory when writing much faster than the terminal can read. Using a TMVar as a buffer of size 1 is perfectly fine here.

• termInterrupt :: STM ()

  This transaction succeeds as soon as an interrupt event occurs. Executing the transaction shall reset an interrupt flag maintained by a supervising background thread.

  It is mandatory to regularly check this transaction in order to signal responsiveness to the background thread. The supervisor is otherwise advised to terminate the program as soon as a second interrupt arrives.

  Note: This is a very low-level operation. Operations like waitEvent, waitEventOrElse or waitInterruptOrElse are more convenient and do this automatically.

• termFlush :: STM ()

  This operations flushes the output buffer. Whether it blocks or not until the buffer has actually been flushed shall be undefined (there might be other buffers involved that cannot be force-flushed so it is probably better to not give any guarantees here).

• termScreenSize :: STM (Int, Int)

  This transaction shall return the latest known screen size without blocking. The first parameter denotes the number of rows and the one the number of columns.

• termSpecialChars :: Char -> Maybe Event

Decoding

newtype Decoder

The type Decoder represents a finite state transducer.

Values of this type can only be constructed by tying the knot which causes the resulting transducer to have one entry point but no exits. Intermediate state can be passed as closures. See below for an example.

Constructors

Decoder

Fields

• feedDecoder :: Modifiers -> Char -> ([Event], Decoder)

ansiDecoder :: (Char -> Maybe Event) -> Decoder