Pipes

A Proxy is a monad transformer that receives and sends information on both an upstream and downstream interface.

The type variables signify:

• a' and a - The upstream interface, where (a')s go out and (a)s come in

• b' and b - The downstream interface, where (b)s go out and (b')s come in

• m - The base monad

• r - The return value

The empty type, used to close output ends

An effect in the base monad

Effects neither await nor yield

Like Effect, but with a polymorphic type

Run a self-contained Effect, converting it back to the base monad

The list monad transformer, which extends a monad with non-determinism

The type variables signify:

• m - The base monad

• a - The values that the computation yields throughout its execution

For basic construction and composition of ListT computations, much can be accomplished using common typeclass methods.

• return corresponds to yield, yielding a single value.

• (>>=) corresponds to for, calling the second computation once for each time the first computation yields.

• mempty neither yields any values nor produces any effects in the base monad.

• (<>) sequences two computations, yielding all the values of the first followed by all the values of the second.

• lift converts an action in the base monad into a ListT computation which performs the action and yields a single value.

ListT is a newtype wrapper for Producer. You will likely need to use Select and enumerate to convert back and forth between these two types to take advantage of all the Producer-related utilities that Pipes.Prelude has to offer.

• To lift a plain list into a ListT computation, first apply each to turn the list into a Producer. Then apply the Select constructor to convert from Producer to ListT.

• For other ways to construct ListT computations, see the “Producers” section in Pipes.Prelude to build Producers. These can then be converted to ListT using Select.

• To aggregate the values from a ListT computation (for example, to compute the sum of a ListT of numbers), first apply enumerate to obtain a Producer. Then see the “Folds” section in Pipes.Prelude to proceed.

Run a self-contained ListT computation

Enumerable generalizes Foldable, converting effectful containers to ListTs.

Instances of Enumerable must satisfy these two laws:

toListT (return r) = return r

toListT $ do x <- m  =  do x <- toListT m
             f x           toListT (f x)

In other words, toListT is monad morphism.

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.

Convert a Foldable to a Producer

each :: (Functor m, Foldable f) => f a -> Producer a m ()

Convert an Enumerable to a Producer

every :: (Monad m, Enumerable t) => t m a -> Producer a m ()

Discards a value

void value discards or ignores the result of evaluation, such as the return value of an System.IO.IO action.

Examples

Replace the contents of a Maybe Int with unit:

>>> void NothingNothing

>>> void (Just 3)Just ()

Replace the contents of an Either Int Int with unit, resulting in an Either Int ():

>>> void (Left 8675309)Left 8675309

>>> void (Right 8675309)Right ()

Replace every element of a list with unit:

>>> void [1,2,3][(),(),()]

Replace the second element of a pair with unit:

>>> void (1,2)(1,())

Discard the result of an System.IO.IO action:

>>> mapM print [1,2]12[(),()]

>>> void $ mapM print [1,2]12

Monads that also support choice and failure.

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)

The class of monad transformers. For any monad m, the result t m should also be a monad, and lift should be a monad transformation from m to t m, i.e. it should satisfy the following laws:

• lift . return = return

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

Since 0.6.0.0 and for GHC 8.6 and later, the requirement that t m be a Monad is enforced by the implication constraint forall m. Monad m => Monad (t m) enabled by the QuantifiedConstraints extension.

Ambiguity error with GHC 9.0 to 9.2.2

These versions of GHC have a bug (https://gitlab.haskell.org/ghc/ghc/-/issues/20582) which causes constraints like

(MonadTrans t, forall m. Monad m => Monad (t m)) => ...

to be reported as ambiguous. For transformers 0.6 and later, this can be fixed by removing the second constraint, which is implied by the first.

A functor in the category of monads, using hoist as the analog of fmap:

hoist (f . g) = hoist f . hoist g

hoist id = id

A monad in the category of monads, using lift from MonadTrans as the analog of return and embed as the analog of (=<<):

embed lift = id

embed f (lift m) = f m

embed g (embed f t) = embed (\m -> embed g (f m)) t

The Foldable class represents data structures that can be reduced to a summary value one element at a time. Strict left-associative folds are a good fit for space-efficient reduction, while lazy right-associative folds are a good fit for corecursive iteration, or for folds that short-circuit after processing an initial subsequence of the structure's elements.

Instances can be derived automatically by enabling the DeriveFoldable extension. For example, a derived instance for a binary tree might be:

{-# LANGUAGE DeriveFoldable #-}
data Tree a = Empty
            | Leaf a
            | Node (Tree a) a (Tree a)
    deriving Foldable

A more detailed description can be found in the Overview section of Data.Foldable#overview.

For the class laws see the Laws section of Data.Foldable#laws.