Bio.Iteratee

Documentation

iGetString :: Int -> Iteratee ByteString m ByteString

Collects a string of a given length. Don't use this for long strings, use takeStream instead.

iterLoop :: (Nullable s, Monad m) => (a -> Iteratee s m a) -> a -> Iteratee s m a

Repeatedly apply an Iteratee to a value until end of stream. Returns the final value.

iLookAhead :: Monoid s => Iteratee s m a -> Iteratee s m a

Run an Iteratee, collect the input. When it finishes, return the result along with *all* input. Effectively allows lookahead. Be careful, this will eat memory if the Iteratee doesn't return speedily.

protectTerm :: (Nullable s, MonadIO m) => Iteratee s m a -> Iteratee s m a

Protects the terminal from binary junk. If i is an Iteratee that might write binary to stdout, then protectTerm i is the same Iteratee, but it will abort if stdout is a terminal device.

parMapChunksIO :: (MonadIO m, Nullable s) => Int -> (s -> IO t) -> Enumeratee s t m a

Parallel map of an IO action over the elements of a stream

This Enumeratee applies an IO action to every chunk of the input stream. These IO actions are run asynchronously in a limited parallel way. Don't forget to evaluate

parRunIO :: MonadIO m => Int -> Enumeratee [IO a] a m b

progressGen :: MonadIO m => (Int -> a -> String) -> Int -> (String -> IO ()) -> Enumeratee [a] [a] m b

A general progress indicator that prints some message after a set number of records have passed through.

progressNum :: MonadIO m => String -> Int -> (String -> IO ()) -> Enumeratee [a] [a] m b

A simple progress indicator that prints the number of records.

progressPos :: MonadIO m => (a -> (Refseq, Int)) -> String -> Refs -> Int -> (String -> IO ()) -> Enumeratee [a] [a] m b

A simple progress indicator that prints a position every set number of passed records.

($==) :: Monad m => Enumerator' hdr input m (Iteratee output m result) -> Enumeratee input output m result -> Enumerator' hdr output m result infixl 1

Compose an Enumerator' with an Enumeratee, giving a new Enumerator'.

class Monad m => MonadIO (m :: * -> *)

Monads in which IO computations may be embedded. Any monad built by applying a sequence of monad transformers to the IO monad will be an instance of this class.

Instances should satisfy the following laws, which state that liftIO is a transformer of monads:

• liftIO . return = return

• liftIO (m >>= f) = liftIO m >>= (liftIO . f)

Minimal complete definition

liftIO

Instances

MonadIO IO

Since: base-4.9.0.0

Defined in Control.Monad.IO.Class

Methods

liftIO :: IO a -> IO a

MonadIO Q

Defined in Language.Haskell.TH.Syntax

Methods

liftIO :: IO a -> Q a

MonadIO m => MonadIO (MaybeT m)

Defined in Control.Monad.Trans.Maybe

Methods

liftIO :: IO a -> MaybeT m a

MonadIO m => MonadIO (ListT m)

Defined in Control.Monad.Trans.List

Methods

liftIO :: IO a -> ListT m a

MonadIO m => MonadIO (ExceptT e m)

Defined in Control.Monad.Trans.Except

Methods

liftIO :: IO a -> ExceptT e m a

MonadIO m => MonadIO (IdentityT m)

Defined in Control.Monad.Trans.Identity

Methods

liftIO :: IO a -> IdentityT m a

(Error e, MonadIO m) => MonadIO (ErrorT e m)

Defined in Control.Monad.Trans.Error

Methods

liftIO :: IO a -> ErrorT e m a

MonadIO m => MonadIO (StateT s m)

Defined in Control.Monad.Trans.State.Lazy

Methods

liftIO :: IO a -> StateT s m a

MonadIO m => MonadIO (StateT s m)

Defined in Control.Monad.Trans.State.Strict

Methods

liftIO :: IO a -> StateT s m a

(Monoid w, MonadIO m) => MonadIO (WriterT w m)

Defined in Control.Monad.Trans.Writer.Lazy

Methods

liftIO :: IO a -> WriterT w m a

(Monoid w, MonadIO m) => MonadIO (WriterT w m)

Defined in Control.Monad.Trans.Writer.Strict

Methods

liftIO :: IO a -> WriterT w m a

(Monoid w, Functor m, MonadIO m) => MonadIO (AccumT w m)

