Pipes.Transduce.Internal

Documentation

newtype Fold1 b e a

A computation in IO that completely drains a Producer of b values, returning a value of type a, except when it fails early with an error of type e.

Constructors

Fold1 (Lift (Fold1_ b e) a)

Instances

Bifunctor (Fold1 b)

first is useful to massage errors.

Functor (Fold1 b e)

Applicative (Fold1 b e)

pure creates a Fold1 that does nothing besides draining the Producer.

<*> feeds both folds with the data of the same Producer. If any of them fails the combination fails.

Monoid a => Monoid (Fold1 b e a)

data Fold1_ b e a

Constructors

TrueFold (FoldM (ExceptT e IO) b a)

ExhaustiveCont (forall r. Producer b IO r -> IO (Either e (a, r)))

NonexhaustiveCont (Producer b IO () -> IO (Either e a))

Instances

Bifunctor (Fold1_ b)

Functor (Fold1_ b e)

Applicative (Fold1_ b e)

nonexhaustiveCont :: Fold1_ b e a -> Producer b IO () -> IO (Either e a)

exhaustiveCont :: Fold1_ b e a -> Producer b IO r -> IO (Either e (a, r))

withFallibleCont

Arguments

:: (Producer b IO () -> IO (Either e a))

-> Fold1 b e a

withFallibleCont'

Arguments

:: (forall r. Producer b IO r -> IO (Either e (a, r)))

-> Fold1 b e a

withCont

Arguments

:: (Producer b IO () -> IO a)

-> Fold1 b e a

withCont'

Arguments

:: (forall r. Producer b IO r -> IO (a, r))

-> Fold1 b e a

withFold :: Fold b a -> Fold1 b e a

withFoldIO :: FoldM IO b a -> Fold1 b e a

hoistFold :: Monad m => (forall a. m a -> n a) -> FoldM m i r -> FoldM n i r

withFallibleFold :: FoldM (ExceptT e IO) b a -> Fold1 b e a

withConsumer :: Consumer b IO () -> Fold1 b e ()

withConsumer' :: Consumer b IO Void -> Fold1 b e ()

Builds a Fold1 out of a Consumer that never stops by itself.

withConsumerM

Arguments

:: MonadIO m

=> (m () -> IO (Either e a))

-> Consumer b m ()

-> Fold1 b e a

withConsumerM'

Arguments

:: MonadIO m

=> (forall r. m r -> IO (Either e (a, r)))

-> Consumer b m Void

-> Fold1 b e a

withSafeConsumer

Arguments

:: Consumer b (SafeT IO) Void

-> Fold1 b e ()

withFallibleConsumer

Arguments

:: Consumer b (ExceptT e IO) Void

-> Fold1 b e ()

withParser

Arguments

:: Parser b IO (Either e a)

-> Fold1 b e a

withParserM

Arguments

:: MonadIO m

=> (forall r. m (a, r) -> IO (Either e (c, r)))

-> Parser b m a

-> Fold1 b e c

foldFallibly1 :: Fold1 b e a -> Producer b IO r -> IO (Either e (a, r))

Run a Fold1.

fold1 :: Fold1 b Void a -> Producer b IO r -> IO (a, r)

Run a Fold1 that never returns an error value (but which may still throw exceptions!)

data Transducer x b e a

A transformation that takes the inputs of a Fold1 from type a to type b.

Optionally, the transformation may delimit groups of elements in the stream. In that case the phantom type x will be Delimited. Otherwise, it will be Continuous.

Constructors

M (b -> a)

F (b -> [a])

P (forall r. Producer b IO r -> Producer a IO r)

PE (forall r. Producer b IO r -> Producer a IO (Either e r))

S (forall r. Producer b IO r -> FreeT (Producer a IO) IO r)

SE (forall r. Producer b IO r -> FreeT (Producer a IO) IO (Either e r))

Instances

Bifunctor (Transducer x b)

Functor (Transducer x b e)

mapper

Arguments

:: (a -> b)

-> Transducer Continuous a e b

fallibleM

Arguments

:: (a -> Either e b)

-> Transducer Continuous a e b

fallibleMapper

Arguments

:: (a -> Either e b)

-> Transducer Continuous a e b

mapperFoldable

Arguments

:: Foldable f

=> (a -> f b)

-> Transducer Continuous a e b

mapperEnumerable

Arguments

:: Enumerable f

=> (a -> f IO b)

-> Transducer Continuous a e b

transducer

Arguments

:: (forall r. Producer b IO r -> Producer a IO r)

-> Transducer Continuous b e a

fallibleTransducer

Arguments

:: (forall r. Producer b IO r -> Producer a IO (Either e r))

-> Transducer Continuous b e a

delimit

Arguments

:: (forall r. Producer a IO r -> FreeT (Producer a' IO) IO r)

-> Transducer Continuous b e a

-> Transducer Delimited b e a'

Plug splitting functions from pipes-group here.

transduce1 :: Transducer Continuous b e a -> Fold1 a e r -> Fold1 b e r

Apply a Transducer to a Fold1.

groups

Arguments

:: (forall r. Producer b IO r -> Producer b' IO r)

-> Transducer Delimited a e b

-> Transducer Delimited a e b'

Tweak each of the groups delimited by a Transducer.

folds

Arguments

:: Fold1 b Void b'

-> Transducer Delimited a e b

-> Transducer Continuous a e b'

data Delimited

data Continuous

concats

Arguments

:: Transducer Delimited a e b

-> Transducer Continuous a e b

intercalates

Arguments

:: Producer b IO ()

-> Transducer Delimited a e b

-> Transducer Continuous a e b

newtype Fold2 b1 b2 e a

Constructors

Fold2 (forall r1 r2. Producer b1 IO r1 -> Producer b2 IO r2 -> IO (Either e (a, r1, r2)))

Instances

Bifunctor (Fold2 b1 b2)

Functor (Fold2 b1 b2 e)

Applicative (Fold2 b1 b2 e)

Monoid a => Monoid (Fold2 b1 b2 e a)

foldFallibly2 :: Fold2 b1 b2 e a -> Producer b1 IO r1 -> Producer b2 IO r2 -> IO (Either e (a, r1, r2))

Run a Fold2.

fold2 :: Fold2 b1 b2 Void a -> Producer b1 IO r1 -> Producer b2 IO r2 -> IO (a, r1, r2)

Run a Fold2 that never returns an error value (but which may still throw exceptions!)

separated :: Fold1 b1 e r1 -> Fold1 b2 e r2 -> Fold2 b1 b2 e (r1, r2)

combined :: Transducer Delimited b1 e x -> Transducer Delimited b2 e x -> Fold1 x e a -> Fold2 b1 b2 e a