chatty 0.5.5.1 → 0.6

raw patch · 22 files changed

+142/−356 lines, 22 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

• System/Chatty/Commands.hs +9/−9
• System/Chatty/Misc.hs +4/−4
• System/Chatty/Spawn.hs +3/−3
• System/Chatty/Spawn/Builtins.hs +2/−2
• System/Chatty/Spawn/Overlay.hs +1/−1
• Text/Chatty/Channel/Broadcast.hs +2/−2
• Text/Chatty/Channel/Printer.hs +8/−8
• Text/Chatty/Expansion.hs +2/−2
• Text/Chatty/Expansion/History.hs +4/−4
• Text/Chatty/Expansion/Vars.hs +6/−6
• Text/Chatty/Extended/ANSI.hs +5/−5
• Text/Chatty/Extended/HTML.hs +5/−5
• Text/Chatty/Extended/Printer.hs +3/−3
• Text/Chatty/Finalizer.hs +2/−3
• Text/Chatty/Interactor/Templates.hs +25/−25
• Text/Chatty/Parser.hs +0/−92
• Text/Chatty/Parser/Nondeterministic.hs +0/−81
• Text/Chatty/Printer.hs +12/−10
• Text/Chatty/Scanner.hs +17/−15
• Text/Chatty/Scanner/Buffered.hs +27/−12
• Text/Chatty/Typograph.hs +0/−60
• chatty.cabal +5/−4

@@ -37,32 +37,32 @@ import System.Posix.Files  -- | Like 'cat' on the command line. Accepts a list of filenames. Simple pass-through, if none are provided.-cat :: (MonadScanner m, MonadPrinter m, MonadIO m,Functor m,MonadFinalizer m) => [String] -> m ()+cat :: (ChScanner m, ChPrinter m, MonadIO m,Functor m,ChFinalizer m) => [String] -> m () cat [] = mscanL >>= mprint cat [f] = cat [] .<. f cat (f:fs) = cat [f] >> cat fs  -- | Like 'cat', but reverses the line order.-tac :: (MonadFinalizer m,MonadScanner m, MonadPrinter m, MonadIO m,Functor m) => [String] -> m ()+tac :: (ChFinalizer m,ChScanner m, ChPrinter m, MonadIO m,Functor m) => [String] -> m () tac [] = mscanL >>= (mprint . unlines . reverse . lines) tac fs = cat fs .|. tac []  -- | Pass-through, simultanously writing all input to a given file.-tee :: (MonadScanner m, MonadPrinter m, MonadIO m, Functor m) => String -> m ()+tee :: (ChScanner m, ChPrinter m, MonadIO m, Functor m) => String -> m () tee f = do   s <- mscanL   mprint s .>. f   mprint s  -- | Prints the given string, after expanding it.-echo :: (MonadPrinter m,MonadExpand m) => String => m ()+echo :: (ChPrinter m,ChExpand m) => String => m () echo = mprintLn <=< expand  -- | Mode for 'wc'. data WcMode = CountChars | CountLines | CountWords  -- | Count characters, lines or words of the input.-wc :: (MonadScanner m, MonadPrinter m, MonadIO m, Functor m) => WcMode -> m ()+wc :: (ChScanner m, ChPrinter m, MonadIO m, Functor m) => WcMode -> m () wc CountChars = mscanL >>= (mprint . show . length) >> mprint "\n" wc CountLines = mscanL >>= (mprint . show . length . lines) >> mprint "\n" wc CountWords = mscanL >>= (mprint . show . length . words) >> mprint "\n"@@ -72,11 +72,11 @@ cd = liftIO . setCurrentDirectory  -- | Print current working directory.-pwd :: (MonadIO m,MonadPrinter m) => m ()+pwd :: (MonadIO m,ChPrinter m) => m () pwd = liftIO getCurrentDirectory >>= mprintLn  -- | List directory contents of the given directories (current one, if empty list).-ls :: (MonadIO m,MonadPrinter m) => [String] -> m ()+ls :: (MonadIO m,ChPrinter m) => [String] -> m () ls [] = liftIO (getDirectoryContents ".") >>= (mprint . unlines) ls [p] = do   fs <- liftIO $ getFileStatus p@@ -87,9 +87,9 @@ ls (p:ps) = ls [p] >> ls ps  -- | Filters only the first n lines of the input.-head :: (MonadScanner m,MonadPrinter m,MonadIO m,Functor m) => Int -> m ()+head :: (ChScanner m,ChPrinter m,MonadIO m,Functor m) => Int -> m () head n = mscanL >>= (mprint . unlines . take n . lines)  -- | FIlters only the last n lines of the input.-tail :: (MonadScanner m,MonadPrinter m,MonadIO m,Functor m) => Int -> m ()+tail :: (ChScanner m,ChPrinter m,MonadIO m,Functor m) => Int -> m () tail n = mscanL >>= (mprint . unlines . reverse . take n . reverse . lines)

@@ -27,24 +27,24 @@ import System.Random  -- | Typeclass for all monads that know the time-class (Functor m,Monad m) => MonadClock m where+class (Functor m,Monad m) => ChClock m where   -- | Get UTC Time   mutctime :: m UTCTime   -- | Get timestamp, guaranteed to grow   mgetstamp :: m NominalDiffTime   mgetstamp = fmap (flip diffUTCTime (UTCTime (fromGregorian 1970 1 1) (secondsToDiffTime 0))) mutctime -instance MonadClock IO where+instance ChClock IO where   mutctime = getCurrentTime  -- | Typeclass for all monads that may provide random numbers-class Monad m => MonadRandom m where+class Monad m => ChRandom m where   -- | Get a single random number   mrandom :: Random r => m r   -- | Get a single random number in the given range   mrandomR :: Random r => (r,r) -> m r -instance MonadRandom IO where+instance ChRandom IO where   mrandom = randomIO   mrandomR rs = randomRIO rs 

