Text.Chatty.Printer

Provides a typeclass for all monads that may print text.

Documentation

class Monad m => ChPrinter m where

A typeclass for all monads that may output strings.

Minimal complete definition

mprint

Methods

mprint :: String -> m ()

Just print it!

mnoecho :: String -> m ()

Print it, except you are IO.

mflush :: m ()

Flush the buffer.

mnomask :: String -> m ()

Alternative to mprint that does not mask any characters (depends on the carrier).

Instances

ChPrinter IO

Monad m => ChPrinter (RecorderT m)

MonadIO m => ChPrinter (OutRedirT m)

Monad m => ChPrinter (DeafT m)

ChPrinter m => ChPrinter (JoinerT m)

ChAtoms m => ChPrinter (FilePrinterT m)

ChPrinter m => ChPrinter (HtmlPrinterT m)

ChPrinter m => ChPrinter (AnsiPrinterT m)

(Eq c, ChPrinter m) => ChPrinter (FilterT c m)

(Eq c, Monad m) => ChPrinter (ArchiverT c m)

newtype DeafT m a

DeafT discards all output (much like >/dev/null in the shell)

Constructors

Deaf

Fields

runDeafT :: m a

Instances

MonadTrans DeafT

RedirectionTarget DiscardO DeafT a a

Monad m => Monad (DeafT m)

Functor m => Functor (DeafT m)

(Functor m, Monad m) => Applicative (DeafT m)

MonadIO m => MonadIO (DeafT m)

Monad m => ChPrinter (DeafT m)

newtype OutRedirT m a

Redirects all output to a given handle (much like >filename in the shell)

Constructors

OutRedir

Fields

runOutRedirT :: Handle -> m a

Instances

MonadTrans OutRedirT

RedirectionTarget Handle OutRedirT a a

RedirectionTarget FilePath OutRedirT a a

Monad m => Monad (OutRedirT m)

Monad m => Functor (OutRedirT m)

Monad m => Applicative (OutRedirT m)

MonadIO m => MonadIO (OutRedirT m)

MonadIO m => ChPrinter (OutRedirT m)

type OutRedir = OutRedirT IO

OutRedirT on a blank IO monad

runOutRedir :: OutRedir a -> Handle -> IO a

Run OutRedir with a Handle

runOutRedirFT :: (Functor m, MonadIO m) => OutRedirT m a -> FilePath -> IOMode -> m a

Run OutRedirT with a FilePath

runOutRedirF :: OutRedir a -> FilePath -> IOMode -> IO a

Run OutRedir with a FilePath

newtype RecorderT m a

Catches all output (much like VAR=$(...) in the shell)

Constructors

Recorder

Fields

runRecorderT' :: m (a, [String])

Instances

MonadTrans RecorderT

RedirectionTarget RecordO RecorderT a (a, Replayable)

Monad m => Monad (RecorderT m)

Monad m => Functor (RecorderT m)

Monad m => Applicative (RecorderT m)

MonadIO m => MonadIO (RecorderT m)

Monad m => ChPrinter (RecorderT m)

type Recorder = RecorderT Identity

RecorderT on the Identity

newtype Replayable

The recorder state. Use this together with replay, replayM or replay_.

Constructors

Replayable [String]

Instances

Show Replayable

RedirectionTarget RecordO RecorderT a (a, Replayable)

replay :: Replayable -> String

Replay a recorder state in a pure context.

runRecorder :: Recorder a -> (a, Replayable)

Run Recorder and also return its state.

runRecorderT :: (Functor m, Monad m) => RecorderT m a -> m (a, Replayable)

Run RecorderT and also return its state.

mprintLn :: ChPrinter m => String -> m ()

Line-terminating alternative to mprint

mnomaskLn :: ChPrinter m => String -> m ()

Line-terminating alternative to mnomask

data DiscardO

Redirection target that discards input.

Constructors

DiscardO

Instances

RedirectionTarget DiscardO DeafT a a

data RecordO

Redirection target that records input.

Constructors

RecordO

Instances

RedirectionTarget RecordO RecorderT a (a, Replayable)

class RedirectionTarget t mt a r | t -> mt, t a -> r where

Class for all redirection targets.

Minimal complete definition

(.>.)

Methods

(.>.) :: (Functor m, MonadIO m, ChPrinter (mt m)) => mt m a -> t -> m r

Overwriting redirection.

(.>>.) :: (Functor m, MonadIO m, ChPrinter (mt m)) => mt m a -> t -> m r

Appending redirection.

Instances

RedirectionTarget Handle OutRedirT a a

RedirectionTarget FilePath OutRedirT a a

RedirectionTarget DiscardO DeafT a a

RedirectionTarget RecordO RecorderT a (a, Replayable)