pipes-group-1.0.12: Group streams into substreams

Safe HaskellSafe
LanguageHaskell2010

Pipes.Group

Contents

Description

Element-agnostic grouping utilities for pipes

See Pipes.Group.Tutorial for an extended tutorial

Some type signatures below refer to the aliases below, which are not used in this library, but are included to simplify the documentation.

type Groups         a m x = FreeT (Producer a m) m x
type Splitter       a m x = Producer a m x -> Groups a m x
type Transformation a m x = Groups a m x -> Groups a m x
type Joiner         a m x = Groups a m x -> Producer a m x
Synopsis

Lenses

groups :: (Monad m, Eq a') => Lens (Producer a' m x) (Producer a m x) (FreeT (Producer a' m) m x) (FreeT (Producer a m) m x) #

Like groupsBy, where the equality predicate is (==)

     groups :: Monad m => Lens' (Producer a m x) (Groups a m x)
view groups :: Monad m => Splitter a m x
set  groups :: Monad m => Groups a m x -> Producer a m x -> Producer a m x
over groups :: Monad m => Transformation a m x -> Producer a m x -> Producer a m x
>>> import Lens.Family (view)
>>> import Pipes (yield, each)
>>> import Pipes.Prelude (toList)
>>> (toList . intercalates (yield '|') . view groups) (each "12233345")
"1|22|333|4|5"

groupsBy :: Monad m => (a' -> a' -> Bool) -> Lens (Producer a' m x) (Producer a m x) (FreeT (Producer a' m) m x) (FreeT (Producer a m) m x) #

groupsBy splits a Producer into a FreeT of Producers grouped using the given equality predicate

      groupsBy p  :: Monad m => Lens' (Producer a m x) (Groups a m x)
view (groupsBy p) :: Monad m => Splitter a m x
set  (groupsBy p) :: Monad m => Groups a m x -> Producer a m x -> Producer a m x
over (groupsBy p) :: Monad m => Transformation a m x -> Producer a m x -> Producer a m x
>>> import Lens.Family (view)
>>> import Pipes (yield, each)
>>> import Pipes.Prelude (toList)
>>> (toList . intercalates (yield '|') . view (groupsBy (==))) (each "12233345")
"1|22|333|4|5"

groupsBy' :: Monad m => (a' -> a' -> Bool) -> Lens (Producer a' m x) (Producer a m x) (FreeT (Producer a' m) m x) (FreeT (Producer a m) m x) #

groupsBy' splits a Producer into a FreeT of Producers grouped using the given equality predicate

This differs from groupsBy by comparing successive elements for equality instead of comparing each element to the first member of the group

>>> import Lens.Family (view)
>>> import Pipes (yield, each)
>>> import Pipes.Prelude (toList)
>>> let cmp c1 c2 = succ c1 == c2
>>> (toList . intercalates (yield '|') . view (groupsBy' cmp)) (each "12233345")
"12|23|3|345"
>>> (toList . intercalates (yield '|') . view (groupsBy  cmp)) (each "12233345")
"122|3|3|34|5"
      groupsBy' p  :: Monad m => Lens' (Producer a m x) (Groups a m x)
view (groupsBy' p) :: Monad m => Splitter a m x
set  (groupsBy' p) :: Monad m => Groups a m x -> Producer a m x -> Producer a m x
over (groupsBy' p) :: Monad m => Transformation a m x -> Producer a m x -> Producer a m x

chunksOf :: Monad m => Int -> Lens (Producer a' m x) (Producer a m x) (FreeT (Producer a' m) m x) (FreeT (Producer a m) m x) #

chunksOf is an splits a Producer into a FreeT of Producers of fixed length

      chunksOf n  :: Monad m => Lens' (Producer a m x) (Groups a m x)
view (chunksOf n) :: Monad m => Splitter a m x
set  (chunksOf n) :: Monad m => Groups a m x -> Producer a m x -> Producer a m x
over (chunksOf n) :: Monad m => Transformation a m x -> Producer a m x -> Producer a m x
>>> import Lens.Family (view)
>>> import Pipes (yield, each)
>>> import Pipes.Prelude (toList)
>>> (toList . intercalates (yield '|') . view (chunksOf 3)) (each "12233345")
"122|333|45"

Transformations

takes :: (Functor f, Monad m) => Int -> FreeT f m () -> FreeT f m () #

(takes n) only keeps the first n functor layers of a FreeT

takes :: Monad m => Int -> Groups a m () -> Groups a m ()
>>> import Lens.Family (view)
>>> import Pipes (yield, each)
>>> import Pipes.Prelude (toList)
>>> (toList . intercalates (yield '|') . takes 3 . view groups) (each "12233345")
"1|22|333"

takes' :: Monad m => Int -> FreeT (Producer a m) m x -> FreeT (Producer a m) m x #

(takes' n) only keeps the first n Producers of a FreeT

takes' differs from takes by draining unused Producers in order to preserve the return value. This makes it a suitable argument for maps.

takes' :: Monad m => Int -> Transformation a m x

drops :: Monad m => Int -> FreeT (Producer a m) m x -> FreeT (Producer a m) m x #

(drops n) peels off the first n Producer layers of a FreeT

drops :: Monad m => Int -> Transformation a m x
>>> import Lens.Family (view)
>>> import Pipes (yield, each)
>>> import Pipes.Prelude (toList)
>>> (toList . intercalates (yield '|') . drops 3 . view groups) (each "12233345")
"4|5"

Use carefully: the peeling off is not free. This runs the first n layers, just discarding everything they produce.

maps :: (Monad m, Functor g) => (forall r. f r -> g r) -> FreeT f m x -> FreeT g m x #

Transform each individual functor layer of a FreeT

You can think of this as:

maps
    :: (forall r . Producer a m r -> Producer b m r)
    -> FreeT (Producer a m) m x -> FreeT (Producer b m) m x

This is just a synonym for transFreeT

individually :: (Monad m, Functor g) => Setter (FreeT f m x) (FreeT g m x) (f (FreeT f m x)) (g (FreeT f m x)) #

Lens to transform each individual functor layer of a FreeT. (over individually) is equivalent to maps, but with a less general type.

type Group a m x = Producer a m (Groups a m x)

set  individually :: Monad m => Group a m x -> Transformation a m x
over individually :: Monad m => (Group a m x -> Group a m x) -> Transformation a m x

Joiners

concats :: Monad m => FreeT (Producer a m) m x -> Producer a m x #

Join a FreeT-delimited stream of Producers into a single Producer

concats :: Monad m => Joiner a m x

intercalates :: Monad m => Producer a m () -> FreeT (Producer a m) m x -> Producer a m x #

Join a FreeT-delimited stream of Producers into a single Producer by intercalating a Producer in between them

intercalates :: Monad m => Producer a m () -> Joiner a m x

Folds

These folds are designed to be compatible with the foldl library. See the purely and impurely functions from that library for more details.

For example, to count the number of Producer layers in a FreeT, you can write:

import Control.Applicative (pure)
import qualified Control.Foldl as L
import Pipes.Group
import qualified Pipes.Prelude as P

count :: Monad m => FreeT (Producer a m) m () -> m Int
count = P.sum . L.purely folds (pure 1)

folds #

Arguments

:: Monad m 
=> (x -> a -> x)

Step function

-> x

Initial accumulator

-> (x -> b)

Extraction function

-> FreeT (Producer a m) m r 
-> Producer b m r 

Fold each Producer of a FreeT

purely folds :: Monad m => Fold a b -> Groups a m r -> Producer b m r

foldsM #

Arguments

:: Monad m 
=> (x -> a -> m x)

Step function

-> m x

Initial accumulator

-> (x -> m b)

Extraction function

-> FreeT (Producer a m) m r 
-> Producer b m r 

Fold each Producer of a FreeT, monadically

impurely foldsM :: Monad m => FoldM a b -> Groups a m r -> Producer b m r

Re-exports

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

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

data FreeF (f :: Type -> Type) a b #

The base functor for a free monad.

Constructors

Pure a 
Free (f b) 
Instances
Traversable f => Bitraversable (FreeF f) 
Instance details

Defined in Control.Monad.Trans.Free

Methods

bitraverse :: Applicative f0 => (a -> f0 c) -> (b -> f0 d) -> FreeF f a b -> f0 (FreeF f c d) #

Foldable f => Bifoldable (FreeF f) 
Instance details

Defined in Control.Monad.Trans.Free

Methods

bifold :: Monoid m => FreeF f m m -> m #

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> FreeF f a b -> m #

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> FreeF f a b -> c #

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> FreeF f a b -> c #

Functor f => Bifunctor (FreeF f) 
Instance details

Defined in Control.Monad.Trans.Free

Methods

bimap :: (a -> b) -> (c -> d) -> FreeF f a c -> FreeF f b d #

first :: (a -> b) -> FreeF f a c -> FreeF f b c #

second :: (b -> c) -> FreeF f a b -> FreeF f a c #

Eq1 f => Eq2 (FreeF f) 
Instance details

Defined in Control.Monad.Trans.Free

Methods

liftEq2 :: (a -> b -> Bool) -> (c -> d -> Bool) -> FreeF f a c -> FreeF f b d -> Bool #

Ord1 f => Ord2 (FreeF f) 
Instance details

Defined in Control.Monad.Trans.Free

Methods

liftCompare2 :: (a -> b -> Ordering) -> (c -> d -> Ordering) -> FreeF f a c -> FreeF f b d -> Ordering #

Read1 f => Read2 (FreeF f) 
Instance details

Defined in Control.Monad.Trans.Free

Methods

liftReadsPrec2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> Int -> ReadS (FreeF f a b) #

liftReadList2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> ReadS [FreeF f a b] #

liftReadPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec (FreeF f a b) #

liftReadListPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec [FreeF f a b] #

Show1 f => Show2 (FreeF f) 
Instance details

Defined in Control.Monad.Trans.Free

Methods

liftShowsPrec2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> Int -> FreeF f a b -> ShowS #

liftShowList2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> [FreeF f a b] -> ShowS #

Generic1 (FreeF f a :: Type -> Type) 
Instance details

Defined in Control.Monad.Trans.Free

Associated Types

type Rep1 (FreeF f a) :: k -> Type #

Methods

from1 :: FreeF f a a0 -> Rep1 (FreeF f a) a0 #

to1 :: Rep1 (FreeF f a) a0 -> FreeF f a a0 #

Functor f => Functor (FreeF f a) 
Instance details

Defined in Control.Monad.Trans.Free

Methods

fmap :: (a0 -> b) -> FreeF f a a0 -> FreeF f a b #

(<$) :: a0 -> FreeF f a b -> FreeF f a a0 #

Foldable f => Foldable (FreeF f a) 
Instance details

Defined in Control.Monad.Trans.Free

Methods

fold :: Monoid m => FreeF f a m -> m #

foldMap :: Monoid m => (a0 -> m) -> FreeF f a a0 -> m #

foldr :: (a0 -> b -> b) -> b -> FreeF f a a0 -> b #

foldr' :: (a0 -> b -> b) -> b -> FreeF f a a0 -> b #

foldl :: (b -> a0 -> b) -> b -> FreeF f a a0 -> b #

foldl' :: (b -> a0 -> b) -> b -> FreeF f a a0 -> b #

foldr1 :: (a0 -> a0 -> a0) -> FreeF f a a0 -> a0 #

foldl1 :: (a0 -> a0 -> a0) -> FreeF f a a0 -> a0 #

toList :: FreeF f a a0 -> [a0] #

null :: FreeF f a a0 -> Bool #

length :: FreeF f a a0 -> Int #

elem :: Eq a0 => a0 -> FreeF f a a0 -> Bool #

maximum :: Ord a0 => FreeF f a a0 -> a0 #

minimum :: Ord a0 => FreeF f a a0 -> a0 #

sum :: Num a0 => FreeF f a a0 -> a0 #

product :: Num a0 => FreeF f a a0 -> a0 #

Traversable f => Traversable (FreeF f a) 
Instance details

Defined in Control.Monad.Trans.Free

Methods

traverse :: Applicative f0 => (a0 -> f0 b) -> FreeF f a a0 -> f0 (FreeF f a b) #

sequenceA :: Applicative f0 => FreeF f a (f0 a0) -> f0 (FreeF f a a0) #

mapM :: Monad m => (a0 -> m b) -> FreeF f a a0 -> m (FreeF f a b) #

sequence :: Monad m => FreeF f a (m a0) -> m (FreeF f a a0) #

(Eq1 f, Eq a) => Eq1 (FreeF f a) 
Instance details

Defined in Control.Monad.Trans.Free

Methods

liftEq :: (a0 -> b -> Bool) -> FreeF f a a0 -> FreeF f a b -> Bool #

(Ord1 f, Ord a) => Ord1 (FreeF f a) 
Instance details

Defined in Control.Monad.Trans.Free

Methods

liftCompare :: (a0 -> b -> Ordering) -> FreeF f a a0 -> FreeF f a b -> Ordering #

(Read1 f, Read a) => Read1 (FreeF f a) 
Instance details

Defined in Control.Monad.Trans.Free

Methods

liftReadsPrec :: (Int -> ReadS a0) -> ReadS [a0] -> Int -> ReadS (FreeF f a a0) #

liftReadList :: (Int -> ReadS a0) -> ReadS [a0] -> ReadS [FreeF f a a0] #

liftReadPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec (FreeF f a a0) #

liftReadListPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec [FreeF f a a0] #

(Show1 f, Show a) => Show1 (FreeF f a) 
Instance details

Defined in Control.Monad.Trans.Free

Methods

liftShowsPrec :: (Int -> a0 -> ShowS) -> ([a0] -> ShowS) -> Int -> FreeF f a a0 -> ShowS #

liftShowList :: (Int -> a0 -> ShowS) -> ([a0] -> ShowS) -> [FreeF f a a0] -> ShowS #

(Eq a, Eq (f b)) => Eq (FreeF f a b) 
Instance details

Defined in Control.Monad.Trans.Free

Methods

(==) :: FreeF f a b -> FreeF f a b -> Bool #

(/=) :: FreeF f a b -> FreeF f a b -> Bool #

(Ord a, Ord (f b)) => Ord (FreeF f a b) 
Instance details

Defined in Control.Monad.Trans.Free

Methods

compare :: FreeF f a b -> FreeF f a b -> Ordering #

(<) :: FreeF f a b -> FreeF f a b -> Bool #

(<=) :: FreeF f a b -> FreeF f a b -> Bool #

(>) :: FreeF f a b -> FreeF f a b -> Bool #

(>=) :: FreeF f a b -> FreeF f a b -> Bool #

max :: FreeF f a b -> FreeF f a b -> FreeF f a b #

min :: FreeF f a b -> FreeF f a b -> FreeF f a b #

(Read a, Read (f b)) => Read (FreeF f a b) 
Instance details

Defined in Control.Monad.Trans.Free

Methods

readsPrec :: Int -> ReadS (FreeF f a b) #

readList :: ReadS [FreeF f a b] #

readPrec :: ReadPrec (FreeF f a b) #

readListPrec :: ReadPrec [FreeF f a b] #

(Show a, Show (f b)) => Show (FreeF f a b) 
Instance details

Defined in Control.Monad.Trans.Free

Methods

showsPrec :: Int -> FreeF f a b -> ShowS #

show :: FreeF f a b -> String #

showList :: [FreeF f a b] -> ShowS #

Generic (FreeF f a b) 
Instance details

Defined in Control.Monad.Trans.Free

Associated Types

type Rep (FreeF f a b) :: Type -> Type #

Methods

from :: FreeF f a b -> Rep (FreeF f a b) x #

to :: Rep (FreeF f a b) x -> FreeF f a b #

type Rep1 (FreeF f a :: Type -> Type) 
Instance details

Defined in Control.Monad.Trans.Free

type Rep1 (FreeF f a :: Type -> Type) = D1 (MetaData "FreeF" "Control.Monad.Trans.Free" "free-5.1-4UATSEhaXgTAvcVwsU7IL6" False) (C1 (MetaCons "Pure" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)) :+: C1 (MetaCons "Free" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 f)))
type Rep (FreeF f a b) 
Instance details

Defined in Control.Monad.Trans.Free

type Rep (FreeF f a b) = D1 (MetaData "FreeF" "Control.Monad.Trans.Free" "free-5.1-4UATSEhaXgTAvcVwsU7IL6" False) (C1 (MetaCons "Pure" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)) :+: C1 (MetaCons "Free" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (f b))))

newtype FreeT (f :: Type -> Type) (m :: Type -> Type) a #

The "free monad transformer" for a functor f

Constructors

FreeT 

Fields

Instances
(Functor f, Monad m) => MonadFree f (FreeT f m) 
Instance details

Defined in Control.Monad.Trans.Free

Methods

wrap :: f (FreeT f m a) -> FreeT f m a #

(Functor f, MonadWriter w m) => MonadWriter w (FreeT f m) 
Instance details

Defined in Control.Monad.Trans.Free

Methods

writer :: (a, w) -> FreeT f m a #

tell :: w -> FreeT f m () #

listen :: FreeT f m a -> FreeT f m (a, w) #

pass :: FreeT f m (a, w -> w) -> FreeT f m a #

(Functor f, MonadState s m) => MonadState s (FreeT f m) 
Instance details

Defined in Control.Monad.Trans.Free

Methods

get :: FreeT f m s #

put :: s -> FreeT f m () #

state :: (s -> (a, s)) -> FreeT f m a #

(Functor f, MonadReader r m) => MonadReader r (FreeT f m) 
Instance details

Defined in Control.Monad.Trans.Free

Methods

ask :: FreeT f m r #

local :: (r -> r) -> FreeT f m a -> FreeT f m a #

reader :: (r -> a) -> FreeT f m a #

(Functor f, MonadError e m) => MonadError e (FreeT f m) 
Instance details

Defined in Control.Monad.Trans.Free

Methods

throwError :: e -> FreeT f m a #

catchError :: FreeT f m a -> (e -> FreeT f m a) -> FreeT f m a #

(Functor f, MonadBase b m) => MonadBase b (FreeT f m) 
Instance details

Defined in Control.Monad.Trans.Free

Methods

liftBase :: b α -> FreeT f m α #

MonadTrans (FreeT f) 
Instance details

Defined in Control.Monad.Trans.Free

Methods

lift :: Monad m => m a -> FreeT f m a #

(Functor f, Monad m) => Monad (FreeT f m) 
Instance details

Defined in Control.Monad.Trans.Free

Methods

(>>=) :: FreeT f m a -> (a -> FreeT f m b) -> FreeT f m b #

(>>) :: FreeT f m a -> FreeT f m b -> FreeT f m b #

return :: a -> FreeT f m a #

fail :: String -> FreeT f m a #

(Functor f, Monad m) => Functor (FreeT f m) 
Instance details

Defined in Control.Monad.Trans.Free

Methods

fmap :: (a -> b) -> FreeT f m a -> FreeT f m b #

(<$) :: a -> FreeT f m b -> FreeT f m a #

(Functor f, Monad m) => MonadFail (FreeT f m) 
Instance details

Defined in Control.Monad.Trans.Free

Methods

fail :: String -> FreeT f m a #

(Functor f, Monad m) => Applicative (FreeT f m) 
Instance details

Defined in Control.Monad.Trans.Free

Methods

pure :: a -> FreeT f m a #

(<*>) :: FreeT f m (a -> b) -> FreeT f m a -> FreeT f m b #

liftA2 :: (a -> b -> c) -> FreeT f m a -> FreeT f m b -> FreeT f m c #

(*>) :: FreeT f m a -> FreeT f m b -> FreeT f m b #

(<*) :: FreeT f m a -> FreeT f m b -> FreeT f m a #

(Foldable m, Foldable f) => Foldable (FreeT f m) 
Instance details

Defined in Control.Monad.Trans.Free

Methods

fold :: Monoid m0 => FreeT f m m0 -> m0 #

foldMap :: Monoid m0 => (a -> m0) -> FreeT f m a -> m0 #

foldr :: (a -> b -> b) -> b -> FreeT f m a -> b #

foldr' :: (a -> b -> b) -> b -> FreeT f m a -> b #

foldl :: (b -> a -> b) -> b -> FreeT f m a -> b #

foldl' :: (b -> a -> b) -> b -> FreeT f m a -> b #

foldr1 :: (a -> a -> a) -> FreeT f m a -> a #

foldl1 :: (a -> a -> a) -> FreeT f m a -> a #

toList :: FreeT f m a -> [a] #

null :: FreeT f m a -> Bool #

length :: FreeT f m a -> Int #

elem :: Eq a => a -> FreeT f m a -> Bool #

maximum :: Ord a => FreeT f m a -> a #

minimum :: Ord a => FreeT f m a -> a #

sum :: Num a => FreeT f m a -> a #

product :: Num a => FreeT f m a -> a #

(Monad m, Traversable m, Traversable f) => Traversable (FreeT f m) 
Instance details

Defined in Control.Monad.Trans.Free

Methods

traverse :: Applicative f0 => (a -> f0 b) -> FreeT f m a -> f0 (FreeT f m b) #

sequenceA :: Applicative f0 => FreeT f m (f0 a) -> f0 (FreeT f m a) #

mapM :: Monad m0 => (a -> m0 b) -> FreeT f m a -> m0 (FreeT f m b) #

sequence :: Monad m0 => FreeT f m (m0 a) -> m0 (FreeT f m a) #

(Eq1 f, Eq1 m) => Eq1 (FreeT f m) 
Instance details

Defined in Control.Monad.Trans.Free

Methods

liftEq :: (a -> b -> Bool) -> FreeT f m a -> FreeT f m b -> Bool #

(Ord1 f, Ord1 m) => Ord1 (FreeT f m) 
Instance details

Defined in Control.Monad.Trans.Free

Methods

liftCompare :: (a -> b -> Ordering) -> FreeT f m a -> FreeT f m b -> Ordering #

(Read1 f, Read1 m) => Read1 (FreeT f m) 
Instance details

Defined in Control.Monad.Trans.Free

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (FreeT f m a) #

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [FreeT f m a] #

liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (FreeT f m a) #

liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [FreeT f m a] #

(Show1 f, Show1 m) => Show1 (FreeT f m) 
Instance details

Defined in Control.Monad.Trans.Free

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> FreeT f m a -> ShowS #

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [FreeT f m a] -> ShowS #

(Functor f, MonadIO m) => MonadIO (FreeT f m) 
Instance details

Defined in Control.Monad.Trans.Free

Methods

liftIO :: IO a -> FreeT f m a #

(Functor f, MonadPlus m) => Alternative (FreeT f m) 
Instance details

Defined in Control.Monad.Trans.Free

Methods

empty :: FreeT f m a #

(<|>) :: FreeT f m a -> FreeT f m a -> FreeT f m a #

some :: FreeT f m a -> FreeT f m [a] #

many :: FreeT f m a -> FreeT f m [a] #

(Functor f, MonadPlus m) => MonadPlus (FreeT f m) 
Instance details

Defined in Control.Monad.Trans.Free

Methods

mzero :: FreeT f m a #

mplus :: FreeT f m a -> FreeT f m a -> FreeT f m a #

(Functor f, MonadThrow m) => MonadThrow (FreeT f m) 
Instance details

Defined in Control.Monad.Trans.Free

Methods

throwM :: Exception e => e -> FreeT f m a #

(Functor f, MonadCatch m) => MonadCatch (FreeT f m) 
Instance details

Defined in Control.Monad.Trans.Free

Methods

catch :: Exception e => FreeT f m a -> (e -> FreeT f m a) -> FreeT f m a #

(Functor f, MonadCont m) => MonadCont (FreeT f m) 
Instance details

Defined in Control.Monad.Trans.Free

Methods

callCC :: ((a -> FreeT f m b) -> FreeT f m a) -> FreeT f m a #

(Functor f, Monad m) => Apply (FreeT f m) 
Instance details

Defined in Control.Monad.Trans.Free

Methods

(<.>) :: FreeT f m (a -> b) -> FreeT f m a -> FreeT f m b #

(.>) :: FreeT f m a -> FreeT f m b -> FreeT f m b #

(<.) :: FreeT f m a -> FreeT f m b -> FreeT f m a #

liftF2 :: (a -> b -> c) -> FreeT f m a -> FreeT f m b -> FreeT f m c #

(Functor f, Monad m) => Bind (FreeT f m) 
Instance details

Defined in Control.Monad.Trans.Free

Methods

(>>-) :: FreeT f m a -> (a -> FreeT f m b) -> FreeT f m b #

join :: FreeT f m (FreeT f m a) -> FreeT f m a #

(Eq1 f, Eq1 m, Eq a) => Eq (FreeT f m a) 
Instance details

Defined in Control.Monad.Trans.Free

Methods

(==) :: FreeT f m a -> FreeT f m a -> Bool #

(/=) :: FreeT f m a -> FreeT f m a -> Bool #

(Ord1 f, Ord1 m, Ord a) => Ord (FreeT f m a) 
Instance details

Defined in Control.Monad.Trans.Free

Methods

compare :: FreeT f m a -> FreeT f m a -> Ordering #

(<) :: FreeT f m a -> FreeT f m a -> Bool #

(<=) :: FreeT f m a -> FreeT f m a -> Bool #

(>) :: FreeT f m a -> FreeT f m a -> Bool #

(>=) :: FreeT f m a -> FreeT f m a -> Bool #

max :: FreeT f m a -> FreeT f m a -> FreeT f m a #

min :: FreeT f m a -> FreeT f m a -> FreeT f m a #

(Read1 f, Read1 m, Read a) => Read (FreeT f m a) 
Instance details

Defined in Control.Monad.Trans.Free

Methods

readsPrec :: Int -> ReadS (FreeT f m a) #

readList :: ReadS [FreeT f m a] #

readPrec :: ReadPrec (FreeT f m a) #

readListPrec :: ReadPrec [FreeT f m a] #

(Show1 f, Show1 m, Show a) => Show (FreeT f m a) 
Instance details

Defined in Control.Monad.Trans.Free

Methods

showsPrec :: Int -> FreeT f m a -> ShowS #

show :: FreeT f m a -> String #

showList :: [FreeT f m a] -> ShowS #

next :: Monad m => Producer a m r -> m (Either r (a, Producer a m r)) #

Consume the first value from a Producer

next either fails with a Left if the Producer terminates or succeeds with a Right providing the next value and the remainder of the Producer.

yield :: Monad m => a -> Producer' a m () #

Produce a value

yield :: Monad m => a -> Pipe x a m ()

type Producer b = Proxy X () () b #

Producers can only yield