-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | simple pipeline library like conduit
--   
--   examples/upperFile.hs
--   
--   <ul>
--   <li>read file (sample.txt)</li>
--   <li>take 3 lines</li>
--   <li>to upper all lines</li>
--   <li>write to stdout</li>
--   </ul>
--   
--   extensions
--   
--   <ul>
--   <li>PackageImports</li>
--   </ul>
--   
--   <pre>
--   import Data.Pipe
--   import Data.Char
--   import System.IO
--   import "monads-tf" Control.Monad.Trans
--   
--   main :: IO ()
--   main = do
--   	_ &lt;- runPipe $ readFileP "sample.txt"
--   	=$= takeP 3
--   	=$= convert (map toUpper)
--   	=$= writeString
--   	return ()
--   
--   readFileP :: FilePath -&gt; Pipe () String IO ()
--   readFileP fp = bracket (openFile fp ReadMode) hClose hRead
--   
--   hRead :: Handle -&gt; Pipe () String IO ()
--   hRead h = do
--   	eof &lt;- lift $ hIsEOF h
--   	if eof then return () else do
--   		l &lt;- lift $ hGetLine h
--   		yield l
--   		hRead h
--   
--   writeString :: Pipe String () IO ()
--   writeString = do
--   	ms &lt;- await
--   	case ms of
--   		Just s -&gt; lift (putStrLn s) &gt;&gt; writeString
--   		_ -&gt; return ()
--   
--   takeP :: Monad m =&gt; Int -&gt; Pipe a a m ()
--   takeP 0 = return ()
--   takeP n = do
--   mx &lt;- await
--   case mx of
--   	Just x -&gt; yield x &gt;&gt; takeP (n - 1)
--   	_ -&gt; return ()
--   </pre>
@package simple-pipe
@version 0.0.0.18

module Data.Pipe
class PipeClass p where p finalize f = p `onBreak` f `onDone` f
runPipe :: (PipeClass p, Monad m) => p i o m r -> m (Maybe r)
(=$=) :: (PipeClass p, Monad m) => p a b m x -> p b c m y -> p a c m y
yield :: (PipeClass p, Monad m) => o -> p i o m ()
await :: (PipeClass p, Monad m) => p i o m (Maybe i)
onBreak :: (PipeClass p, Monad m) => p i o m r -> m b -> p i o m r
onDone :: (PipeClass p, Monad m) => p i o m r -> m b -> p i o m r
finalize :: (PipeClass p, Monad m) => p i o m r -> m b -> p i o m r
mapMonad :: (PipeClass p, Monad m) => (forall a. m a -> m a) -> p i o m r -> p i o m r
mapOut :: (PipeClass p, Monad m) => (o -> o') -> p i o m r -> p i o' m r
mapIn :: (PipeClass p, Monad m) => (i' -> i) -> p i o m r -> p i' o m r

-- | Minimal complete definition: <a>appLeft</a>
class PipeClass pc => PipeChoice pc where appRight f = mapIn mirror . mapOut mirror $ appLeft f where mirror (Left x) = Right x mirror (Right y) = Left y f ++++ g = appLeft f =$= appRight g f |||| g = mapOut untag (f ++++ g) where untag (Left x) = x untag (Right y) = y
appLeft :: (PipeChoice pc, Monad m) => pc b c m r -> pc (Either b d) (Either c d) m r
appRight :: (PipeChoice pc, Monad m) => pc b c m r -> pc (Either d b) (Either d c) m r
(++++) :: (PipeChoice pc, Monad m) => pc b c m r -> pc b' c' m r -> pc (Either b b') (Either c c') m r
(||||) :: (PipeChoice pc, Monad m) => pc b d m r -> pc c d m r -> pc (Either b c) d m r
(=@=) :: (PipeClass p, PipeChoice p, Monad m, Monad (p i (Either a r) m), Monad (p a o m), Monad (p r o m), Monad (p (Either a r) o m)) => p i a m r -> p a o m r' -> p i o m r
convert :: (PipeClass p, Monad m, Monad (p a b m)) => (a -> b) -> p a b m ()
data Pipe i o m r
finally :: (MonadBaseControl IO m, PipeClass p) => p i o m r -> m b -> p i o m r
bracket :: (MonadBaseControl IO m, PipeClass p, MonadTrans (p i o), Monad (p i o m)) => m a -> (a -> m b) -> (a -> p i o m r) -> p i o m r
instance MonadReader m => MonadReader (Pipe i o m)
instance MonadState m => MonadState (Pipe i o m)
instance MonadIO m => MonadIO (Pipe i o m)
instance MonadTrans (Pipe i o)
instance Monad m => Applicative (Pipe i o m)
instance Monad m => Functor (Pipe i o m)
instance Monad m => Monad (Pipe i o m)
instance PipeClass Pipe
instance MonadError m => MonadError (Pipe i o m)
instance MonadWriter m => MonadWriter (Pipe i o m)
instance PipeChoice Pipe

module Data.Pipe.List
fromList :: (Monad m, Monad (p () a m), PipeClass p) => [a] -> p () a m ()

-- | Consume all values from the stream and return as a list. This will
--   pull all values into memory.
toList :: (Monad m, Monad (p a () m), PipeClass p) => p a () m [a]

module Data.Pipe.IO
fromHandle :: (PipeClass p, Monad m, MonadIO (p i Char m)) => Handle -> p i Char m ()
toHandle :: (PipeClass p, Monad m, MonadIO (p Char o m)) => Handle -> p Char o m ()
fromFile :: (PipeClass p, MonadIO m, MonadBaseControl IO m, MonadTrans (p i Char), MonadIO (p i Char m)) => FilePath -> p i Char m ()
toFile :: (PipeClass p, MonadIO m, MonadBaseControl IO m, MonadTrans (p Char o), MonadIO (p Char o m)) => FilePath -> p Char o m ()

module Data.Pipe.ByteString
fromHandleLn :: (PipeClass p, Monad m, MonadIO (p i ByteString m)) => Handle -> p i ByteString m ()
toHandleLn :: (PipeClass p, Monad m, MonadIO (p ByteString o m)) => Handle -> p ByteString o m ()
fromFileLn :: (PipeClass p, MonadIO m, MonadBaseControl IO m, MonadTrans (p i ByteString), MonadIO (p i ByteString m)) => FilePath -> p i ByteString m ()
toFileLn :: (PipeClass p, MonadIO m, MonadBaseControl IO m, MonadTrans (p ByteString o), MonadIO (p ByteString o m)) => FilePath -> p ByteString o m ()