snap-core-0.9.8.0: Snap: A Haskell Web Framework (core interfaces and types)

Safe HaskellNone

Snap.Iteratee

Contents

Description

Snap Framework type aliases and utilities for iteratees. Note that as a convenience, this module also exports everything from Data.Enumerator in the enumerator library.

Synopsis

Enumerators

enumBS :: Monad m => ByteString -> Enumerator ByteString m aSource

Enumerates a strict bytestring.

enumLBS :: Monad m => ByteString -> Enumerator ByteString m aSource

Enumerates a lazy bytestring.

enumBuilder :: Monad m => Builder -> Enumerator Builder m aSource

Enumerates a Builder.

enumFile :: FilePath -> Enumerator ByteString IO aSource

enumFilePartial :: FilePath -> (Int64, Int64) -> Enumerator ByteString IO aSource

Iteratee utilities

joinI' :: Monad m => Iteratee a m (Step a m b) -> Iteratee a m bSource

countBytes :: Monad m => forall a. Iteratee ByteString m a -> Iteratee ByteString m (a, Int64)Source

Wraps an Iteratee, counting the number of bytes consumed by it.

drop' :: Monad m => Int64 -> Iteratee ByteString m ()Source

Skip n elements of the stream, if there are that many

mkIterateeBuffer :: IO (ForeignPtr CChar)Source

Creates a buffer to be passed into unsafeBufferIterateeWithBuffer.

unsafeBufferIterateeWithBuffer :: ForeignPtr CChar -> Iteratee ByteString IO a -> Iteratee ByteString IO aSource

Buffers an iteratee, "unsafely". Here we use a fixed binary buffer which we'll re-use, meaning that if you hold on to any of the bytestring data passed into your iteratee (instead of, let's say, shoving it right out a socket) it'll get changed out from underneath you, breaking referential transparency. Use with caution!

This version accepts a buffer created by mkIterateeBuffer.

unsafeBufferIteratee :: Iteratee ByteString IO a -> IO (Iteratee ByteString IO a)Source

Buffers an iteratee, "unsafely". Here we use a fixed binary buffer which we'll re-use, meaning that if you hold on to any of the bytestring data passed into your iteratee (instead of, let's say, shoving it right out a socket) it'll get changed out from underneath you, breaking referential transparency. Use with caution!

take :: Monad m => Int -> Enumeratee ByteString ByteString m aSource

drop :: Monad m => Int -> Iteratee ByteString m ()Source

Skip n elements of the stream, if there are that many

takeExactly :: Monad m => Int64 -> Enumeratee ByteString ByteString m aSource

Reads n bytes from a stream and applies the given iteratee to the stream of the read elements. Reads exactly n bytes, and if the stream is short propagates an error.

takeNoMoreThan :: Monad m => Int64 -> Enumeratee ByteString ByteString m aSource

skipToEof :: Monad m => Iteratee a m ()Source

mapEnum :: Monad m => (aOut -> aIn) -> (aIn -> aOut) -> Enumerator aIn m a -> Enumerator aOut m aSource

mapIter :: Monad m => (aOut -> aIn) -> (aIn -> aOut) -> Iteratee aIn m a -> Iteratee aOut m aSource

enumBuilderToByteString :: MonadIO m => Enumeratee Builder ByteString m aSource

unsafeEnumBuilderToByteString :: MonadIO m => Enumeratee Builder ByteString m aSource

enumByteStringToBuilder :: MonadIO m => Enumeratee ByteString Builder m aSource

killIfTooSlowSource

Arguments

:: MonadIO m 
=> m ()

action to bump timeout

-> Double

minimum data rate, in bytes per second

-> Int

minimum amount of time to let the iteratee run for

-> Iteratee ByteString m a

iteratee consumer to wrap

-> Iteratee ByteString m a 

Re-export types and functions from Data.Enumerator

data Stream a

Constructors

Chunks [a] 
EOF 

Instances

Monad Stream 
Functor Stream 
Typeable1 Stream 
Applicative Stream 
Eq a => Eq (Stream a) 
Show a => Show (Stream a) 
Monoid (Stream a) 

data Step a m b

Constructors

Continue (Stream a -> Iteratee a m b) 
Yield b (Stream a) 
Error SomeException 

Instances

(Typeable a, Typeable1 m) => Typeable1 (Step a m) 

newtype Iteratee a m b

Constructors

Iteratee 

Fields

runIteratee :: m (Step a m b)
 

Instances

MonadTrans (Iteratee a) 
Monad m => Monad (Iteratee a m) 
Monad m => Functor (Iteratee a m) 
(Typeable a, Typeable1 m) => Typeable1 (Iteratee a m) 
Monad m => Applicative (Iteratee a m) 
MonadIO m => MonadIO (Iteratee a m) 
(Functor m, MonadCatchIO m) => MonadCatchIO (Iteratee s m) 

type Enumerator a m b = Step a m b -> Iteratee a m b

type Enumeratee ao ai m b = Step ai m b -> Iteratee ao m (Step ai m b)

Primitives

Combinators

These are common patterns which occur whenever iteratees are being defined.

returnI :: Monad m => Step a m b -> Iteratee a m b

yield :: Monad m => b -> Stream a -> Iteratee a m b

continue :: Monad m => (Stream a -> Iteratee a m b) -> Iteratee a m b

throwError :: (Monad m, Exception e) => e -> Iteratee a m b

catchError :: Monad m => Iteratee a m b -> (SomeException -> Iteratee a m b) -> Iteratee a m b

liftI :: Monad m => (Stream a -> Step a m b) -> Iteratee a m b

(>>==) :: Monad m => Iteratee a m b -> (Step a m b -> Iteratee a' m b') -> Iteratee a' m b'

(==<<) :: Monad m => (Step a m b -> Iteratee a' m b') -> Iteratee a m b -> Iteratee a' m b'

($$) :: Monad m => (Step a m b -> Iteratee a' m b') -> Iteratee a m b -> Iteratee a' m b'

(>==>) :: Monad m => Enumerator a m b -> (Step a m b -> Iteratee a' m b') -> Step a m b -> Iteratee a' m b'

(<==<) :: Monad m => (Step a m b -> Iteratee a' m b') -> Enumerator a m b -> Step a m b -> Iteratee a' m b'

($=) :: Monad m => Enumerator ao m (Step ai m b) -> Enumeratee ao ai m b -> Enumerator ai m b

(=$) :: Monad m => Enumeratee ao ai m b -> Iteratee ai m b -> Iteratee ao m b

Iteratees

run :: Monad m => Iteratee a m b -> m (Either SomeException b)

run_ :: Monad m => Iteratee a m b -> m b

consume :: Monad m => Iteratee a m [a]

isEOF :: Monad m => Iteratee a m Bool

liftTrans :: (Monad m, MonadTrans t, Monad (t m)) => Iteratee a m b -> Iteratee a (t m) b

liftFoldL :: Monad m => (b -> a -> b) -> b -> Iteratee a m b

liftFoldL' :: Monad m => (b -> a -> b) -> b -> Iteratee a m b

liftFoldM :: Monad m => (b -> a -> m b) -> b -> Iteratee a m b

printChunks :: (MonadIO m, Show a) => Bool -> Iteratee a m ()

head :: Monad m => Iteratee a m (Maybe a)

peek :: Monad m => Iteratee a m (Maybe a)

Enumerators

enumEOF :: Monad m => Enumerator a m b

enumList :: Monad m => Integer -> [a] -> Enumerator a m b

concatEnums :: Monad m => [Enumerator a m b] -> Enumerator a m b

Enumeratees

checkDone :: Monad m => ((Stream a -> Iteratee a m b) -> Iteratee a' m (Step a m b)) -> Enumeratee a' a m b

map :: Monad m => (ao -> ai) -> Enumeratee ao ai m b

sequence :: Monad m => Iteratee ao m ai -> Enumeratee ao ai m b

joinI :: Monad m => Iteratee a m (Step a' m b) -> Iteratee a m b