Read Strings from stdin using getLine

Terminates on end of input

read values from stdin, ignoring failed parses

Read Strings from a Handle using hGetLine

Terminates on end of input

fromHandle :: MonadIO m => Handle -> Producer String m ()

Repeat a monadic action indefinitely, yielding each result

repeatM :: Monad m => m a -> Producer a m r

Repeat a monadic action a fixed number of times, yielding each result

replicateM  0      x = return ()

replicateM (m + n) x = replicateM m x >> replicateM n x  -- 0 <= {m,n}

replicateM :: Monad m => Int -> m a -> Producer a m ()

The natural unfold into a Producer with a step function and a seed

unfoldr next = id

Write Strings to stdout using putStrLn

Unlike toHandle, stdoutLn gracefully terminates on a broken output pipe

Write Strings to stdout using putStrLn

This does not handle a broken output pipe, but has a polymorphic return value

Consume all values using a monadic function

print values to stdout

Write Strings to a Handle using hPutStrLn

discard all incoming values

Apply a function to all values flowing downstream

map id = cat

map (g . f) = map f >-> map g

Apply a monadic function to all values flowing downstream

mapM return = cat

mapM (f >=> g) = mapM f >-> mapM g

Convert a stream of actions to a stream of values

Apply a function to all values flowing downstream, and forward each element of the result.

(filter predicate) only forwards values that satisfy the predicate.

filter (pure True) = cat

filter (liftA2 (&&) p1 p2) = filter p1 >-> filter p2

filter f = mapMaybe (\a -> a <$ guard (f a))

(mapMaybe f) yields Just results of f.

Basic laws:

mapMaybe (f >=> g) = mapMaybe f >-> mapMaybe g

mapMaybe (pure @Maybe . f) = mapMaybe (Just . f) = map f

mapMaybe (const Nothing) = drain

As a result of the second law,

mapMaybe return = mapMaybe Just = cat

(filterM predicate) only forwards values that satisfy the monadic predicate

filterM (pure (pure True)) = cat

filterM (liftA2 (liftA2 (&&)) p1 p2) = filterM p1 >-> filterM p2

filterM f = wither (\a -> (\b -> a <$ guard b) <$> f a)

(wither f) forwards Just values produced by the monadic action.

Basic laws:

wither (runMaybeT . (MaybeT . f >=> MaybeT . g)) = wither f >-> wither g

wither (runMaybeT . lift . f) = wither (fmap Just . f) = mapM f

wither (pure . f) = mapMaybe f

As a result of the second law,

wither (runMaybeT . return) = cat

As a result of the third law,

wither (pure . const Nothing) = wither (const (pure Nothing)) = drain

(take n) only allows n values to pass through

take 0 = return ()

take (m + n) = take m >> take n

take <infinity> = cat

take (min m n) = take m >-> take n

(takeWhile p) allows values to pass downstream so long as they satisfy the predicate p.

takeWhile (pure True) = cat

takeWhile (liftA2 (&&) p1 p2) = takeWhile p1 >-> takeWhile p2

(takeWhile' p) is a version of takeWhile that returns the value failing the predicate.

takeWhile' (pure True) = cat

takeWhile' (liftA2 (&&) p1 p2) = takeWhile' p1 >-> takeWhile' p2

(drop n) discards n values going downstream

drop 0 = cat

drop (m + n) = drop m >-> drop n

(dropWhile p) discards values going downstream until one violates the predicate p.

dropWhile (pure False) = cat

dropWhile (liftA2 (||) p1 p2) = dropWhile p1 >-> dropWhile p2

Flatten all Foldable elements flowing downstream

Outputs the indices of all elements that match the given element

Outputs the indices of all elements that satisfied the predicate

Strict left scan

Control.Foldl.purely scan :: Monad m => Fold a b -> Pipe a b m r

Strict, monadic left scan

Control.Foldl.impurely scanM :: Monad m => FoldM m a b -> Pipe a b m r

Apply an action to all values flowing downstream

chain (pure (return ())) = cat

chain (liftA2 (>>) m1 m2) = chain m1 >-> chain m2

Parse Readable values, only forwarding the value if the parse succeeds

Convert Showable values to Strings

Evaluate all values flowing downstream to WHNF

Create a Pipe from a ListT transformation

loop (k1 >=> k2) = loop k1 >-> loop k2

loop return = cat

Strict fold of the elements of a Producer

Control.Foldl.purely fold :: Monad m => Fold a b -> Producer a m () -> m b

Strict fold of the elements of a Producer that preserves the return value

Control.Foldl.purely fold' :: Monad m => Fold a b -> Producer a m r -> m (b, r)

Strict, monadic fold of the elements of a Producer

Control.Foldl.impurely foldM :: Monad m => FoldM a b -> Producer a m () -> m b

Strict, monadic fold of the elements of a Producer

Control.Foldl.impurely foldM' :: Monad m => FoldM a b -> Producer a m r -> m (b, r)

(all predicate p) determines whether all the elements of p satisfy the predicate.

(any predicate p) determines whether any element of p satisfies the predicate.

Determines whether all elements are True

Determines whether any element is True

(elem a p) returns True if p has an element equal to a, False otherwise

(notElem a) returns False if p has an element equal to a, True otherwise

Find the first element of a Producer that satisfies the predicate

Find the index of the first element of a Producer that satisfies the predicate

Retrieve the first element from a Producer

Index into a Producer

Retrieve the last element from a Producer

Count the number of elements in a Producer

Find the maximum element of a Producer

Find the minimum element of a Producer

Determine if a Producer is empty

Compute the sum of the elements of a Producer

Compute the product of the elements of a Producer

Convert a pure Producer into a list

Convert an effectful Producer into a list

Note: toListM is not an idiomatic use of pipes, but I provide it for simple testing purposes. Idiomatic pipes style consumes the elements immediately as they are generated instead of loading all elements into memory.

Convert an effectful Producer into a list alongside the return value

Note: toListM' is not an idiomatic use of pipes, but I provide it for simple testing purposes. Idiomatic pipes style consumes the elements immediately as they are generated instead of loading all elements into memory.

Zip two Producers

Zip two Producers using the provided combining function

Transform a Consumer to a Pipe that reforwards all values further downstream

Transform a unidirectional Pipe to a bidirectional Proxy

generalize (f >-> g) = generalize f >+> generalize g

generalize cat = pull