Defined in Control.Monad.Trans.Accum

Methods

liftIO :: IO a -> AccumT w m a

MonadIO m => MonadIO (SelectT r m)

Defined in Control.Monad.Trans.Select

Methods

liftIO :: IO a -> SelectT r m a

(MonadIO m, Nullable s, NullPoint s) => MonadIO (Iteratee s m)

Defined in Bio.Iteratee.Base

Methods

liftIO :: IO a -> Iteratee s m a

MonadIO m => MonadIO (ContT r m)

Defined in Control.Monad.Trans.Cont

Methods

liftIO :: IO a -> ContT r m a

MonadIO m => MonadIO (ReaderT r m)

Defined in Control.Monad.Trans.Reader

Methods

liftIO :: IO a -> ReaderT r m a

(Monoid w, MonadIO m) => MonadIO (RWST r w s m)

Defined in Control.Monad.Trans.RWS.Lazy

Methods

liftIO :: IO a -> RWST r w s m a

(Monoid w, MonadIO m) => MonadIO (RWST r w s m)

Defined in Control.Monad.Trans.RWS.Strict

Methods

liftIO :: IO a -> RWST r w s m a

class MonadCatch m => MonadMask (m :: * -> *)

A class for monads which provide for the ability to account for all possible exit points from a computation, and to mask asynchronous exceptions. Continuation-based monads are invalid instances of this class.

Instances should ensure that, in the following code:

fg = f `finally` g

The action g is called regardless of what occurs within f, including async exceptions. Some monads allow f to abort the computation via other effects than throwing an exception. For simplicity, we will consider aborting and throwing an exception to be two forms of "throwing an error".

If f and g both throw an error, the error thrown by fg depends on which errors we're talking about. In a monad transformer stack, the deeper layers override the effects of the inner layers; for example, ExceptT e1 (Except e2) a represents a value of type Either e2 (Either e1 a), so throwing both an e1 and an e2 will result in Left e2. If f and g both throw an error from the same layer, instances should ensure that the error from g wins.

Effects other than throwing an error are also overriden by the deeper layers. For example, StateT s Maybe a represents a value of type s -> Maybe (a, s), so if an error thrown from f causes this function to return Nothing, any changes to the state which f also performed will be erased. As a result, g will see the state as it was before f. Once g completes, f's error will be rethrown, so g' state changes will be erased as well. This is the normal interaction between effects in a monad transformer stack.

By contrast, lifted-base's version of finally always discards all of g's non-IO effects, and g never sees any of f's non-IO effects, regardless of the layer ordering and regardless of whether f throws an error. This is not the result of interacting effects, but a consequence of MonadBaseControl's approach.

Minimal complete definition

mask, uninterruptibleMask, generalBracket

Instances

MonadMask IO

Defined in Control.Monad.Catch

Methods

mask :: ((forall a. IO a -> IO a) -> IO b) -> IO b

uninterruptibleMask :: ((forall a. IO a -> IO a) -> IO b) -> IO b

generalBracket :: IO a -> (a -> ExitCase b -> IO c) -> (a -> IO b) -> IO (b, c)

e ~ SomeException => MonadMask (Either e)

Since: exceptions-0.8.3

Defined in Control.Monad.Catch

Methods

mask :: ((forall a. Either e a -> Either e a) -> Either e b) -> Either e b

uninterruptibleMask :: ((forall a. Either e a -> Either e a) -> Either e b) -> Either e b

generalBracket :: Either e a -> (a -> ExitCase b -> Either e c) -> (a -> Either e b) -> Either e (b, c)

MonadMask m => MonadMask (MaybeT m)

Since: exceptions-0.10.0

Defined in Control.Monad.Catch

Methods

mask :: ((forall a. MaybeT m a -> MaybeT m a) -> MaybeT m b) -> MaybeT m b

uninterruptibleMask :: ((forall a. MaybeT m a -> MaybeT m a) -> MaybeT m b) -> MaybeT m b

generalBracket :: MaybeT m a -> (a -> ExitCase b -> MaybeT m c) -> (a -> MaybeT m b) -> MaybeT m (b, c)

MonadMask m => MonadMask (ExceptT e m)

Since: exceptions-0.9.0

Defined in Control.Monad.Catch

Methods