@@ -31,13 +31,13 @@ import qualified System.Process as P  -- | Class for all (real or pseudo) process-spawning monads.-class Monad m => MonadSpawn m where+class Monad m => ChSpawn m where   -- | Spawn process   mspw :: String -> [String] -> Either Handle String -> m (Int,String,[Handle])   -- | Accept handle as input?   mah :: String -> m Bool -instance MonadSpawn IO where+instance ChSpawn IO where   mspw pn as (Left h) = do     (_, Just hout, _, ph) <- P.createProcess (P.proc pn as){       P.std_in = P.UseHandle h,@@ -57,7 +57,7 @@   mah = return $ return True  -- | Spawn process-spawn :: (MonadFinalizer m,MonadScanner m,MonadPrinter m, MonadSpawn m,Functor m) => String -> [String] -> m Int+spawn :: (ChFinalizer m,ChScanner m,ChPrinter m, ChSpawn m,Functor m) => String -> [String] -> m Int spawn fn as = do   ah <- mah fn   mscanh >>= \h' -> case if ah then h' else Nothing of

@@ -26,10 +26,10 @@ import System.Chatty.Spawn.Overlay  -- | Use builtins if possible.-withBuiltins :: (Functor m, MonadSpawn m) => SpawnOverlayT m a -> m a+withBuiltins :: (Functor m, ChSpawn m) => SpawnOverlayT m a -> m a withBuiltins m = fmap fst $ runSpawnOverlayT m builtins -builtins :: MonadSpawn m => [(String,[String] -> String -> m (Int,String))]+builtins :: ChSpawn m => [(String,[String] -> String -> m (Int,String))] builtins =   ("cat", \_ si -> return (0,si)):   []

@@ -43,7 +43,7 @@ instance Monad m => Functor (SpawnOverlayT m) where   fmap f a = SpawnOverlay $ \s -> do (a',s') <- runSpawnOverlayT a s; return (f a',s') -instance MonadSpawn m => MonadSpawn (SpawnOverlayT m) where+instance ChSpawn m => ChSpawn (SpawnOverlayT m) where   mspw pn as (Right si) = SpawnOverlay $ \s ->     case pn `elem` (map fst s) of       True -> let c = snd $ head $ filter ((==pn).fst) s

@@ -31,12 +31,12 @@ import Text.Chatty.Channel.Printer  -- | Typeclass for all channel printers that may broadcast to all channels that fulfill a condition.-class ChannelPrinter c m => Broadcaster c m where+class ChChannelPrinter c m => ChBroadcaster c m where   -- | Print the string to all channels that fulfill the current condition.   bprint :: (c -> m Bool) -> String -> m ()  -- | Typeclass for all broadcaster that may embrace sections-class Broadcaster c m => BroadcasterBracket c m where+class ChBroadcaster c m => ChBroadcasterBracket c m where   -- | Run the function and print to all channels that fulfill the given condition.   bbracket :: (c -> m Bool) -> m a -> m a   bbracket f m = bstart f >> m >>= \a -> bfin f >> return a

@@ -22,7 +22,7 @@  -- | Provides a printer class that offers several channels. module Text.Chatty.Channel.Printer (-  ChannelPrinter (..),+  ChChannelPrinter (..),   ArchiverT (..),   IntArchiverT,   BoolArchiverT,@@ -43,7 +43,7 @@ import System.IO  -- | Typeclass for all printers that offer several channels.-class (MonadPrinter m,Eq c) => ChannelPrinter c m where+class (ChPrinter m,Eq c) => ChChannelPrinter c m where   -- | Run the function with the given channel.   cbracket :: c -> m a -> m a   cbracket c m = cstart c >> m >>= \a -> cfin c >> return a@@ -79,10 +79,10 @@   | p == k = (p,f a) : ps   | otherwise = (p,a) : withAssoc k n f ps -instance (Eq c,Monad m) => MonadPrinter (ArchiverT c m) where+instance (Eq c,Monad m) => ChPrinter (ArchiverT c m) where   mprint s = Archiver $ \(r,c:cx) -> return ((),(withAssoc c [] (s:) r,c:cx)) -instance (Eq c,Monad m) => ChannelPrinter c (ArchiverT c m) where+instance (Eq c,Monad m) => ChChannelPrinter c (ArchiverT c m) where   cbracket c m = Archiver $ \(r,c1) -> do     (a,(r',_)) <- runArchiverT' m (r,c:c1)     return (a,(r',c1))@@ -114,11 +114,11 @@ instance Monad m => Functor (FilterT c m) where   fmap f a = liftM f a -instance (Eq c,MonadPrinter m) => MonadPrinter (FilterT c m) where+instance (Eq c,ChPrinter m) => ChPrinter (FilterT c m) where   mprint str = Filter $ \(c,c1:cx) -> if c == c1 then mprint str >> return ((),c1:cx) else return ((),c1:cx)   mnomask str = Filter $ \(c,c1:cx) -> if c == c1 then mnomask str >> return ((),c1:cx) else return ((),c1:cx) -instance (Eq c,MonadPrinter m) => ChannelPrinter c (FilterT c m) where+instance (Eq c,ChPrinter m) => ChChannelPrinter c (FilterT c m) where   cbracket c m = Filter $ \(cf,cx) -> do     (a,_) <- runFilterT m (cf,c:cx)     return (a,cx)@@ -147,11 +147,11 @@ instance Functor m => Functor (JoinerT m) where   fmap f (Joiner j) = Joiner $ fmap f j -instance MonadPrinter m => MonadPrinter (JoinerT m) where+instance ChPrinter m => ChPrinter (JoinerT m) where   mprint = lift . mprint   mnomask = lift . mnomask -instance (Eq c,MonadPrinter m) => ChannelPrinter c (JoinerT m) where+instance (Eq c,ChPrinter m) => ChChannelPrinter c (JoinerT m) where   cstart _ = return ()   cfin _ = return ()   cbracket _ m = m

@@ -27,7 +27,7 @@ import Control.Monad.Trans.Class  -- | Typeclass for all string-expanding monads.-class Monad e => MonadExpand e where+class Monad e => ChExpand e where   -- | Expand the given string.   expand :: String -> e String @@ -46,7 +46,7 @@ instance MonadIO m => MonadIO (NullExpanderT m) where   liftIO = lift . liftIO -instance Monad m => MonadExpand (NullExpanderT m) where+instance Monad m => ChExpand (NullExpanderT m) where   expand = return  withExpansion :: Monad m => NullExpanderT m a -> m a

@@ -46,19 +46,19 @@ instance Monad m => Functor (HistoryT m) where   fmap f a = History $ \s -> do (a',s') <- runHistoryT a s; return (f a',s') -class Monad he => HistoryEnv he where+class Monad he => ChHistoryEnv he where   mcounth :: he Int   mgeth :: Int -> he String   mputh :: String -> he () -instance Monad m => HistoryEnv (HistoryT m) where+instance Monad m => ChHistoryEnv (HistoryT m) where   mcounth = History $ runKleisli (arr length &&& id)   mgeth i     | i <= 0 = let j = -i in History $ runKleisli (arr (!!j) &&& id)     | otherwise = History . runKleisli $ arr ((!!i).reverse &&& id)   mputh s = History . runKleisli $ arr (const () &&& (s:)) -expandHist :: HistoryEnv h => String -> h String+expandHist :: ChHistoryEnv h => String -> h String expandHist [] = return [] expandHist ('!':ss) =   let (nm,rm) = (takeWhile isNum &&& dropWhile isNum) ss@@ -73,7 +73,7 @@       return (h++hs) expandHist (s:ss) = do ss' <- expandHist ss; return (s:ss') -instance MonadExpand m => MonadExpand (HistoryT m) where+instance ChExpand m => ChExpand (HistoryT m) where   expand = lift . expand <=< expandHist  withHistory :: Monad m => HistoryT m a -> m a

@@ -78,14 +78,14 @@   liftIO $ forM_ vs $ \(k,v) -> setEnv k (show v) True   return ((),vs) -instance MonadExpand IO where+instance ChExpand IO where   expand = expandVars -instance MonadExpand m => MonadExpand (ExpanderT m) where+instance ChExpand m => ChExpand (ExpanderT m) where   expand = lift . expand <=< expandVars  -- | Expand $variables-expandVars :: (Monad m,Functor m,ExpanderEnv m) => String -> m String+expandVars :: (Monad m,Functor m,ChExpanderEnv m) => String -> m String expandVars [] = return [] expandVars ('\\':'$':ss) = do r <- expandVars ss; return ('$':r) expandVars ('$':'{':ss) =@@ -111,19 +111,19 @@ isAnum = (`elem` (['a'..'z']++['A'..'Z']++"_"++['0'..'9']))  -- | Typeclass for all environment storages.-class Monad ee => ExpanderEnv ee where+class Monad ee => ChExpanderEnv ee where   -- | Get environment variable   mgetv :: String -> ee EnvVar   -- | Put environment variable   mputv :: String -> EnvVar -> ee () -instance Monad m => ExpanderEnv (ExpanderT m) where+instance Monad m => ChExpanderEnv (ExpanderT m) where   mgetv s = Expander $ \vs -> return $     case filter ((==s).fst) vs of       [] -> (NotSet,vs)       ((_,v):_) -> (v,vs)   mputv k v = Expander $ \vs -> return ((),(k,v):filter ((/=k).fst) vs) -instance ExpanderEnv IO where+instance ChExpanderEnv IO where   mgetv = fmap (\v -> case v of Nothing -> NotSet; Just v' -> Literal v') . getEnv   mputv k v = setEnv k (show v) True

@@ -19,7 +19,7 @@   along with Chatty. If not, see <http://www.gnu.org/licenses/>. -} --- | Provides an ExtendedPrinter that handles colours using standardized ANSI codes.+-- | Provides a 'ChExtendedPrinter' that handles colours using standardized ANSI codes. module Text.Chatty.Extended.ANSI where  import qualified System.Console.ANSI as A@@ -30,7 +30,7 @@ import Text.Chatty.Extended.Printer import Text.Chatty.Expansion --- | An ExtendedPrinter that uses ANSI colour codes.+-- | A 'ChExtendedPrinter' that uses ANSI colour codes. newtype AnsiPrinterT m a = AnsiPrinter { runAnsiPrinterT :: [Colour] -> m (a,[Colour]) }  instance Monad m => Monad (AnsiPrinterT m) where@@ -46,13 +46,13 @@ instance MonadIO m => MonadIO (AnsiPrinterT m) where   liftIO = lift . liftIO -instance MonadPrinter m => MonadPrinter (AnsiPrinterT m) where+instance ChPrinter m => ChPrinter (AnsiPrinterT m) where   mprint = lift . mprint   mnoecho = lift . mnoecho   mflush = lift mflush   mnomask = lift . mnomask -instance MonadPrinter m => ExtendedPrinter (AnsiPrinterT m) where+instance ChPrinter m => ChExtendedPrinter (AnsiPrinterT m) where   estart c = AnsiPrinter $ \c1 -> do     mprint $ A.setSGRCode [A.SetColor A.Foreground (mkColourInt c) (mkColourCode c)]     return ((),c:c1)@@ -65,7 +65,7 @@         mprint $ A.setSGRCode [A.Reset]         return ((),[]) -instance (Functor m,MonadExpand m) => MonadExpand (AnsiPrinterT m) where+instance (Functor m,ChExpand m) => ChExpand (AnsiPrinterT m) where   expand s = AnsiPrinter $ \cx -> do     s1 <- (expand =<<) $ liftM (replay.snd) $ runRecorderT $ liftM fst $ flip runAnsiPrinterT cx $ expandClr s     return (s1, cx)

@@ -19,7 +19,7 @@   along with Chatty. If not, see <http://www.gnu.org/licenses/>. -} --- | Provides an 'ExtendedPrinter' that handles colours using HTML output.+-- | Provides an 'ChExtendedPrinter' that handles colours using HTML output. module Text.Chatty.Extended.HTML where  import Text.Chatty.Printer@@ -29,7 +29,7 @@ import Control.Monad.Trans.Class import Control.Monad.IO.Class --- | An 'ExtendedPrinter' for HTML output.+-- | An 'ChExtendedPrinter' for HTML output. newtype HtmlPrinterT m a = HtmlPrinter { runHtmlPrinterT :: m a }  instance Monad m => Monad (HtmlPrinterT m) where@@ -45,17 +45,17 @@ instance MonadIO m => MonadIO (HtmlPrinterT m) where   liftIO = lift . liftIO -instance MonadPrinter m => MonadPrinter (HtmlPrinterT m) where+instance ChPrinter m => ChPrinter (HtmlPrinterT m) where   mprint = lift . mprint . concatMap maskHtml   mnoecho = lift . mnoecho . concatMap maskHtml   mflush = lift mflush   mnomask = lift . mnomask -instance MonadPrinter m => ExtendedPrinter (HtmlPrinterT m) where+instance ChPrinter m => ChExtendedPrinter (HtmlPrinterT m) where   estart c =  lift $ mprint $ concat ["<span style=\"color: #", hexColour c, ";\">"]   efin = lift $ mprint "</span>" -instance (Functor m,MonadExpand m) => MonadExpand (HtmlPrinterT m) where+instance (Functor m,ChExpand m) => ChExpand (HtmlPrinterT m) where   expand = lift . expand <=< liftM (replay.snd) . runRecorderT . runHtmlPrinterT . expandClr  -- | Convert the given character to its HTML representation.

@@ -20,7 +20,7 @@ -}  -- | Provides an extended printer class that supports colours.-module Text.Chatty.Extended.Printer (ExtendedPrinter(..),Tone(..),Colour(..),expandClr) where+module Text.Chatty.Extended.Printer (ChExtendedPrinter(..),Tone(..),Colour(..),expandClr) where  import Text.Chatty.Printer @@ -30,7 +30,7 @@ data Colour = Dull Tone | Vivid Tone  -- | Typeclass for all printers that support colourized output.-class MonadPrinter m => ExtendedPrinter m where+class ChPrinter m => ChExtendedPrinter m where   -- | Run the function with the given colour.   ebracket :: Colour -> m a -> m a   ebracket c m = do estart c; a <- m; efin; return a@@ -62,7 +62,7 @@  procClr c ss = let (nm,rm) = splitBrace ss in ebracket c (expandClr nm) >> expandClr rm -expandClr :: ExtendedPrinter m => String -> m ()+expandClr :: ChExtendedPrinter m => String -> m () expandClr ('%':'{':'V':'0':';':ss) = procClr (Vivid Black) ss expandClr ('%':'{':'V':'1':';':ss) = procClr (Vivid Red) ss expandClr ('%':'{':'V':'2':';':ss) = procClr (Vivid Green) ss

@@ -28,7 +28,7 @@ import System.IO  -- | Class for all handle-finalizing monads. Required for file redirections.-class Monad m => MonadFinalizer m where+class Monad m => ChFinalizer m where   -- | Enqueue handle   mqfh :: Handle -> m ()   -- | Enqueue list of handles@@ -53,7 +53,7 @@ instance MonadIO m => MonadIO (HandleCloserT m) where   liftIO = lift . liftIO -instance MonadIO m => MonadFinalizer (HandleCloserT m) where+instance MonadIO m => ChFinalizer (HandleCloserT m) where   mqfh h = HandleCloser $ \hs -> return ((),h:hs)   mfin = HandleCloser $ \hs -> do     sequence_ $ fmap (liftIO.hClose) hs@@ -62,4 +62,3 @@ -- | Run function with handle closer withLazyIO :: (MonadIO m,Functor m) => HandleCloserT m a -> m a withLazyIO m = fmap fst $ runHandleCloserT (do a <- m; mfin; return a) []-

@@ -42,10 +42,10 @@ import System.Chatty.Misc import System.IO --- | Automatically derives a MonadScanner instance for you.+-- | Automatically derives a ChScanner instance for you. mkScanner :: Name -> Q [Dec] mkScanner s = [d|-    instance MonadScanner m => MonadScanner ($sx m) where+    instance ChScanner m => ChScanner ($sx m) where       mscan1 = lift mscan1       mscanL = lift mscanL       mscannable = lift mscannable@@ -54,19 +54,19 @@   |]   where sx = strToType s --- | Automatically derives a BufferedScanner instance for you.+-- | Automatically derives a ChBufferedScanner instance for you. mkBufferedScanner :: Name -> Q [Dec] mkBufferedScanner s = [d|-    instance BufferedScanner m => BufferedScanner ($sx m) where+    instance ChBufferedScanner m => ChBufferedScanner ($sx m) where       mpeek1 = lift mpeek1       mprepend = lift . mprepend   |]   where sx = strToType s --- | Automatically derives a MonadPrinter instance for you.+-- | Automatically derives a ChPrinter instance for you. mkPrinter :: Name -> Q [Dec] mkPrinter s = [d|-    instance MonadPrinter m => MonadPrinter ($sx m) where+    instance ChPrinter m => ChPrinter ($sx m) where       mprint = lift . mprint       mnoecho = lift . mnoecho       mflush = lift mflush@@ -74,10 +74,10 @@   |]   where sx = strToType s --- | Automatically derives an ExtendedPrinter instance for you.+-- | Automatically derives an ChExtendedPrinter instance for you. mkExtendedPrinter :: Name -> Q [Dec] mkExtendedPrinter s = [d|-    instance ExtendedPrinter m => ExtendedPrinter ($sx m) where+    instance ChExtendedPrinter m => ChExtendedPrinter ($sx m) where       estart = lift . estart       efin = lift efin       eprint c = lift . eprint c@@ -85,10 +85,10 @@   |]                where sx = strToType s --- | Automatically derives a ChannelPrinter instance for you.+-- | Automatically derives a ChChannelPrinter instance for you. mkChannelPrinter :: Name ->  Name -> Q [Dec] mkChannelPrinter c s = [d|-    instance ChannelPrinter $cx m => ChannelPrinter $cx ($sx m) where+    instance ChChannelPrinter $cx m => ChChannelPrinter $cx ($sx m) where       cstart = lift . cstart       cfin = lift . cfin       cprint c = lift . cprint c@@ -109,7 +109,7 @@   where sx = strToType s         cx = strToType c-} --- | Automatically derives ChannelPrinter instances for 'Int', 'Bool' and 'Handle' channels.+-- | Automatically derives ChChannelPrinter instances for 'Int', 'Bool' and 'Handle' channels. mkDefCP :: Name -> Q [Dec] mkDefCP s = mkInteractor s (mkChannelPrinter ''Int) (mkChannelPrinter ''Bool) (mkChannelPrinter ''Handle) @@ -117,64 +117,64 @@ mkDefBC :: Name -> Q [Dec] mkDefBC s = mkInteractor s (mkBroadcaster ''Int) (mkBroadcaster ''Bool) (mkBroadcaster ''Handle)-} --- | Automatically derives a MonadFinalizer instance for you.+-- | Automatically derives a ChFinalizer instance for you. mkFinalizer :: Name -> Q [Dec] mkFinalizer s = [d|-    instance MonadFinalizer m => MonadFinalizer ($sx m) where+    instance ChFinalizer m => ChFinalizer ($sx m) where       mqfh = lift . mqfh       mfin = lift mfin   |]                  where sx = strToType s --- | Automatically derives a MonadExpand instance for you.+-- | Automatically derives a ChExpand instance for you. mkExpander :: Name -> Q [Dec] mkExpander s = [d|-    instance MonadExpand m => MonadExpand ($sx m) where+    instance ChExpand m => ChExpand ($sx m) where       expand = lift . expand   |]   where sx = strToType s --- | Automatically derives an ExpanderEnv instance for you+-- | Automatically derives an ChExpanderEnv instance for you mkExpanderEnv :: Name -> Q [Dec] mkExpanderEnv s = [d|-    instance ExpanderEnv m => ExpanderEnv ($sx m) where+    instance ChExpanderEnv m => ChExpanderEnv ($sx m) where       mgetv = lift . mgetv       mputv k v = lift $ mputv k v   |]   where sx = strToType s --- | Automatically derives a HistoryEnv instance for you+-- | Automatically derives a ChHistoryEnv instance for you mkHistoryEnv :: Name -> Q [Dec] mkHistoryEnv s = [d|-    instance HistoryEnv m => HistoryEnv ($sx m) where+    instance ChHistoryEnv m => ChHistoryEnv ($sx m) where       mcounth = lift mcounth       mgeth = lift . mgeth       mputh = lift . mputh   |]   where sx = strToType s --- | Automatically derives a MonadSpawn instance for you.+-- | Automatically derives a ChSpawn instance for you. mkSpawn :: Name -> Q [Dec] mkSpawn s = [d|-    instance MonadSpawn m => MonadSpawn ($sx m) where+    instance ChSpawn m => ChSpawn ($sx m) where       mspw pn as si = lift $ mspw pn as si       mah = lift . mah   |]   where sx = strToType s --- | Automatically derives a MonadRandom instance for you.+-- | Automatically derives a ChRandom instance for you. mkRandom :: Name -> Q [Dec] mkRandom s = [d|-    instance MonadRandom m => MonadRandom ($sx m) where+    instance ChRandom m => ChRandom ($sx m) where       mrandom = lift mrandom       mrandomR = lift . mrandomR   |]               where sx = strToType s --- | Automatically derives a MonadClock instance for you.+-- | Automatically derives a ChClock instance for you. mkClock :: Name -> Q [Dec] mkClock s = [d|-    instance MonadClock m => MonadClock ($sx m) where+    instance ChClock m => ChClock ($sx m) where       mutctime = lift mutctime       mgetstamp = lift mgetstamp   |]           

@@ -1,92 +0,0 @@-{--  This module is part of Chatty.-  Copyleft (c) 2014 Marvin Cohrs--  All wrongs reversed. Sharing is an act of love, not crime.-  Please share Antisplice with everyone you like.--  Chatty is free software: you can redistribute it and/or modify-  it under the terms of the GNU Affero General Public License as published by-  the Free Software Foundation, either version 3 of the License, or-  (at your option) any later version.--  Chatty is distributed in the hope that it will be useful,-  but WITHOUT ANY WARRANTY; without even the implied warranty of-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the-  GNU Affero General Public License for more details.--  You should have received a copy of the GNU Affero General Public License-  along with Chatty. If not, see <http://www.gnu.org/licenses/>.--}--module Text.Chatty.Parser where--import Control.Monad-import Data.Char-import Text.Chatty.Scanner--class MonadScanner m => MonadParser m where-  pabort :: m a-  (??) :: Eq a => m a -> m a -> m a-  (???) :: m a -> m a -> m a-  ptry :: MonadPlus n => m a -> m (n a)--request :: MonadScanner m => m Char-request = mscan1--match :: MonadParser m => Char -> m Char-match c = do-  k <- request-  if k == c then return c else pabort--matchs :: MonadParser m => String -> m String-matchs [] = return []-matchs (c:cs) = do-  match c-  matchs cs-  return (c:cs)--white :: MonadParser m => m Char-white = do-  k <- request-  if isSpace k then return k else pabort--digit :: MonadParser m => m Int-digit = do-  k <- request-  if isDigit k then return (read [k]) else pabort--alpha :: MonadParser m => m Char-alpha = do-  k <- request-  if isAlpha k then return k else pabort--anum :: MonadParser m => m Char-anum = do-  k <- request-  if isAlphaNum k then return k else pabort--possibly :: MonadParser m => m a -> m (Maybe a)-possibly f = liftM Just f ??? return Nothing--many :: MonadParser m => m a -> m [a]-many f = do-  x <- possibly f-  case x of-    Nothing -> return []-    Just x -> do-      xs <- many f-      return (x : xs)--some :: MonadParser m => m a -> m [a]-some f = do-  x <- f-  xs <- many f-  return (x : xs)--number :: MonadParser m => m Int-number = do-  many white-  ds <- some digit-  many white-  return $ foldl (\k n -> k * 10 + n) 0 ds

@@ -1,81 +0,0 @@-{--  This module is part of Chatty.-  Copyleft (c) 2014 Marvin Cohrs--  All wrongs reversed. Sharing is an act of love, not crime.-  Please share Antisplice with everyone you like.--  Chatty is free software: you can redistribute it and/or modify-  it under the terms of the GNU Affero General Public License as published by-  the Free Software Foundation, either version 3 of the License, or-  (at your option) any later version.--  Chatty is distributed in the hope that it will be useful,-  but WITHOUT ANY WARRANTY; without even the implied warranty of-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the-  GNU Affero General Public License for more details.--  You should have received a copy of the GNU Affero General Public License-  along with Chatty. If not, see <http://www.gnu.org/licenses/>.--}--module Text.Chatty.Parser.Nondeterministic where--import Control.Monad-import Data.List-import qualified Data.Foldable as F-import Text.Chatty.Parser-import Text.Chatty.Scanner--data ForkerT m a = Result (m a) (Char -> ForkerT m a) | Failed--instance (MonadPlus m,F.Foldable m) => Monad (ForkerT m) where-  return a = Result (return a) $ const Failed-  (Result as f) >>= m = Result (results >>= rResult) (\k -> F.foldl (???) (f k >>= m) (liftM (flip rFunction k) results))-    where isResult (Result _ _) = True-          isResult _ = False-          rResult (Result x _) = x-          rFunction (Result _ f) = f-          results = mfilter isResult $ liftM m as-  Failed >>= m = Failed-  fail _ = Failed--instance (MonadPlus m,F.Foldable m) => MonadParser (ForkerT m) where-  pabort = Failed-  Failed ?? b = b-  a ?? Failed = a-  (Result as f) ?? (Result bs g) = Result (msum $ liftM return $ nub $ F.foldr (:) [] $ mplus as bs) $ \k -> f k ?? g k-  Failed ??? b = b-  a ??? Failed = a-  (Result as f) ??? (Result bs g) = Result (mplus as bs) $ \k -> f k ??? g k-  ptry Failed = Failed-  ptry (Result as f) = Result (msum $ liftM return [msum $ liftM return $ F.foldr (:) [] as]) $ \k -> ptry $ f k--instance (MonadPlus m,F.Foldable m) => MonadScanner (ForkerT m) where-  mscan1 = Result mzero return-  mscanL = do-    c <- mscan1-    cs <- mscanL-    return (c:cs)-  mscannable = return True-  mready = return False--feedForkerT1 :: (MonadPlus m,F.Foldable m) => Char -> ForkerT m a -> ForkerT m a-feedForkerT1 _ Failed = Failed-feedForkerT1 c (Result _ f) = f c--feedForkerT :: (MonadPlus m,F.Foldable m) => String -> ForkerT m a -> ForkerT m a-feedForkerT [] = id-feedForkerT (c:cs) = feedForkerT cs . feedForkerT1 c--embedForkerT :: (MonadPlus n,F.Foldable n,MonadScanner m) => ForkerT n a -> m (n a)-embedForkerT f = do-  b <- mscannable-  if not b then-      case f of-        Failed -> return mzero-        Result xs _ -> return xs-    else do-      k <- mscan1-      embedForkerT $ feedForkerT1 k f-        

@@ -31,7 +31,7 @@ import System.IO  -- | A typeclass for all monads that may output strings.-class Monad m => MonadPrinter m where+class Monad m => ChPrinter m where   -- | Just print it!   mprint :: String -> m ()   -- | Print it, except you are IO.@@ -44,12 +44,12 @@   mnomask :: String -> m ()   mnomask = mprint -instance MonadPrinter IO where+instance ChPrinter IO where   mprint = putStr   mnoecho _ = return ()   mflush = hFlush stdout -instance Monad m => MonadPrinter (StateT String m) where+instance Monad m => ChPrinter (StateT String m) where   mprint s = modify (++s)  -- | DeafT discards all output (much like >\/dev\/null in the shell)@@ -68,7 +68,7 @@ instance MonadIO m => MonadIO (DeafT m) where   liftIO = lift . liftIO -instance Monad m => MonadPrinter (DeafT m) where+instance Monad m => ChPrinter (DeafT m) where   mprint _ = return ()  -- Definition of OutRedirT + instances@@ -87,7 +87,7 @@ instance MonadIO m => MonadIO (OutRedirT m) where   liftIO = lift . liftIO -instance MonadIO m => MonadPrinter (OutRedirT m) where+instance MonadIO m => ChPrinter (OutRedirT m) where   mprint s = OutRedir $ \h -> do liftIO $ hPutStr h s; return ((),h)   mflush = OutRedir $ \h -> do liftIO $ hFlush h; return ((),h) @@ -129,7 +129,7 @@ instance MonadTrans RecorderT where   lift m = Recorder $ \s -> do a <- m; return (a,s) -instance Monad m => MonadPrinter (RecorderT m) where+instance Monad m => ChPrinter (RecorderT m) where   mprint s = Recorder $ \s' -> return ((),s:s')  instance Monad m => Functor (RecorderT m) where@@ -164,11 +164,11 @@ runRecorderT = fmap (second Replayable) . flip runRecorderT' []  -- | Line-terminating alternative to 'mprint'-mprintLn :: MonadPrinter m => String -> m ()+mprintLn :: ChPrinter m => String -> m () mprintLn = mprint . (++"\n")  -- | Line-terminating alternative to 'mnomask'-mnomaskLn :: MonadPrinter m => String -> m ()+mnomaskLn :: ChPrinter m => String -> m () mnomaskLn = mnomask . (++"\n")  -- Shell-like syntax@@ -179,9 +179,9 @@ -- | Class for all redirection targets. class RedirectionTarget t mt a r | t -> mt, t a -> r where   -- | Overwriting redirection.-  (.>.) :: (Functor m,MonadIO m,MonadPrinter (mt m)) => mt m a -> t -> m r+  (.>.) :: (Functor m,MonadIO m,ChPrinter (mt m)) => mt m a -> t -> m r   -- | Appending redirection.-  (.>>.) :: (Functor m,MonadIO m,MonadPrinter (mt m)) => mt m a -> t -> m r+  (.>>.) :: (Functor m,MonadIO m,ChPrinter (mt m)) => mt m a -> t -> m r   (.>>.) = (.>.) instance RedirectionTarget DiscardO DeafT a a where   m .>. _ = runDeafT m@@ -190,3 +190,5 @@ instance RedirectionTarget FilePath OutRedirT a a where   m .>. fp = runOutRedirFT m fp WriteMode   m .>>. fp = runOutRedirFT m fp AppendMode+instance RedirectionTarget Handle OutRedirT a a where+  m .>. fp = runOutRedirT m fp

@@ -32,7 +32,7 @@ import System.IO  -- | A typeclass for all monads that may read input.-class Monad m => MonadScanner m where+class Monad m => ChScanner m where   -- | Read one single character   mscan1 :: m Char   -- | Lazily read all the input.@@ -45,16 +45,16 @@   -- | Input available yet?   mready :: m Bool --- MonadScanner instance for: IO-instance MonadScanner IO where+-- ChScanner instance for: IO+instance ChScanner IO where   mscan1 = getChar   mscanL = getContents   mscannable = fmap not isEOF   mscanh = return $ Just stdin   mready = hReady stdin --- MonadScanner instance for: StateT String-instance Monad m => MonadScanner (StateT String m) where+-- ChScanner instance for: StateT String+instance Monad m => ChScanner (StateT String m) where   mscan1 = do     c <- gets head     modify tail@@ -81,7 +81,7 @@ instance Monad m => Functor (HereStringT m) where   fmap f a = HereString $ \s -> do (a',s') <- runHereStringT a s; return (f a',s') -instance Monad m => MonadScanner (HereStringT m) where+instance Monad m => ChScanner (HereStringT m) where   mscan1 = HereString $ \(s:ss) -> return (s,ss)   mscanL = HereString $ \s -> return (s,[])   mscannable = HereString $ \s -> return (not $ null s,s)@@ -90,7 +90,7 @@ instance MonadIO m => MonadIO (HereStringT m) where   liftIO = lift . liftIO -instance MonadFinalizer m => MonadFinalizer (HereStringT m) where+instance ChFinalizer m => ChFinalizer (HereStringT m) where   mqfh = lift . mqfh   mfin = lift mfin @@ -105,7 +105,7 @@ instance MonadTrans QuietT where   lift = Quiet -instance Monad m => MonadScanner (QuietT m) where+instance Monad m => ChScanner (QuietT m) where   mscan1 = return undefined   mscanL = return []   mscannable = return False@@ -130,7 +130,7 @@ instance MonadIO m => MonadIO (InRedirT m) where   liftIO = lift . liftIO -instance MonadIO m => MonadScanner (InRedirT m) where+instance MonadIO m => ChScanner (InRedirT m) where   mscan1 = InRedir $ \h -> do c <- liftIO $ hGetChar h; return (c,h)   mscanL = InRedir $ \h -> do s <- liftIO $ hGetContents h; return (s,h)   mscannable = InRedir $ \h -> do b <- liftIO $ hIsEOF h; return (b,h)@@ -140,7 +140,7 @@ instance Monad m => Functor (InRedirT m) where   fmap f a = InRedir $ \h -> do (a',h') <- runInRedirT' a h; return (f a',h') -instance MonadFinalizer m => MonadFinalizer (InRedirT m) where+instance ChFinalizer m => ChFinalizer (InRedirT m) where   mqfh = lift . mqfh   mfin = lift mfin @@ -153,7 +153,7 @@ runInRedir m h = withLazyIO $ runInRedirT m h  -- | Run InRedirT with a filename-runInRedirFT :: (Functor m,MonadIO m,MonadFinalizer m) => InRedirT m a -> FilePath -> m a+runInRedirFT :: (Functor m,MonadIO m,ChFinalizer m) => InRedirT m a -> FilePath -> m a runInRedirFT m fp = do   h <- liftIO $ openFile fp ReadMode   a <- runInRedirT m h@@ -166,7 +166,7 @@ runInRedirF m fp = withLazyIO $ runInRedirFT m fp  -- | Line-scanning alternative to mscan1/L-mscanLn :: MonadScanner m => m String+mscanLn :: ChScanner m => m String mscanLn = do   h <- mscan1   if h == '\n' then return ""@@ -175,7 +175,7 @@                  return (h:hs)  -- | Scan a fixed number of chars-mscanN :: MonadScanner m => Int -> m String+mscanN :: ChScanner m => Int -> m String mscanN n   | n > 0 = do     b <- mscannable@@ -192,14 +192,16 @@ -- | Class for all primitive redirection sources. class RedirectionSource t mt a r | t -> mt, t a -> r where   -- | Redirection-  (.<.) :: (MonadFinalizer m,Functor m,MonadIO m,MonadScanner (mt m)) => mt m a -> t -> m a+  (.<.) :: (ChFinalizer m,Functor m,MonadIO m,ChScanner (mt m)) => mt m a -> t -> m r instance RedirectionSource EmptyI QuietT a a where   m .<. _ = runQuietT m instance RedirectionSource FilePath InRedirT a a where   m .<. fp = runInRedirFT m fp+instance RedirectionSource Handle InRedirT a a where+  m .<. fp = runInRedirT m fp -- | Class for all Here-Documents class RedirectionHeredoc t mt a r | t -> mt, t a -> r where   -- | Redirection-  (.<<.) :: (Functor m,MonadScanner (mt m)) => mt m a -> t -> m a+  (.<<.) :: (Functor m,ChScanner (mt m)) => mt m a -> t -> m r instance RedirectionHeredoc String HereStringT a a where   m .<<. str = fmap fst $ runHereStringT m str

@@ -21,6 +21,7 @@   along with Chatty. If not, see <http://www.gnu.org/licenses/>. -} +-- | Provides a typeclass for buffered scanners as well as a buffering monad transformer. module Text.Chatty.Scanner.Buffered where  import Control.Monad@@ -29,19 +30,30 @@ import Control.Monad.Trans.Class import Text.Chatty.Scanner -class MonadScanner m => BufferedScanner m where+-- | Typeclass for all buffered 'ChScanner's.+class ChScanner m => ChBufferedScanner m where+  -- | Scan the next character without removing it.   mpeek1 :: m Char+  -- | Prepend the given character to the scannable input.   mprepend :: String -> m () -instance Monad m => BufferedScanner (StateT String m) where+-- | Typeclass for all 'BufferedScanner's with support for pushing and popping.+class ChBufferedScanner m => ChStackBufferedScanner m where+  -- | Push the current input state to the stack.+  mpush :: m ()+  -- | Pop the previous input state from the stack.+  mpop :: m ()++instance Monad m => ChBufferedScanner (StateT String m) where   mpeek1 = gets head   mprepend s = modify (s++)   -instance Monad m => BufferedScanner (HereStringT m) where+instance Monad m => ChBufferedScanner (HereStringT m) where   mpeek1 = HereString $ \ss -> return (head ss, ss)   mprepend s = HereString $ \ss -> return ((), s++ss) -newtype ScannerBufferT m a = ScannerBuffer { runScannerBufferT :: String -> m (a,String) }+-- | A buffering 'MonadScanner' transformer that lets you use 'mpeek1' and 'mprepend' everywhere.+newtype ScannerBufferT m a = ScannerBuffer { runScannerBufferT :: [String] -> m (a,[String]) }  instance Monad m => Monad (ScannerBufferT m) where   return a = ScannerBuffer $ \s -> return (a,s)@@ -53,17 +65,20 @@ instance Monad m => Functor (ScannerBufferT m) where   fmap = liftM -instance MonadScanner m => MonadScanner (ScannerBufferT m) where-  mscan1 = ScannerBuffer $ \ss -> (if null ss then do s <- mscan1; return (s,[]) else return (head ss,tail ss))-  mscanL = ScannerBuffer $ \ss -> do l <- mscanL; return (ss++l, [])-  mscannable = ScannerBuffer $ \ss -> (if null ss then do b <- mscannable; return (b,[]) else return (True,ss))+instance ChScanner m => ChScanner (ScannerBufferT m) where+  mscan1 = ScannerBuffer $ \(ss:sx) -> (if null ss then do s <- mscan1; return (s,[]:map (s:) sx) else return (head ss,tail ss:map (head ss:) sx))+  mscanL = ScannerBuffer $ \(ss:sx) -> do l <- mscanL; return (ss++l, []:map (++l) sx)+  mscannable = ScannerBuffer $ \(ss:sx) -> (if null ss then do b <- mscannable; return (b,[]:sx) else return (True,ss:sx))   mscanh = return Nothing-  mready = ScannerBuffer $ \ss -> (if null ss then do b <- mready; return (b,[]) else return (True,ss))+  mready = ScannerBuffer $ \(ss:sx) -> (if null ss then do b <- mready; return (b,[]:sx) else return (True,ss:sx))  instance MonadIO m => MonadIO (ScannerBufferT m) where   liftIO = lift . liftIO -instance MonadScanner m => BufferedScanner (ScannerBufferT m) where-  mpeek1 = ScannerBuffer $ \ss -> (if null ss then do s <- mscan1; return (s,[s]) else return (head ss,ss))-  mprepend s = ScannerBuffer $ \ss -> return ((),s++ss)+instance ChScanner m => ChBufferedScanner (ScannerBufferT m) where+  mpeek1 = ScannerBuffer $ \(ss:sx) -> (if null ss then do s <- mscan1; return (s,[s]:sx) else return (head ss,ss:sx))+  mprepend s = ScannerBuffer $ \(ss:sx) -> return ((),(s++ss):sx) +instance ChScanner m => ChStackBufferedScanner (ScannerBufferT m) where+  mpush = ScannerBuffer $ \(ss:sx) -> return ((),ss:[]:sx)+  mpop = ScannerBuffer $ \(_:sx) -> return ((),sx)

@@ -1,60 +0,0 @@-{-# LANGUAGE ScopedTypeVariables #-}--{--  This module is part of Chatty.-  Copyleft (c) 2014 Marvin Cohrs--  All wrongs reversed. Sharing is an act of love, not crime.-  Please share Antisplice with everyone you like.--  Chatty is free software: you can redistribute it and/or modify-  it under the terms of the GNU Affero General Public License as published by-  the Free Software Foundation, either version 3 of the License, or-  (at your option) any later version.--  Chatty is distributed in the hope that it will be useful,-  but WITHOUT ANY WARRANTY; without even the implied warranty of-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the-  GNU Affero General Public License for more details.--  You should have received a copy of the GNU Affero General Public License-  along with Chatty. If not, see <http://www.gnu.org/licenses/>.--}--module Text.Chatty.Typograph where--import Control.Monad-import Control.Monad.Trans.Class-import Data.Char-import Text.Chatty.Interactor-import Text.Chatty.Printer-import Text.Chatty.Scanner-import Text.Chatty.Scanner.Buffered--simpleTypesetter :: (Functor m,MonadScanner m,MonadPrinter m) => Int -> m ()-simpleTypesetter width = void $ runScannerBufferT (typeset width) ""-  where scanw = mscannable >>= \b -> if not b then return [] else do-          k <- mpeek1-          if isSpace k then return [] else do-            mscan1-            ks <- scanw-            return (k:ks)-        skipw :: BufferedScanner m => m Int-        skipw = mscannable >>= \b -> if not b then return 0 else do-          k <- mpeek1-          if not (isSpace k) then return 0 else do-            mscan1-            w <- skipw-            return (w + if k == '\n' then 1 else 0)-        tsetw i w-          | length w < i = mprint (w ++ " ") >> typeset (i - 1 - length w)-          | length w == i = mprintLn w >> typeset width-          | length w > width && i == width = mprintLn (take i w) >> tsetw width (drop i w)-          | otherwise = mprintLn "" >> tsetw width w-        typeset i = mscannable >>= \b -> when b $ do-          ls <- skipw-          if ls > 0-            then forM_ [1..ls] (const $ mprintLn "") >> typeset width-            else do-              w <- scanw-              tsetw i w

@@ -10,13 +10,14 @@ -- PVP summary:      +-+------- breaking API changes --                   | | +----- non-breaking API additions --                   | | | +--- code changes with no API change-version:             0.5.5.1+version:             0.6  -- A short (one-line) description of the package.-synopsis:            Some monad transformers and typeclasses to simplify I/O on a transformer stack.+synopsis:            Some monad transformers and typeclasses for abstraction of global dependencies.  -- A longer description of the package.-description:         Some monad transformers and typeclasses for text in- and output on a function scope, including features like here-strings, file redirection, pipes and string expansion. Works best on a transformer stack.+description:         Some monad transformers and typeclasses abstracting global dependencies, like Text in- and output (incl. here-strings, pipes, recorders and file-redirections on a per-function scope),+                     process spawning, time and random number retrieval. Later also: Filesystem access, database access, authentication and privilege escalation (passing-through IO actions).  -- The license under which the package is released. license:             AGPL-3@@ -48,7 +49,7 @@  library   -- Modules exported by the library.-  exposed-modules:     Text.Chatty.Expansion, System.Chatty.Commands, System.Chatty.Spawn, Text.Chatty.Printer, Text.Chatty.Finalizer, Text.Chatty.Templates, Text.Chatty.Scanner, Text.Chatty.Interactor, System.Chatty.Spawn.Overlay, System.Chatty.Spawn.Builtins, Text.Chatty.Interactor.Templates, System.Chatty.Misc, Text.Chatty.Extended.Printer, Text.Chatty.Extended.HTML, Text.Chatty.Extended.ANSI, Text.Chatty.Expansion.Vars, Text.Chatty.Expansion.History, Text.Chatty.Channel.Printer, Text.Chatty.Channel.Broadcast, Text.Chatty.Scanner.Buffered, Text.Chatty.Typograph, Text.Chatty.Parser.Nondeterministic, Text.Chatty.Parser+  exposed-modules:     Text.Chatty.Expansion, System.Chatty.Commands, System.Chatty.Spawn, Text.Chatty.Printer, Text.Chatty.Finalizer, Text.Chatty.Templates, Text.Chatty.Scanner, Text.Chatty.Interactor, System.Chatty.Spawn.Overlay, System.Chatty.Spawn.Builtins, Text.Chatty.Interactor.Templates, System.Chatty.Misc, Text.Chatty.Extended.Printer, Text.Chatty.Extended.HTML, Text.Chatty.Extended.ANSI, Text.Chatty.Expansion.Vars, Text.Chatty.Expansion.History, Text.Chatty.Channel.Printer, Text.Chatty.Channel.Broadcast, Text.Chatty.Scanner.Buffered      -- Modules included in this library but not exported.   -- other-modules: