chatty (empty) → 0.1.4.0

raw patch · 18 files changed

+1632/−0 lines, 18 filesdep +ansi-terminaldep +basedep +directorysetup-changed

Dependencies added: ansi-terminal, base, directory, mtl, process, random, setenv, template-haskell, time, transformers, unix

Files

Chatty/Commands.hs +62/−0
Chatty/Expansion.hs +88/−0
Chatty/Extended/ANSI.hs +45/−0
Chatty/Extended/HTML.hs +54/−0
Chatty/Extended/Printer.hs +17/−0
Chatty/Finalizer.hs +37/−0
Chatty/Interactor.hs +57/−0
Chatty/Interactor/Templates.hs +86/−0
Chatty/Misc.hs +21/−0
Chatty/Printer.hs +146/−0
Chatty/Scanner.hs +168/−0
Chatty/Spawn.hs +48/−0
Chatty/Spawn/Builtins.hs +12/−0
Chatty/Spawn/Overlay.hs +39/−0
Chatty/Templates.hs +22/−0
LICENSE +661/−0
Setup.hs +2/−0
chatty.cabal +67/−0

+ Chatty/Commands.hs view

@@ -0,0 +1,62 @@+{-# LANGUAGE FlexibleInstances #-}++module Chatty.Commands where++import Chatty.Printer+import Chatty.Scanner+import Chatty.Interactor+import Chatty.Finalizer+import Chatty.Expansion+import Control.Monad+import Control.Monad.Trans.Class+import Control.Monad.IO.Class+import System.IO+import System.Directory+import System.Posix.Files++cat :: (MonadScanner m, MonadPrinter m, MonadIO m,Functor m,MonadFinalizer m) => [String] -> m ()+cat [] = mscanL >>= mprint+cat [f] = cat [] .<. f+cat (f:fs) = cat [f] >> cat fs++tac :: (MonadFinalizer m,MonadScanner m, MonadPrinter m, MonadIO m,Functor m) => [String] -> m ()+tac [] = mscanL >>= (mprint . unlines . reverse . lines)+tac fs = cat fs .|. tac []++tee :: (MonadScanner m, MonadPrinter m, MonadIO m, Functor m) => String -> m ()+tee f = do+  s <- mscanL+  mprint s .>. f+  mprint s++echo :: (MonadPrinter m,MonadExpand m) => String => m ()+echo = mprintLn <=< expand++data WcMode = CountChars | CountLines | CountWords++wc :: (MonadScanner m, MonadPrinter 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"++cd :: MonadIO m => String -> m ()+cd = liftIO . setCurrentDirectory++pwd :: (MonadIO m,MonadPrinter m) => m ()+pwd = liftIO getCurrentDirectory >>= mprintLn++ls :: (MonadIO m,MonadPrinter m) => [String] -> m ()+ls [] = liftIO (getDirectoryContents ".") >>= (mprint . unlines)+ls [p] = do+  fs <- liftIO $ getFileStatus p+  when (isDirectory fs) $+    liftIO (getDirectoryContents p) >>= (mprint . unlines)+  when (isRegularFile fs) $+    mprintLn p+ls (p:ps) = ls [p] >> ls ps+  +head :: (MonadScanner m,MonadPrinter m,MonadIO m,Functor m) => Int -> m ()+head n = mscanL >>= (mprint . unlines . take n . lines)++tail :: (MonadScanner m,MonadPrinter m,MonadIO m,Functor m) => Int -> m ()+tail n = mscanL >>= (mprint . unlines . reverse . take n . reverse . lines)

+ Chatty/Expansion.hs view

@@ -0,0 +1,88 @@+{-# LANGUAGE ExistentialQuantification, RankNTypes, Rank2Types #-}++module Chatty.Expansion where++import Data.List+import Control.Arrow+import Control.Monad+import Control.Monad.IO.Class+import Control.Monad.Trans.Class+import System.Environment hiding (getEnv)+import System.Posix.Env (getEnv, setEnv)+--import System.SetEnv++data EnvVar = NotSet | Literal String | forall a.Show a => Scalar a | Array [EnvVar]++instance Show EnvVar where+  show (Scalar s) = show s+  show (Literal s) = s+  show (Array ps) = unwords $ map show ps+  show NotSet = ""++newtype ExpanderT m a = Expander {+    runExpanderT :: [(String,EnvVar)] -> m (a,[(String,EnvVar)])+  }++instance Monad m => Monad (ExpanderT m) where+  return a = Expander $ \vs -> return (a,vs)+  (Expander e) >>= f = Expander $ \vs -> do (a,vs') <- e vs; runExpanderT (f a) vs'++instance MonadTrans ExpanderT where+  lift m = Expander $ \vs -> do a <- m; return (a,vs)++instance MonadIO m => MonadIO (ExpanderT m) where+  liftIO = lift . liftIO++instance Monad m => Functor (ExpanderT m) where+  fmap f a = Expander $ \vs -> do (a',vs') <- runExpanderT a vs; return (f a',vs')++localEnvironment :: Functor m => ExpanderT m a -> m a+localEnvironment m = fmap fst $ runExpanderT m []++forkEnvironment :: (Functor m,Monad m,MonadIO m) => ExpanderT m a -> m a+forkEnvironment m = do+  es <- liftIO getEnvironment+  fmap fst $ runExpanderT m $ fmap (second Literal) es++exportAll :: (Monad m,MonadIO m) => ExpanderT m ()+exportAll = Expander $ \vs -> do+  liftIO $ forM_ vs $ \(k,v) -> setEnv k (show v) True+  return ((),vs)++class Monad ee => ExpanderEnv ee where+  mgetv :: String -> ee EnvVar+  mputv :: String -> EnvVar -> ee ()++instance Monad m => ExpanderEnv (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+  mgetv = fmap (\v -> case v of Nothing -> NotSet; Just v' -> Literal v') . getEnv+  mputv k v = setEnv k (show v) True++class Monad e => MonadExpand e where+  expand :: String -> e String++instance MonadExpand IO where+  expand = expandVars++instance Monad m => MonadExpand (ExpanderT m) where+  expand = expandVars++expandVars :: (Monad m,Functor m,ExpanderEnv m) => String -> m String+expandVars [] = return []+expandVars ('$':ss) =+  let nm = takeWhile isAnum ss+      rm = dropWhile isAnum ss+  in do+    v <- fmap show $ mgetv nm+    r <- expandVars rm+    return (v++r)+expandVars (s:ss) = do ss' <- expandVars ss; return (s:ss')++isAnum = (`elem` (['a'..'z']++['A'..'Z']++"_"++['0'..'9']))+

+ Chatty/Extended/ANSI.hs view

@@ -0,0 +1,45 @@+module Chatty.Extended.ANSI where++import qualified System.Console.ANSI as A+import Control.Monad.Trans.Class+import Control.Monad.IO.Class+import Chatty.Printer+import Chatty.Extended.Printer++newtype AnsiPrinterT m a = AnsiPrinter { runAnsiPrinterT :: Colour -> m a }++instance Monad m => Monad (AnsiPrinterT m) where+  return a = AnsiPrinter $ \s -> return a+  (AnsiPrinter p) >>= f = AnsiPrinter $ \s -> do a <- p s; runAnsiPrinterT (f a) s++instance MonadTrans AnsiPrinterT where+  lift m = AnsiPrinter $ return m++instance Monad m => Functor (AnsiPrinterT m) where+  fmap f a = AnsiPrinter $ \s -> do a' <- runAnsiPrinterT a s; return (f a')++instance MonadIO m => MonadIO (AnsiPrinterT m) where+  liftIO = lift . liftIO++instance MonadPrinter m => MonadPrinter (AnsiPrinterT m) where+  mprint = lift . mprint+  mnoecho = lift . mnoecho+  mflush = lift mflush++instance MonadPrinter m => ExtendedPrinter (AnsiPrinterT m) where+  estart c = AnsiPrinter $ \c1 -> mprint $ A.setSGRCode [A.SetColor A.Foreground (mkColourInt c) (mkColourCode c)]+  efin = AnsiPrinter $ \c1 -> mprint $ A.setSGRCode [A.SetColor A.Foreground (mkColourInt c1) (mkColourCode c1)]++mkColourInt (Dull _) = A.Dull+mkColourInt (Vivid _) = A.Vivid++mkColourCode (Dull c) = mkColourCode (Vivid c)+mkColourCode (Vivid c) = case c of+  Green -> A.Green+  Red -> A.Red+  Yellow -> A.Yellow+  Blue -> A.Blue+  Black -> A.Black+  White -> A.White+  Cyan -> A.Cyan+  Magenta -> A.Magenta

+ Chatty/Extended/HTML.hs view

@@ -0,0 +1,54 @@+module Chatty.Extended.HTML where++import Chatty.Printer+import Chatty.Extended.Printer+import Control.Monad.Trans.Class+import Control.Monad.IO.Class++newtype HtmlPrinterT m a = HtmlPrinter { runHtmlPrinterT :: m a }++instance Monad m => Monad (HtmlPrinterT m) where+  return = HtmlPrinter . return+  (HtmlPrinter p) >>= f = HtmlPrinter $ do p' <- p; runHtmlPrinterT (f p')++instance MonadTrans HtmlPrinterT where+  lift = HtmlPrinter++instance Functor m => Functor (HtmlPrinterT m) where+  fmap f (HtmlPrinter p) = HtmlPrinter $ fmap f p++instance MonadIO m => MonadIO (HtmlPrinterT m) where+  liftIO = lift . liftIO++instance MonadPrinter m => MonadPrinter (HtmlPrinterT m) where+  mprint = lift . mprint . concatMap maskHtml+  mnoecho = lift . mnoecho . concatMap maskHtml+  mflush = lift mflush++instance MonadPrinter m => ExtendedPrinter (HtmlPrinterT m) where+  estart c =  lift $ mprint $ concat ["<span style=\"color: #", hexColour c, ";\">"]+  efin = lift $ mprint "</span>"++maskHtml :: Char -> String+maskHtml '&' = "&amp;"+maskHtml '<' = "&lt;"+maskHtml '>' = "&gt;"+maskHtml ' ' = "&nbsp;"+maskHtml c = [c]++hexColour (Dull Green) = "004400"+hexColour (Vivid Green) = "00FF00"+hexColour (Dull Red) = "440000"+hexColour (Vivid Red) = "FF0000"+hexColour (Dull Yellow) = "444400"+hexColour (Vivid Yellow) = "FFFF00"+hexColour (Dull Blue) = "000044"+hexColour (Vivid Blue) = "0000FF"+hexColour (Dull Black) = "000000"+hexColour (Vivid Black) = "444444"+hexColour (Dull White) = "888888"+hexColour (Vivid White) = "FFFFFF"+hexColour (Dull Cyan) = "004444"+hexColour (Vivid Cyan) = "00FFFF"+hexColour (Dull Magenta) = "440044"+hexColour (Vivid Magenta) = "FF00FF"