mask :: ((forall a. ExceptT e m a -> ExceptT e m a) -> ExceptT e m b) -> ExceptT e m b

uninterruptibleMask :: ((forall a. ExceptT e m a -> ExceptT e m a) -> ExceptT e m b) -> ExceptT e m b

generalBracket :: ExceptT e m a -> (a -> ExitCase b -> ExceptT e m c) -> (a -> ExceptT e m b) -> ExceptT e m (b, c)

MonadMask m => MonadMask (IdentityT m)

Defined in Control.Monad.Catch

Methods

mask :: ((forall a. IdentityT m a -> IdentityT m a) -> IdentityT m b) -> IdentityT m b

uninterruptibleMask :: ((forall a. IdentityT m a -> IdentityT m a) -> IdentityT m b) -> IdentityT m b

generalBracket :: IdentityT m a -> (a -> ExitCase b -> IdentityT m c) -> (a -> IdentityT m b) -> IdentityT m (b, c)

(Error e, MonadMask m) => MonadMask (ErrorT e m)

Defined in Control.Monad.Catch

Methods

mask :: ((forall a. ErrorT e m a -> ErrorT e m a) -> ErrorT e m b) -> ErrorT e m b

uninterruptibleMask :: ((forall a. ErrorT e m a -> ErrorT e m a) -> ErrorT e m b) -> ErrorT e m b

generalBracket :: ErrorT e m a -> (a -> ExitCase b -> ErrorT e m c) -> (a -> ErrorT e m b) -> ErrorT e m (b, c)

MonadMask m => MonadMask (StateT s m)

Defined in Control.Monad.Catch

Methods

mask :: ((forall a. StateT s m a -> StateT s m a) -> StateT s m b) -> StateT s m b

uninterruptibleMask :: ((forall a. StateT s m a -> StateT s m a) -> StateT s m b) -> StateT s m b

generalBracket :: StateT s m a -> (a -> ExitCase b -> StateT s m c) -> (a -> StateT s m b) -> StateT s m (b, c)

MonadMask m => MonadMask (StateT s m)

Defined in Control.Monad.Catch

Methods

mask :: ((forall a. StateT s m a -> StateT s m a) -> StateT s m b) -> StateT s m b

uninterruptibleMask :: ((forall a. StateT s m a -> StateT s m a) -> StateT s m b) -> StateT s m b

generalBracket :: StateT s m a -> (a -> ExitCase b -> StateT s m c) -> (a -> StateT s m b) -> StateT s m (b, c)

(MonadMask m, Monoid w) => MonadMask (WriterT w m)

Defined in Control.Monad.Catch

Methods

mask :: ((forall a. WriterT w m a -> WriterT w m a) -> WriterT w m b) -> WriterT w m b

uninterruptibleMask :: ((forall a. WriterT w m a -> WriterT w m a) -> WriterT w m b) -> WriterT w m b

generalBracket :: WriterT w m a -> (a -> ExitCase b -> WriterT w m c) -> (a -> WriterT w m b) -> WriterT w m (b, c)

(MonadMask m, Monoid w) => MonadMask (WriterT w m)

Defined in Control.Monad.Catch

Methods

mask :: ((forall a. WriterT w m a -> WriterT w m a) -> WriterT w m b) -> WriterT w m b

uninterruptibleMask :: ((forall a. WriterT w m a -> WriterT w m a) -> WriterT w m b) -> WriterT w m b

generalBracket :: WriterT w m a -> (a -> ExitCase b -> WriterT w m c) -> (a -> WriterT w m b) -> WriterT w m (b, c)

MonadMask m => MonadMask (ReaderT r m)

Defined in Control.Monad.Catch

Methods

mask :: ((forall a. ReaderT r m a -> ReaderT r m a) -> ReaderT r m b) -> ReaderT r m b

uninterruptibleMask :: ((forall a. ReaderT r m a -> ReaderT r m a) -> ReaderT r m b) -> ReaderT r m b

generalBracket :: ReaderT r m a -> (a -> ExitCase b -> ReaderT r m c) -> (a -> ReaderT r m b) -> ReaderT r m (b, c)

(MonadMask m, Monoid w) => MonadMask (RWST r w s m)

Defined in Control.Monad.Catch

Methods

mask :: ((forall a. RWST r w s m a -> RWST r w s m a) -> RWST r w s m b) -> RWST r w s m b

uninterruptibleMask :: ((forall a. RWST r w s m a -> RWST r w s m a) -> RWST r w s m b) -> RWST r w s m b

generalBracket :: RWST r w s m a -> (a -> ExitCase b -> RWST r w s m c) -> (a -> RWST r w s m b) -> RWST r w s m (b, c)

(MonadMask m, Monoid w) => MonadMask (RWST r w s m)

Defined in Control.Monad.Catch

Methods

mask :: ((forall a. RWST r w s m a -> RWST r w s m a) -> RWST r w s m b) -> RWST r w s m b

uninterruptibleMask :: ((forall a. RWST r w s m a -> RWST r w s m a) -> RWST r w s m b) -> RWST r w s m b

generalBracket :: RWST r w s m a -> (a -> ExitCase b -> RWST r w s m c) -> (a -> RWST r w s m b) -> RWST r w s m (b, c)

lift :: (MonadTrans t, Monad m) => m a -> t m a

Lift a computation from the argument monad to the constructed monad.

liftIO :: MonadIO m => IO a -> m a

Lift a computation from the IO monad.

stdin :: Handle

A handle managing input from the Haskell program's standard input channel.

stdout :: Handle

A handle managing output to the Haskell program's standard output channel.

stderr :: Handle

A handle managing output to the Haskell program's standard error channel.

enumAuxFile :: MonadBracketIO m => FilePath -> Iteratee ByteString m a -> m a

enumInputs :: MonadBracketIO m => [FilePath] -> Enumerator ByteString m a

enumDefaultInputs :: MonadBracketIO m => Enumerator ByteString m a

data Ordering' a

Constructors

Less

Equal a

NotLess