+ Chatty/Extended/Printer.hs view

@@ -0,0 +1,17 @@+module Chatty.Extended.Printer where++import Chatty.Printer++data Tone = Green | Red | Yellow | Blue | Black | White | Cyan | Magenta+data Colour = Dull Tone | Vivid Tone++class MonadPrinter m => ExtendedPrinter m where+  ebracket :: Colour -> m a -> m a+  ebracket c m = do estart c; a <- m; efin; return a+  eprint :: Colour -> String -> m ()+  eprint c = ebracket c . mprint+  eprintLn :: Colour -> String -> m ()+  eprintLn c s = eprint c s >> mprintLn ""+  estart :: Colour -> m ()+  efin :: m ()+

+ Chatty/Finalizer.hs view

@@ -0,0 +1,37 @@+module Chatty.Finalizer where++import Control.Monad+import Control.Monad.IO.Class+import Control.Monad.Trans.Class+import System.IO++class Monad m => MonadFinalizer m where+  mqfh :: Handle -> m ()+  mqfhs :: [Handle] -> m ()+  mqfhs = foldr ((>>) . mqfh) (return ())+  mfin :: m ()++newtype HandleCloserT m a = HandleCloser { runHandleCloserT :: [Handle] -> m (a,[Handle]) }++instance Monad m => Monad (HandleCloserT m) where+  return a = HandleCloser $ \hs -> return (a,hs)+  (HandleCloser m) >>= f = HandleCloser $ \hs -> do (a,hs') <- m hs; runHandleCloserT (f a) hs'++instance MonadTrans HandleCloserT where+  lift m = HandleCloser $ \hs -> do a <- m; return (a,hs)++instance Monad m => Functor (HandleCloserT m) where+  fmap f a = HandleCloser $ \hs -> do (a',hs') <- runHandleCloserT a hs; return (f a',hs')++instance MonadIO m => MonadIO (HandleCloserT m) where+  liftIO = lift . liftIO++instance MonadIO m => MonadFinalizer (HandleCloserT m) where+  mqfh h = HandleCloser $ \hs -> return ((),h:hs)+  mfin = HandleCloser $ \hs -> do+    sequence_ $ fmap (liftIO.hClose) hs+    return ((),[])++withLazyIO :: (MonadIO m,Functor m) => HandleCloserT m a -> m a+withLazyIO m = fmap fst $ runHandleCloserT (do a <- m; mfin; return a) []+

+ Chatty/Interactor.hs view

@@ -0,0 +1,57 @@+{-# LANGUAGE MultiParamTypeClasses, FlexibleInstances, FunctionalDependencies, TemplateHaskell #-}++module Chatty.Interactor where++import Chatty.Printer+import Chatty.Scanner+import Chatty.Finalizer+import Chatty.Expansion+import Chatty.Extended.HTML+import Chatty.Extended.ANSI+import Chatty.Misc+import Chatty.Interactor.Templates+import Chatty.Spawn+import Chatty.Spawn.Overlay+import Control.Monad+import Control.Monad.Trans.Class+import Control.Monad.Identity++mkInteractor ''RecorderT mkScanner mkFinalizer mkExpander mkSpawn mkRandom mkClock+mkInteractor ''DeafT mkScanner mkFinalizer mkExpander mkSpawn mkRandom mkClock+mkInteractor ''OutRedirT mkScanner mkFinalizer mkExpander mkSpawn mkRandom mkClock+mkInteractor ''HandleCloserT mkScanner mkPrinter mkExpander mkSpawn mkRandom mkClock+mkInteractor ''ExpanderT mkScanner mkPrinter mkFinalizer mkSpawn mkRandom mkClock+mkInteractor ''HereStringT mkPrinter mkExpander mkSpawn mkRandom mkClock+mkInteractor ''QuietT mkPrinter mkExpander mkSpawn mkRandom mkClock+mkInteractor ''InRedirT mkPrinter mkExpander mkSpawn mkRandom mkClock+mkInteractor ''SpawnOverlayT mkPrinter mkScanner mkExpander mkFinalizer mkRandom mkClock+mkInteractor ''HtmlPrinterT mkScanner mkExpander mkFinalizer mkSpawn mkRandom mkClock+mkInteractor ''AnsiPrinterT mkScanner mkExpander mkFinalizer mkSpawn mkRandom mkClock++type IgnorantT m = QuietT (DeafT m)+type Ignorant = IgnorantT Identity+type ChattyT m = HereStringT (RecorderT m)+type Chatty = ChattyT Identity++runIgnorantT :: Monad m => IgnorantT m a -> m a+runIgnorantT = runDeafT . runQuietT++runIgnorant :: Ignorant a -> a+runIgnorant = runIdentity . runIgnorantT++runChattyT :: (Monad m,Functor m) => ChattyT m a -> String -> m (a,String,Replayable)+runChattyT m input = fmap (\((a,u),r) -> (a,u,r)) $ runRecorderT $ runHereStringT m input++runChatty :: Chatty a -> String -> (a,String,Replayable)+runChatty m = runIdentity . runChattyT m++-- Shell-like syntax+(.|.) :: (Monad m,Functor m) => RecorderT m a -> HereStringT m b -> m b+m1 .|. m2 = do+  (_,r) <- runRecorderT m1+  fmap fst $ runHereStringT m2 (replay r)++(.<$.) :: (Functor m,Monad m) => (String -> m b) -> RecorderT m a -> m b+m1 .<$. m2 = do+  (_,r) <- runRecorderT m2+  m1 $ replay r

+ Chatty/Interactor/Templates.hs view

@@ -0,0 +1,86 @@+{-# LANGUAGE TemplateHaskell, QuasiQuotes, FlexibleInstances #-}++module Chatty.Interactor.Templates (mkScanner, mkPrinter, mkFinalizer, mkExpander,mkInteractor,mkSpawn,mkRandom,mkClock) where++import Chatty.Scanner+import Chatty.Printer+import Chatty.Finalizer+import Chatty.Expansion+import Chatty.Spawn+import Chatty.Extended.Printer+import Control.Monad+import Control.Monad.Trans+import Language.Haskell.TH+import Chatty.Templates+import Chatty.Misc++mkScanner s = [d|+    instance MonadScanner m => MonadScanner ($sx m) where+      mscan1 = lift mscan1+      mscanL = lift mscanL+      mscannable = lift mscannable+      mscanh = lift mscanh+      mready = lift mready+  |]+  where sx = strToType s++mkPrinter s = [d|+    instance MonadPrinter m => MonadPrinter ($sx m) where+      mprint = lift . mprint+      mnoecho = lift . mnoecho+      mflush = lift mflush+    instance ExtendedPrinter m => ExtendedPrinter ($sx m) where+      estart = lift . estart+      efin = lift efin+      eprint c = lift . eprint c+      eprintLn c = lift . eprintLn c+  |]             +  where sx = strToType s++mkFinalizer s = [d|+    instance MonadFinalizer m => MonadFinalizer ($sx m) where+      mqfh = lift . mqfh+      mfin = lift mfin+  |]               +  where sx = strToType s++mkExpander s = [d|+    instance MonadExpand m => MonadExpand ($sx m) where+      expand = lift . expand+    instance ExpanderEnv m => ExpanderEnv ($sx m) where+      mgetv = lift . mgetv+      mputv k v = lift $ mputv k v+  |]+  where sx = strToType s++mkSpawn s = [d|+    instance MonadSpawn m => MonadSpawn ($sx m) where+      mspw pn as si = lift $ mspw pn as si+      mah = lift . mah+  |]+  where sx = strToType s++mkRandom s = [d|+    instance MonadRandom m => MonadRandom ($sx m) where+      mrandom = lift mrandom+      mrandomR = lift . mrandomR+  |]            +  where sx = strToType s++mkClock s = [d|+    instance MonadClock m => MonadClock ($sx m) where+      mutctime = lift mutctime+      mgetstamp = lift mgetstamp+  |]           +  where sx = strToType s++class InteractorMaker i where+  mkInteractor' :: Name -> Q [Dec] -> i+  mkInteractor :: Name -> i+  mkInteractor n = mkInteractor' n [d| |]++instance InteractorMaker (Q [Dec]) where+  mkInteractor' _ = id++instance InteractorMaker i => InteractorMaker ((Name -> Q [Dec]) -> i) where+  mkInteractor' n qs qf = mkInteractor' n (do q1 <- qs; q2 <- qf n; return (q1++q2))

+ Chatty/Misc.hs view

@@ -0,0 +1,21 @@+module Chatty.Misc where++import Data.Time.Clock+import System.Random++class (Functor m,Monad m) => MonadClock m where+  mutctime :: m UTCTime+  mgetstamp :: m DiffTime+  mgetstamp = fmap utctDayTime mutctime++instance MonadClock IO where+  mutctime = getCurrentTime++class Monad m => MonadRandom m where+  mrandom :: Random r => m r+  mrandomR :: Random r => (r,r) -> m r++instance MonadRandom IO where+  mrandom = randomIO+  mrandomR rs = randomRIO rs+

+ Chatty/Printer.hs view

@@ -0,0 +1,146 @@+{-# LANGUAGE FlexibleInstances, MultiParamTypeClasses, FunctionalDependencies #-}++module Chatty.Printer where++import Control.Arrow+import Control.Monad+import Control.Monad.State+import Control.Monad.Identity+import System.IO++-- Class Definition for MonadPrinter+class Monad m => MonadPrinter m where+  mprint :: String -> m ()+  mnoecho :: String -> m ()+  mnoecho = mprint+  mflush :: m ()+  mflush = return ()++-- MonadPrinter instance for: IO+instance MonadPrinter IO where+  mprint = putStr+  mnoecho _ = return ()+  mflush = hFlush stdout++-- MonadPrinter instance for: StateT String m+instance Monad m => MonadPrinter (StateT String m) where+  mprint s = modify (++s)++-- Definition of DeafT + instances+-- DeafT discards all output (much like >/dev/null in the shell)+newtype DeafT m a = Deaf { runDeafT :: m a }++instance Monad m => Monad (DeafT m) where+  return = Deaf . return+  (Deaf d) >>= f = Deaf $ do d' <- d; runDeafT (f d')++instance MonadTrans DeafT where+  lift = Deaf++instance Functor m => Functor (DeafT m) where+  fmap f (Deaf a) = Deaf $ fmap f a++instance MonadIO m => MonadIO (DeafT m) where+  liftIO = lift . liftIO++instance Monad m => MonadPrinter (DeafT m) where+  mprint _ = return ()++-- Definition of OutRedirT + instances+-- OutRedirT redirects all output to a given handle (much like >filename in the shell)+newtype OutRedirT m a = OutRedir { runOutRedirT' :: Handle -> m (a,Handle) }+type OutRedir = OutRedirT IO++instance Monad m => Monad (OutRedirT m) where+  return a = OutRedir $ \h -> return (a,h)+  (OutRedir r) >>= f = OutRedir $ \h -> do (a,h') <- r h; runOutRedirT' (f a) h'++instance MonadTrans OutRedirT where+  lift m = OutRedir $ \h -> do a <- m; return (a,h)++instance MonadIO m => MonadIO (OutRedirT m) where+  liftIO = lift . liftIO++instance MonadIO m => MonadPrinter (OutRedirT m) where+  mprint s = OutRedir $ \h -> do liftIO $ hPutStr h s; return ((),h)+  mflush = OutRedir $ \h -> do liftIO $ hFlush h; return ((),h)++instance Monad m => Functor (OutRedirT m) where+  fmap f a = OutRedir $ \h -> do (a',h') <- runOutRedirT' a h; return (f a',h')++runOutRedirT :: Functor m => OutRedirT m a -> Handle -> m a+runOutRedirT m h = fmap fst $ runOutRedirT' m h++runOutRedir :: OutRedir a -> Handle -> IO a+runOutRedir = runOutRedirT++runOutRedirFT :: (Functor m,MonadIO m) => OutRedirT m a -> FilePath -> IOMode -> m a+runOutRedirFT m fp md+  | md `elem` [AppendMode,WriteMode] = do+    h <- liftIO $ openFile fp md+    a <- runOutRedirT m h+    liftIO $ hClose h+    return a+  | otherwise = error "runOutRedirFT does only accept AppendMode or WriteMode."++runOutRedirF :: OutRedir a -> FilePath -> IOMode -> IO a+runOutRedirF = runOutRedirFT++-- Definition of RecorderT + instances+-- RecorderT catches all output (much like VAR=$(...) in the shell)+newtype RecorderT m a = Recorder { runRecorderT' :: [String] -> m (a,[String]) }+type Recorder = RecorderT Identity++instance Monad m => Monad (RecorderT m) where+  return a = Recorder $ \s -> return (a,s)+  (Recorder r) >>= f = Recorder $ \s -> do (a,s') <- r s; runRecorderT' (f a) s'++instance MonadTrans RecorderT where+  lift m = Recorder $ \s -> do a <- m; return (a,s)++instance Monad m => MonadPrinter (RecorderT m) where+  mprint s = Recorder $ \s' -> return ((),s:s')++instance Monad m => Functor (RecorderT m) where+  fmap f a = Recorder $ \s -> do (a',s') <- runRecorderT' a s; return (f a',s')++instance MonadIO m => MonadIO (RecorderT m) where+  liftIO = lift . liftIO++-- Helper methods for RecorderT+newtype Replayable = Replayable [String]+instance Show Replayable where show r = show ((\(Replayable x) -> length x) r) ++ ":" ++ show (replay r)++replayM :: Monad m => m Replayable -> m String+replayM r = do (Replayable r') <- r; return (concat $ reverse r')++replay :: Replayable -> String+replay (Replayable r) = concat $ reverse r++replay_ :: Monad m => RecorderT m String+replay_ = Recorder $ \s -> return (concat $ reverse s,s)++runRecorder :: Recorder a -> (a,Replayable)+runRecorder = second Replayable . runIdentity . flip runRecorderT' []++runRecorderT :: (Functor m,Monad m) => RecorderT m a -> m (a,Replayable)+runRecorderT = fmap (second Replayable) . flip runRecorderT' []++-- Line-terminating alternative to mprint+mprintLn :: MonadPrinter m => String -> m ()+mprintLn = mprint . (++"\n")++-- Shell-like syntax+data DiscardO = DiscardO+data RecordO = RecordO+class RedirectionTarget t mt a r | t -> mt, t a -> r where+  (.>.) :: (Functor m,MonadIO m,MonadPrinter (mt m)) => mt m a -> t -> m r+  (.>>.) :: (Functor m,MonadIO m,MonadPrinter (mt m)) => mt m a -> t -> m r+  (.>>.) = (.>.)+instance RedirectionTarget DiscardO DeafT a a where+  m .>. _ = runDeafT m+instance RedirectionTarget RecordO RecorderT a (a,Replayable) where+  m .>. _ = runRecorderT m+instance RedirectionTarget FilePath OutRedirT a a where+  m .>. fp = runOutRedirFT m fp WriteMode+  m .>>. fp = runOutRedirFT m fp AppendMode

+ Chatty/Scanner.hs view

@@ -0,0 +1,168 @@+{-# LANGUAGE FlexibleInstances, MultiParamTypeClasses, FunctionalDependencies #-}++module Chatty.Scanner where++import Chatty.Finalizer+import Control.Monad+import Control.Monad.State+import Control.Monad.Identity+import Control.Monad.Trans.Class+import System.IO++-- Class Definition of MonadScanner+class Monad m => MonadScanner m where+  mscan1 :: m Char+  mscanL :: m String+  mscannable :: m Bool+  mscanh :: m (Maybe Handle)+  mscanh = return Nothing+  mready :: m Bool++-- MonadScanner instance for: IO+instance MonadScanner 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+  mscan1 = do+    c <- gets head+    modify tail+    return c+  mscanL = do+    s <- get+    put []+    return s+  mscannable = gets (not.null)+  mready = return True++-- Definition of HereStringT + instances+-- HereStringT holds a given string and uses it as input for the function+-- (much like here-strings in the shell)+newtype HereStringT m a = HereString { runHereStringT :: String -> m (a,String) }++instance Monad m => Monad (HereStringT m) where+  return a = HereString $ \s -> return (a,s)+  (HereString h) >>= f = HereString $ \s -> do (a,s') <- h s; runHereStringT (f a) s'++instance MonadTrans HereStringT where+  lift m = HereString $ \s -> do a <- m; return (a,s)++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+  mscan1 = HereString $ \(s:ss) -> return (s,ss)+  mscanL = HereString $ \s -> return (s,[])+  mscannable = HereString $ \s -> return (not $ null s,s)+  mready = return True++instance MonadIO m => MonadIO (HereStringT m) where+  liftIO = lift . liftIO++instance MonadFinalizer m => MonadFinalizer (HereStringT m) where+  mqfh = lift . mqfh+  mfin = lift mfin++-- Definition of QuietT + instances+-- QuietT does not convey any input (much like </dev/null in the shell)+newtype QuietT m a = Quiet { runQuietT :: m a }++instance Monad m => Monad (QuietT m) where+  return = Quiet . return+  (Quiet q) >>= f = Quiet $ do q' <- q; runQuietT (f q')++instance MonadTrans QuietT where+  lift = Quiet++instance Monad m => MonadScanner (QuietT m) where+  mscan1 = return undefined+  mscanL = return []+  mscannable = return False+  mready = return False++instance Functor m => Functor (QuietT m) where+  fmap f (Quiet a) = Quiet $ fmap f a++-- Definition of InRedirT + instances+-- InRedirT redirects all input to a given handle (much like <filename in the shell)+newtype InRedirT m a = InRedir { runInRedirT' :: Handle -> m (a,Handle) }+type InRedir = InRedirT (HandleCloserT IO)++instance Monad m => Monad (InRedirT m) where+  return a = InRedir $ \h -> return (a,h)+  (InRedir r) >>= f = InRedir $ \h -> do (a,h') <- r h; runInRedirT' (f a) h'++instance MonadTrans InRedirT where+  lift m = InRedir $ \h -> do a <- m; return (a,h)++instance MonadIO m => MonadIO (InRedirT m) where+  liftIO = lift . liftIO++instance MonadIO m => MonadScanner (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)+  mscanh = InRedir $ \h -> return (Just h,h)+  mready = InRedir $ \h -> do r <- liftIO $ hReady h; return (r,h)++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+  mqfh = lift . mqfh+  mfin = lift mfin++runInRedirT :: Functor m => InRedirT m a -> Handle -> m a+runInRedirT m h = fmap fst $ runInRedirT' m h++runInRedir :: InRedir a -> Handle -> IO a+runInRedir m h = withLazyIO $ runInRedirT m h++runInRedirFT :: (Functor m,MonadIO m,MonadFinalizer m) => InRedirT m a -> FilePath -> m a+runInRedirFT m fp = do+  h <- liftIO $ openFile fp ReadMode+  a <- runInRedirT m h+  mqfh h+  --liftIO $ hClose h+  return a++runInRedirF :: InRedir a -> FilePath -> IO a+runInRedirF m fp = withLazyIO $ runInRedirFT m fp++-- Line-scanning alternative to mscan1/L+mscanLn :: MonadScanner m => m String+mscanLn = do+  h <- mscan1+  if h == '\n' then return ""+               else do+                 hs <- mscanLn+                 return (h:hs)++-- Scan a fixed number of chars+mscanN :: MonadScanner m => Int -> m String+mscanN n+  | n > 0 = do+    b <- mscannable+    if not b then return []+             else do+               h <- mscan1+               hs <- mscanN (n-1)+               return (h:hs)+  | otherwise = return []++-- Shell-like syntax+data EmptyI = EmptyI+class RedirectionSource t mt a r | t -> mt, t a -> r where+  (.<.) :: (MonadFinalizer m,Functor m,MonadIO m,MonadScanner (mt m)) => mt m a -> t -> m a+instance RedirectionSource EmptyI QuietT a a where+  m .<. _ = runQuietT m+instance RedirectionSource FilePath InRedirT a a where+  m .<. fp = runInRedirFT m fp+class RedirectionHeredoc t mt a r | t -> mt, t a -> r where+  (.<<.) :: (Functor m,MonadScanner (mt m)) => mt m a -> t -> m a+instance RedirectionHeredoc String HereStringT a a where+  m .<<. str = fmap fst $ runHereStringT m str

+ Chatty/Spawn.hs view

@@ -0,0 +1,48 @@+module Chatty.Spawn where++import Chatty.Finalizer+import Chatty.Printer+import Chatty.Scanner+import Control.Monad.IO.Class+import System.Exit+import System.IO+import qualified System.Process as P++class Monad m => MonadSpawn m where+  mspw :: String -> [String] -> Either Handle String -> m (Int,String,[Handle])+  mah :: String -> m Bool++instance MonadSpawn IO where+  mspw pn as (Left h) = do+    (_, Just hout, _, ph) <- P.createProcess (P.proc pn as){+      P.std_in = P.UseHandle h,+      P.std_out = P.CreatePipe }+    so <- hGetContents hout+    ec <- P.waitForProcess ph+    return (case ec of+               ExitSuccess -> 0+               ExitFailure i -> i,+            so, [hout])+  mspw pn as (Right si) = do+    (ec,so,_) <- P.readProcessWithExitCode pn as si+    return (case ec of+               ExitSuccess -> 0+               ExitFailure i -> i,+            so, [])+  mah = return $ return True++spawn :: (MonadFinalizer m,MonadScanner m,MonadPrinter m, MonadSpawn m,Functor m) => String -> [String] -> m Int+spawn fn as = do+  ah <- mah fn+  mscanh >>= \h' -> case if ah then h' else Nothing of+    Nothing -> do+      si <- mscanL+      (i,so,hs) <- mspw fn as (Right si)+      mprint so+      mqfhs hs+      return i+    Just h -> do+      (i,so,hs) <- mspw fn as (Left h)+      mprint so+      mqfhs hs+      return i

+ Chatty/Spawn/Builtins.hs view

@@ -0,0 +1,12 @@+module Chatty.Spawn.Builtins (withBuiltins) where++import Chatty.Spawn+import Chatty.Spawn.Overlay++withBuiltins :: (Functor m, MonadSpawn m) => SpawnOverlayT m a -> m a+withBuiltins m = fmap fst $ runSpawnOverlayT m builtins++builtins :: MonadSpawn m => [(String,[String] -> String -> m (Int,String))]+builtins =+  ("cat", \_ si -> return (0,si)):+  []

+ Chatty/Spawn/Overlay.hs view

@@ -0,0 +1,39 @@+module Chatty.Spawn.Overlay where++import Chatty.Spawn+import Control.Monad.Trans.Class+import Control.Monad.IO.Class+import System.IO++newtype SpawnOverlayT m a = SpawnOverlay { runSpawnOverlayT :: [(String,[String] -> String -> m (Int,String))] -> m (a,[(String,[String] -> String -> m (Int,String))]) }++instance Monad m => Monad (SpawnOverlayT m) where+  return a = SpawnOverlay $ \o -> return (a,o)+  (SpawnOverlay o) >>= f = SpawnOverlay $ \s -> do (a,s') <- o s; runSpawnOverlayT (f a) s'++instance MonadTrans SpawnOverlayT where+  lift m = SpawnOverlay $ \s -> do a <- m; return (a,s)++instance MonadIO m => MonadIO (SpawnOverlayT m) where+  liftIO = lift . liftIO++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+  mspw pn as (Right si) = SpawnOverlay $ \s ->+    case pn `elem` (map fst s) of+      True -> let c = snd $ head $ filter ((==pn).fst) s+              in do+                (r,so) <- c as si+                return ((r,so,[]),s)+      False -> do+                r <- mspw pn as (Right si)+                return (r,s)+  mspw pn as (Left h) = lift $ mspw pn as (Left h)+  mah pn = SpawnOverlay $ \s ->+    case pn `elem` (map fst s) of+      True -> return (False,s)+      False -> do+        ah <- mah pn+        return (ah,s)

+ Chatty/Templates.hs view

@@ -0,0 +1,22 @@+{-# LANGUAGE FlexibleInstances #-}++module Chatty.Templates where++import Language.Haskell.TH++strToType :: Name -> Q Type+strToType s = do+  TyConI d <- reify s+  case d of+    DataD _ n _ _ _ -> conT $ simpleName n+    NewtypeD _ n _ _ _ -> conT $ simpleName n+    TySynD n _ _ -> conT $ simpleName n+  where+    simpleName :: Name -> Name+    simpleName nm =+      let s = nameBase nm+      in case dropWhile (/=':') s of+        []          -> mkName s+        _:[]        -> mkName s+        _:t         -> mkName t+

+ LICENSE view

@@ -0,0 +1,661 @@+                    GNU AFFERO GENERAL PUBLIC LICENSE+                       Version 3, 19 November 2007++ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>+ Everyone is permitted to copy and distribute verbatim copies+ of this license document, but changing it is not allowed.++                            Preamble++  The GNU Affero General Public License is a free, copyleft license for+software and other kinds of works, specifically designed to ensure+cooperation with the community in the case of network server software.++  The licenses for most software and other practical works are designed+to take away your freedom to share and change the works.  By contrast,+our General Public Licenses are intended to guarantee your freedom to+share and change all versions of a program--to make sure it remains free+software for all its users.++  When we speak of free software, we are referring to freedom, not+price.  Our General Public Licenses are designed to make sure that you+have the freedom to distribute copies of free software (and charge for+them if you wish), that you receive source code or can get it if you+want it, that you can change the software or use pieces of it in new+free programs, and that you know you can do these things.++  Developers that use our General Public Licenses protect your rights+with two steps: (1) assert copyright on the software, and (2) offer+you this License which gives you legal permission to copy, distribute+and/or modify the software.++  A secondary benefit of defending all users' freedom is that+improvements made in alternate versions of the program, if they+receive widespread use, become available for other developers to+incorporate.  Many developers of free software are heartened and+encouraged by the resulting cooperation.  However, in the case of+software used on network servers, this result may fail to come about.+The GNU General Public License permits making a modified version and+letting the public access it on a server without ever releasing its+source code to the public.++  The GNU Affero General Public License is designed specifically to+ensure that, in such cases, the modified source code becomes available+to the community.  It requires the operator of a network server to+provide the source code of the modified version running there to the+users of that server.  Therefore, public use of a modified version, on+a publicly accessible server, gives the public access to the source+code of the modified version.++  An older license, called the Affero General Public License and+published by Affero, was designed to accomplish similar goals.  This is+a different license, not a version of the Affero GPL, but Affero has+released a new version of the Affero GPL which permits relicensing under+this license.++  The precise terms and conditions for copying, distribution and+modification follow.++                       TERMS AND CONDITIONS++  0. Definitions.++  "This License" refers to version 3 of the GNU Affero General Public License.++  "Copyright" also means copyright-like laws that apply to other kinds of+works, such as semiconductor masks.++  "The Program" refers to any copyrightable work licensed under this+License.  Each licensee is addressed as "you".  "Licensees" and+"recipients" may be individuals or organizations.++  To "modify" a work means to copy from or adapt all or part of the work+in a fashion requiring copyright permission, other than the making of an+exact copy.  The resulting work is called a "modified version" of the+earlier work or a work "based on" the earlier work.++  A "covered work" means either the unmodified Program or a work based+on the Program.++  To "propagate" a work means to do anything with it that, without+permission, would make you directly or secondarily liable for+infringement under applicable copyright law, except executing it on a+computer or modifying a private copy.  Propagation includes copying,+distribution (with or without modification), making available to the+public, and in some countries other activities as well.++  To "convey" a work means any kind of propagation that enables other+parties to make or receive copies.  Mere interaction with a user through+a computer network, with no transfer of a copy, is not conveying.++  An interactive user interface displays "Appropriate Legal Notices"+to the extent that it includes a convenient and prominently visible+feature that (1) displays an appropriate copyright notice, and (2)+tells the user that there is no warranty for the work (except to the+extent that warranties are provided), that licensees may convey the+work under this License, and how to view a copy of this License.  If+the interface presents a list of user commands or options, such as a+menu, a prominent item in the list meets this criterion.++  1. Source Code.++  The "source code" for a work means the preferred form of the work+for making modifications to it.  "Object code" means any non-source+form of a work.++  A "Standard Interface" means an interface that either is an official+standard defined by a recognized standards body, or, in the case of+interfaces specified for a particular programming language, one that+is widely used among developers working in that language.++  The "System Libraries" of an executable work include anything, other+than the work as a whole, that (a) is included in the normal form of+packaging a Major Component, but which is not part of that Major+Component, and (b) serves only to enable use of the work with that+Major Component, or to implement a Standard Interface for which an+implementation is available to the public in source code form.  A+"Major Component", in this context, means a major essential component+(kernel, window system, and so on) of the specific operating system+(if any) on which the executable work runs, or a compiler used to+produce the work, or an object code interpreter used to run it.++  The "Corresponding Source" for a work in object code form means all+the source code needed to generate, install, and (for an executable+work) run the object code and to modify the work, including scripts to+control those activities.  However, it does not include the work's+System Libraries, or general-purpose tools or generally available free+programs which are used unmodified in performing those activities but+which are not part of the work.  For example, Corresponding Source+includes interface definition files associated with source files for+the work, and the source code for shared libraries and dynamically+linked subprograms that the work is specifically designed to require,+such as by intimate data communication or control flow between those+subprograms and other parts of the work.++  The Corresponding Source need not include anything that users+can regenerate automatically from other parts of the Corresponding+Source.++  The Corresponding Source for a work in source code form is that+same work.++  2. Basic Permissions.++  All rights granted under this License are granted for the term of+copyright on the Program, and are irrevocable provided the stated+conditions are met.  This License explicitly affirms your unlimited+permission to run the unmodified Program.  The output from running a+covered work is covered by this License only if the output, given its+content, constitutes a covered work.  This License acknowledges your+rights of fair use or other equivalent, as provided by copyright law.++  You may make, run and propagate covered works that you do not+convey, without conditions so long as your license otherwise remains+in force.  You may convey covered works to others for the sole purpose+of having them make modifications exclusively for you, or provide you+with facilities for running those works, provided that you comply with+the terms of this License in conveying all material for which you do+not control copyright.  Those thus making or running the covered works+for you must do so exclusively on your behalf, under your direction+and control, on terms that prohibit them from making any copies of+your copyrighted material outside their relationship with you.++  Conveying under any other circumstances is permitted solely under+the conditions stated below.  Sublicensing is not allowed; section 10+makes it unnecessary.++  3. Protecting Users' Legal Rights From Anti-Circumvention Law.++  No covered work shall be deemed part of an effective technological+measure under any applicable law fulfilling obligations under article+11 of the WIPO copyright treaty adopted on 20 December 1996, or+similar laws prohibiting or restricting circumvention of such+measures.++  When you convey a covered work, you waive any legal power to forbid+circumvention of technological measures to the extent such circumvention+is effected by exercising rights under this License with respect to+the covered work, and you disclaim any intention to limit operation or+modification of the work as a means of enforcing, against the work's+users, your or third parties' legal rights to forbid circumvention of+technological measures.++  4. Conveying Verbatim Copies.++  You may convey verbatim copies of the Program's source code as you+receive it, in any medium, provided that you conspicuously and+appropriately publish on each copy an appropriate copyright notice;+keep intact all notices stating that this License and any+non-permissive terms added in accord with section 7 apply to the code;+keep intact all notices of the absence of any warranty; and give all+recipients a copy of this License along with the Program.++  You may charge any price or no price for each copy that you convey,+and you may offer support or warranty protection for a fee.++  5. Conveying Modified Source Versions.++  You may convey a work based on the Program, or the modifications to+produce it from the Program, in the form of source code under the+terms of section 4, provided that you also meet all of these conditions:++    a) The work must carry prominent notices stating that you modified+    it, and giving a relevant date.++    b) The work must carry prominent notices stating that it is+    released under this License and any conditions added under section+    7.  This requirement modifies the requirement in section 4 to+    "keep intact all notices".++    c) You must license the entire work, as a whole, under this+    License to anyone who comes into possession of a copy.  This+    License will therefore apply, along with any applicable section 7+    additional terms, to the whole of the work, and all its parts,+    regardless of how they are packaged.  This License gives no+    permission to license the work in any other way, but it does not+    invalidate such permission if you have separately received it.++    d) If the work has interactive user interfaces, each must display+    Appropriate Legal Notices; however, if the Program has interactive+    interfaces that do not display Appropriate Legal Notices, your+    work need not make them do so.++  A compilation of a covered work with other separate and independent+works, which are not by their nature extensions of the covered work,+and which are not combined with it such as to form a larger program,+in or on a volume of a storage or distribution medium, is called an+"aggregate" if the compilation and its resulting copyright are not+used to limit the access or legal rights of the compilation's users+beyond what the individual works permit.  Inclusion of a covered work+in an aggregate does not cause this License to apply to the other+parts of the aggregate.++  6. Conveying Non-Source Forms.++  You may convey a covered work in object code form under the terms+of sections 4 and 5, provided that you also convey the+machine-readable Corresponding Source under the terms of this License,+in one of these ways:++    a) Convey the object code in, or embodied in, a physical product+    (including a physical distribution medium), accompanied by the+    Corresponding Source fixed on a durable physical medium+    customarily used for software interchange.++    b) Convey the object code in, or embodied in, a physical product+    (including a physical distribution medium), accompanied by a+    written offer, valid for at least three years and valid for as+    long as you offer spare parts or customer support for that product+    model, to give anyone who possesses the object code either (1) a+    copy of the Corresponding Source for all the software in the+    product that is covered by this License, on a durable physical+    medium customarily used for software interchange, for a price no+    more than your reasonable cost of physically performing this+    conveying of source, or (2) access to copy the+    Corresponding Source from a network server at no charge.++    c) Convey individual copies of the object code with a copy of the+    written offer to provide the Corresponding Source.  This+    alternative is allowed only occasionally and noncommercially, and+    only if you received the object code with such an offer, in accord+    with subsection 6b.++    d) Convey the object code by offering access from a designated+    place (gratis or for a charge), and offer equivalent access to the+    Corresponding Source in the same way through the same place at no+    further charge.  You need not require recipients to copy the+    Corresponding Source along with the object code.  If the place to+    copy the object code is a network server, the Corresponding Source+    may be on a different server (operated by you or a third party)+    that supports equivalent copying facilities, provided you maintain+    clear directions next to the object code saying where to find the+    Corresponding Source.  Regardless of what server hosts the+    Corresponding Source, you remain obligated to ensure that it is+    available for as long as needed to satisfy these requirements.++    e) Convey the object code using peer-to-peer transmission, provided+    you inform other peers where the object code and Corresponding+    Source of the work are being offered to the general public at no+    charge under subsection 6d.++  A separable portion of the object code, whose source code is excluded+from the Corresponding Source as a System Library, need not be+included in conveying the object code work.++  A "User Product" is either (1) a "consumer product", which means any+tangible personal property which is normally used for personal, family,+or household purposes, or (2) anything designed or sold for incorporation+into a dwelling.  In determining whether a product is a consumer product,+doubtful cases shall be resolved in favor of coverage.  For a particular+product received by a particular user, "normally used" refers to a+typical or common use of that class of product, regardless of the status+of the particular user or of the way in which the particular user+actually uses, or expects or is expected to use, the product.  A product+is a consumer product regardless of whether the product has substantial+commercial, industrial or non-consumer uses, unless such uses represent+the only significant mode of use of the product.++  "Installation Information" for a User Product means any methods,+procedures, authorization keys, or other information required to install+and execute modified versions of a covered work in that User Product from+a modified version of its Corresponding Source.  The information must+suffice to ensure that the continued functioning of the modified object+code is in no case prevented or interfered with solely because+modification has been made.++  If you convey an object code work under this section in, or with, or+specifically for use in, a User Product, and the conveying occurs as+part of a transaction in which the right of possession and use of the+User Product is transferred to the recipient in perpetuity or for a+fixed term (regardless of how the transaction is characterized), the+Corresponding Source conveyed under this section must be accompanied+by the Installation Information.  But this requirement does not apply+if neither you nor any third party retains the ability to install+modified object code on the User Product (for example, the work has+been installed in ROM).++  The requirement to provide Installation Information does not include a+requirement to continue to provide support service, warranty, or updates+for a work that has been modified or installed by the recipient, or for+the User Product in which it has been modified or installed.  Access to a+network may be denied when the modification itself materially and+adversely affects the operation of the network or violates the rules and+protocols for communication across the network.++  Corresponding Source conveyed, and Installation Information provided,+in accord with this section must be in a format that is publicly+documented (and with an implementation available to the public in+source code form), and must require no special password or key for+unpacking, reading or copying.++  7. Additional Terms.++  "Additional permissions" are terms that supplement the terms of this+License by making exceptions from one or more of its conditions.+Additional permissions that are applicable to the entire Program shall+be treated as though they were included in this License, to the extent+that they are valid under applicable law.  If additional permissions+apply only to part of the Program, that part may be used separately+under those permissions, but the entire Program remains governed by+this License without regard to the additional permissions.++  When you convey a copy of a covered work, you may at your option+remove any additional permissions from that copy, or from any part of+it.  (Additional permissions may be written to require their own+removal in certain cases when you modify the work.)  You may place+additional permissions on material, added by you to a covered work,+for which you have or can give appropriate copyright permission.++  Notwithstanding any other provision of this License, for material you+add to a covered work, you may (if authorized by the copyright holders of+that material) supplement the terms of this License with terms:++    a) Disclaiming warranty or limiting liability differently from the+    terms of sections 15 and 16 of this License; or++    b) Requiring preservation of specified reasonable legal notices or+    author attributions in that material or in the Appropriate Legal+    Notices displayed by works containing it; or++    c) Prohibiting misrepresentation of the origin of that material, or+    requiring that modified versions of such material be marked in+    reasonable ways as different from the original version; or++    d) Limiting the use for publicity purposes of names of licensors or+    authors of the material; or++    e) Declining to grant rights under trademark law for use of some+    trade names, trademarks, or service marks; or++    f) Requiring indemnification of licensors and authors of that+    material by anyone who conveys the material (or modified versions of+    it) with contractual assumptions of liability to the recipient, for+    any liability that these contractual assumptions directly impose on+    those licensors and authors.++  All other non-permissive additional terms are considered "further+restrictions" within the meaning of section 10.  If the Program as you+received it, or any part of it, contains a notice stating that it is+governed by this License along with a term that is a further+restriction, you may remove that term.  If a license document contains+a further restriction but permits relicensing or conveying under this+License, you may add to a covered work material governed by the terms+of that license document, provided that the further restriction does+not survive such relicensing or conveying.++  If you add terms to a covered work in accord with this section, you+must place, in the relevant source files, a statement of the+additional terms that apply to those files, or a notice indicating+where to find the applicable terms.++  Additional terms, permissive or non-permissive, may be stated in the+form of a separately written license, or stated as exceptions;+the above requirements apply either way.++  8. Termination.++  You may not propagate or modify a covered work except as expressly+provided under this License.  Any attempt otherwise to propagate or+modify it is void, and will automatically terminate your rights under+this License (including any patent licenses granted under the third+paragraph of section 11).++  However, if you cease all violation of this License, then your+license from a particular copyright holder is reinstated (a)+provisionally, unless and until the copyright holder explicitly and+finally terminates your license, and (b) permanently, if the copyright+holder fails to notify you of the violation by some reasonable means+prior to 60 days after the cessation.++  Moreover, your license from a particular copyright holder is+reinstated permanently if the copyright holder notifies you of the+violation by some reasonable means, this is the first time you have+received notice of violation of this License (for any work) from that+copyright holder, and you cure the violation prior to 30 days after+your receipt of the notice.++  Termination of your rights under this section does not terminate the+licenses of parties who have received copies or rights from you under+this License.  If your rights have been terminated and not permanently+reinstated, you do not qualify to receive new licenses for the same+material under section 10.++  9. Acceptance Not Required for Having Copies.++  You are not required to accept this License in order to receive or+run a copy of the Program.  Ancillary propagation of a covered work+occurring solely as a consequence of using peer-to-peer transmission+to receive a copy likewise does not require acceptance.  However,+nothing other than this License grants you permission to propagate or+modify any covered work.  These actions infringe copyright if you do+not accept this License.  Therefore, by modifying or propagating a+covered work, you indicate your acceptance of this License to do so.++  10. Automatic Licensing of Downstream Recipients.++  Each time you convey a covered work, the recipient automatically+receives a license from the original licensors, to run, modify and+propagate that work, subject to this License.  You are not responsible+for enforcing compliance by third parties with this License.++  An "entity transaction" is a transaction transferring control of an+organization, or substantially all assets of one, or subdividing an+organization, or merging organizations.  If propagation of a covered+work results from an entity transaction, each party to that+transaction who receives a copy of the work also receives whatever+licenses to the work the party's predecessor in interest had or could+give under the previous paragraph, plus a right to possession of the+Corresponding Source of the work from the predecessor in interest, if+the predecessor has it or can get it with reasonable efforts.++  You may not impose any further restrictions on the exercise of the+rights granted or affirmed under this License.  For example, you may+not impose a license fee, royalty, or other charge for exercise of+rights granted under this License, and you may not initiate litigation+(including a cross-claim or counterclaim in a lawsuit) alleging that+any patent claim is infringed by making, using, selling, offering for+sale, or importing the Program or any portion of it.++  11. Patents.++  A "contributor" is a copyright holder who authorizes use under this+License of the Program or a work on which the Program is based.  The+work thus licensed is called the contributor's "contributor version".++  A contributor's "essential patent claims" are all patent claims+owned or controlled by the contributor, whether already acquired or+hereafter acquired, that would be infringed by some manner, permitted+by this License, of making, using, or selling its contributor version,+but do not include claims that would be infringed only as a+consequence of further modification of the contributor version.  For+purposes of this definition, "control" includes the right to grant+patent sublicenses in a manner consistent with the requirements of+this License.++  Each contributor grants you a non-exclusive, worldwide, royalty-free+patent license under the contributor's essential patent claims, to+make, use, sell, offer for sale, import and otherwise run, modify and+propagate the contents of its contributor version.++  In the following three paragraphs, a "patent license" is any express+agreement or commitment, however denominated, not to enforce a patent+(such as an express permission to practice a patent or covenant not to+sue for patent infringement).  To "grant" such a patent license to a+party means to make such an agreement or commitment not to enforce a+patent against the party.++  If you convey a covered work, knowingly relying on a patent license,+and the Corresponding Source of the work is not available for anyone+to copy, free of charge and under the terms of this License, through a+publicly available network server or other readily accessible means,+then you must either (1) cause the Corresponding Source to be so+available, or (2) arrange to deprive yourself of the benefit of the+patent license for this particular work, or (3) arrange, in a manner+consistent with the requirements of this License, to extend the patent+license to downstream recipients.  "Knowingly relying" means you have+actual knowledge that, but for the patent license, your conveying the+covered work in a country, or your recipient's use of the covered work+in a country, would infringe one or more identifiable patents in that+country that you have reason to believe are valid.++  If, pursuant to or in connection with a single transaction or+arrangement, you convey, or propagate by procuring conveyance of, a+covered work, and grant a patent license to some of the parties+receiving the covered work authorizing them to use, propagate, modify+or convey a specific copy of the covered work, then the patent license+you grant is automatically extended to all recipients of the covered+work and works based on it.++  A patent license is "discriminatory" if it does not include within+the scope of its coverage, prohibits the exercise of, or is+conditioned on the non-exercise of one or more of the rights that are+specifically granted under this License.  You may not convey a covered+work if you are a party to an arrangement with a third party that is+in the business of distributing software, under which you make payment+to the third party based on the extent of your activity of conveying+the work, and under which the third party grants, to any of the+parties who would receive the covered work from you, a discriminatory+patent license (a) in connection with copies of the covered work+conveyed by you (or copies made from those copies), or (b) primarily+for and in connection with specific products or compilations that+contain the covered work, unless you entered into that arrangement,+or that patent license was granted, prior to 28 March 2007.++  Nothing in this License shall be construed as excluding or limiting+any implied license or other defenses to infringement that may+otherwise be available to you under applicable patent law.++  12. No Surrender of Others' Freedom.++  If conditions are imposed on you (whether by court order, agreement or+otherwise) that contradict the conditions of this License, they do not+excuse you from the conditions of this License.  If you cannot convey a+covered work so as to satisfy simultaneously your obligations under this+License and any other pertinent obligations, then as a consequence you may+not convey it at all.  For example, if you agree to terms that obligate you+to collect a royalty for further conveying from those to whom you convey+the Program, the only way you could satisfy both those terms and this+License would be to refrain entirely from conveying the Program.++  13. Remote Network Interaction; Use with the GNU General Public License.++  Notwithstanding any other provision of this License, if you modify the+Program, your modified version must prominently offer all users+interacting with it remotely through a computer network (if your version+supports such interaction) an opportunity to receive the Corresponding+Source of your version by providing access to the Corresponding Source+from a network server at no charge, through some standard or customary+means of facilitating copying of software.  This Corresponding Source+shall include the Corresponding Source for any work covered by version 3+of the GNU General Public License that is incorporated pursuant to the+following paragraph.++  Notwithstanding any other provision of this License, you have+permission to link or combine any covered work with a work licensed+under version 3 of the GNU General Public License into a single+combined work, and to convey the resulting work.  The terms of this+License will continue to apply to the part which is the covered work,+but the work with which it is combined will remain governed by version+3 of the GNU General Public License.++  14. Revised Versions of this License.++  The Free Software Foundation may publish revised and/or new versions of+the GNU Affero General Public License from time to time.  Such new versions+will be similar in spirit to the present version, but may differ in detail to+address new problems or concerns.++  Each version is given a distinguishing version number.  If the+Program specifies that a certain numbered version of the GNU Affero General+Public License "or any later version" applies to it, you have the+option of following the terms and conditions either of that numbered+version or of any later version published by the Free Software+Foundation.  If the Program does not specify a version number of the+GNU Affero General Public License, you may choose any version ever published+by the Free Software Foundation.++  If the Program specifies that a proxy can decide which future+versions of the GNU Affero General Public License can be used, that proxy's+public statement of acceptance of a version permanently authorizes you+to choose that version for the Program.++  Later license versions may give you additional or different+permissions.  However, no additional obligations are imposed on any+author or copyright holder as a result of your choosing to follow a+later version.++  15. Disclaimer of Warranty.++  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.++  16. Limitation of Liability.++  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF+SUCH DAMAGES.++  17. Interpretation of Sections 15 and 16.++  If the disclaimer of warranty and limitation of liability provided+above cannot be given local legal effect according to their terms,+reviewing courts shall apply local law that most closely approximates+an absolute waiver of all civil liability in connection with the+Program, unless a warranty or assumption of liability accompanies a+copy of the Program in return for a fee.++                     END OF TERMS AND CONDITIONS++            How to Apply These Terms to Your New Programs++  If you develop a new program, and you want it to be of the greatest+possible use to the public, the best way to achieve this is to make it+free software which everyone can redistribute and change under these terms.++  To do so, attach the following notices to the program.  It is safest+to attach them to the start of each source file to most effectively+state the exclusion of warranty; and each file should have at least+the "copyright" line and a pointer to where the full notice is found.++    <one line to give the program's name and a brief idea of what it does.>+    Copyright (C) <year>  <name of author>++    This program 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.++    This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.++Also add information on how to contact you by electronic and paper mail.++  If your software can interact with users remotely through a computer+network, you should also make sure that it provides a way for users to+get its source.  For example, if your program is a web application, its+interface could display a "Source" link that leads users to an archive+of the code.  There are many ways you could offer source, and different+solutions will be better for different programs; see section 13 for the+specific requirements.++  You should also get your employer (if you work as a programmer) or school,+if any, to sign a "copyright disclaimer" for the program, if necessary.+For more information on this, and how to apply and follow the GNU AGPL, see+<http://www.gnu.org/licenses/>.

+ Setup.hs view

@@ -0,0 +1,2 @@+import Distribution.Simple+main = defaultMain

+ chatty.cabal view

@@ -0,0 +1,67 @@+-- Initial chatty.cabal generated by cabal init.  For further +-- documentation, see http://haskell.org/cabal/users-guide/++-- The name of the package.+name:                chatty++-- The package version.  See the Haskell package versioning policy (PVP) +-- for standards guiding when and how versions should be incremented.+-- http://www.haskell.org/haskellwiki/Package_versioning_policy+-- PVP summary:      +-+------- breaking API changes+--                   | | +----- non-breaking API additions+--                   | | | +--- code changes with no API change+version:             0.1.4.0++-- A short (one-line) description of the package.+synopsis:            Some monad transformers and typeclasses to simplify I/O on a transformer stack.++-- 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.++-- The license under which the package is released.+license:             AGPL-3++-- The file containing the license text.+license-file:        LICENSE++-- The package author(s).+author:              Marvin Cohrs++-- An email address to which users can send suggestions, bug reports, and +-- patches.+maintainer:          marvin.cohrs@gmx.net++-- A copyright notice.+-- copyright:           ++category:            Text++build-type:          Simple++-- Extra files to be distributed with the package, such as examples or a +-- README.+-- extra-source-files:  ++-- Constraint on the version of Cabal needed to build this package.+cabal-version:       >=1.10+++library+  -- Modules exported by the library.+  exposed-modules:     Chatty.Expansion, Chatty.Commands, Chatty.Spawn, Chatty.Printer, Chatty.Finalizer, Chatty.Templates, Chatty.Scanner, Chatty.Interactor, Chatty.Spawn.Overlay, Chatty.Spawn.Builtins, Chatty.Interactor.Templates, Chatty.Misc, Chatty.Extended.Printer, Chatty.Extended.HTML, Chatty.Extended.ANSI+  +  -- Modules included in this library but not exported.+  -- other-modules:       +  +  -- LANGUAGE extensions used by modules in this package.+  other-extensions:    ExistentialQuantification, RankNTypes, Rank2Types, FlexibleInstances, MultiParamTypeClasses, FunctionalDependencies, TemplateHaskell, QuasiQuotes+  +  -- Other library packages from which modules are imported.+  build-depends:       base >=4.6 && <4.7, transformers >=0.3 && <0.4, directory >=1.2 && <1.3, process >=1.1 && <1.2, mtl >=2.1 && <2.2, template-haskell >=2.8 && <2.9, setenv >= 0.1 && <0.2, unix >= 2.6 && < 2.7, random >= 1.0 && < 1.1, time >= 1.4 && < 1.5, ansi-terminal >= 0.6 && <0.7+  +  -- Directories containing source files.+  -- hs-source-dirs:      +  +  -- Base language which the package is written in.+  default-language:    Haskell2010+