mergeSortStreams :: Monad m => (a -> a -> Ordering' a) -> Enumeratee [a] [a] (Iteratee [a] m) b

type Enumerator' h eo m b = (h -> Iteratee eo m b) -> m (Iteratee eo m b)

type Enumeratee' h ei eo m b = (h -> Iteratee eo m b) -> Iteratee ei m (Iteratee eo m b)

mergeEnums'

Arguments

:: (Nullable s2, Nullable s1, Monad m)

=> Enumerator' hi s1 m a

inner enumerator

-> Enumerator' ho s2 (Iteratee s1 m) a

outer enumerator

-> (ho -> Enumeratee s2 s1 (Iteratee s1 m) a)

merging enumeratee

-> Enumerator' hi s1 m a

Merge two Enumerator's into one. The header provided by the inner Enumerator' is passed to the output iterator, the header provided by the outer Enumerator' is passed to the merging iteratee

data QQ a

Constructors

QQ !Int [a] [a]

emptyQ :: QQ a

lengthQ :: QQ a -> Int

pushQ :: a -> QQ a -> QQ a

popQ :: QQ a -> Maybe (a, QQ a)

cancelAll :: MonadIO m => QQ (Async a) -> m ()

data ParseError

Constructors

ParseError

Fields

• errorContexts :: [String]
• errorMessage :: String

Instances

Show ParseError

Defined in Bio.Iteratee

Methods

showsPrec :: Int -> ParseError -> ShowS

show :: ParseError -> String

showList :: [ParseError] -> ShowS

Exception ParseError

Defined in Bio.Iteratee

Methods

toException :: ParseError -> SomeException

fromException :: SomeException -> Maybe ParseError

displayException :: ParseError -> String

parserToIteratee :: Parser a -> Iteratee ByteString m a

A function to convert attoparsec Parsers into Iteratees.

stream2vector :: (MonadIO m, Vector v a) => Iteratee [a] m (v a)

Reads the whole stream into a Vector.

stream2vectorN :: (MonadIO m, Vector v a) => Int -> Iteratee [a] m (v a)

Equivalent to joinI $ takeStream n $ stream2vector, but more efficient.

data Fd

Instances

Bounded Fd

Defined in System.Posix.Types

Methods

minBound :: Fd

maxBound :: Fd

Enum Fd

Defined in System.Posix.Types

Methods

succ :: Fd -> Fd

pred :: Fd -> Fd

toEnum :: Int -> Fd

fromEnum :: Fd -> Int

enumFrom :: Fd -> [Fd]

enumFromThen :: Fd -> Fd -> [Fd]

enumFromTo :: Fd -> Fd -> [Fd]

enumFromThenTo :: Fd -> Fd -> Fd -> [Fd]

Eq Fd

Defined in System.Posix.Types

Methods

(==) :: Fd -> Fd -> Bool

(/=) :: Fd -> Fd -> Bool

Integral Fd

Defined in System.Posix.Types

Methods

quot :: Fd -> Fd -> Fd

rem :: Fd -> Fd -> Fd

div :: Fd -> Fd -> Fd

mod :: Fd -> Fd -> Fd

quotRem :: Fd -> Fd -> (Fd, Fd)

divMod :: Fd -> Fd -> (Fd, Fd)

toInteger :: Fd -> Integer

Num Fd

Defined in System.Posix.Types

Methods

(+) :: Fd -> Fd -> Fd

(-) :: Fd -> Fd -> Fd

(*) :: Fd -> Fd -> Fd

negate :: Fd -> Fd

abs :: Fd -> Fd

signum :: Fd -> Fd

fromInteger :: Integer -> Fd

Ord Fd

Defined in System.Posix.Types

Methods

compare :: Fd -> Fd -> Ordering

(<) :: Fd -> Fd -> Bool

(<=) :: Fd -> Fd -> Bool

(>) :: Fd -> Fd -> Bool

(>=) :: Fd -> Fd -> Bool

max :: Fd -> Fd -> Fd

min :: Fd -> Fd -> Fd

Read Fd

Defined in System.Posix.Types

Methods

readsPrec :: Int -> ReadS Fd

readList :: ReadS [Fd]

readPrec :: ReadPrec Fd

readListPrec :: ReadPrec [Fd]

Real Fd

Defined in System.Posix.Types

Methods

toRational :: Fd -> Rational

Show Fd

Defined in System.Posix.Types

Methods

showsPrec :: Int -> Fd -> ShowS

show :: Fd -> String

showList :: [Fd] -> ShowS

Storable Fd

Defined in System.Posix.Types

Methods

sizeOf :: Fd -> Int

alignment :: Fd -> Int

peekElemOff :: Ptr Fd -> Int -> IO Fd

pokeElemOff :: Ptr Fd -> Int -> Fd -> IO ()

peekByteOff :: Ptr b -> Int -> IO Fd

pokeByteOff :: Ptr b -> Int -> Fd -> IO ()

peek :: Ptr Fd -> IO Fd

poke :: Ptr Fd -> Fd -> IO ()

Bits Fd

Defined in System.Posix.Types

Methods

(.&.) :: Fd -> Fd -> Fd

(.|.) :: Fd -> Fd -> Fd

xor :: Fd -> Fd -> Fd

complement :: Fd -> Fd

shift :: Fd -> Int -> Fd

rotate :: Fd -> Int -> Fd

zeroBits :: Fd

bit :: Int -> Fd

setBit :: Fd -> Int -> Fd

clearBit :: Fd -> Int -> Fd

complementBit :: Fd -> Int -> Fd

testBit :: Fd -> Int -> Bool

bitSizeMaybe :: Fd -> Maybe Int

bitSize :: Fd -> Int

isSigned :: Fd -> Bool

shiftL :: Fd -> Int -> Fd

unsafeShiftL :: Fd -> Int -> Fd

shiftR :: Fd -> Int -> Fd

unsafeShiftR :: Fd -> Int -> Fd

rotateL :: Fd -> Int -> Fd

rotateR :: Fd -> Int -> Fd

popCount :: Fd -> Int

FiniteBits Fd

Defined in System.Posix.Types

Methods

finiteBitSize :: Fd -> Int

countLeadingZeros :: Fd -> Int

countTrailingZeros :: Fd -> Int

Prim Fd

Defined in Data.Primitive.Types

Methods

sizeOf# :: Fd -> Int#

alignment# :: Fd -> Int#

indexByteArray# :: ByteArray# -> Int# -> Fd

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, Fd#)

writeByteArray# :: MutableByteArray# s -> Int# -> Fd -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Fd -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> Fd

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, Fd#)

writeOffAddr# :: Addr# -> Int# -> Fd -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> Fd -> State# s -> State# s

withFileFd :: (MonadIO m, MonadMask m) => FilePath -> (Fd -> m a) -> m a

module Bio.Iteratee.Bytes

module Bio.Iteratee.IO

module Bio.Iteratee.Iteratee

module Bio.Iteratee.List