Simpler semantics: There is only one data type (Pipe), two primitives
(await and yield), and only one way to compose Pipes (.). In fact,
this library introduces no new operators, using only its Monad and
Category instances to implement all behavior.

Clearer naming conventions: Enumeratees are called Pipes, Enumerators
are Producers, and Iteratees are Consumers. Producers and Consumers
are just type synonyms for Pipes with either the input or output end
closed.

Pipes are Categories: You compose them using ordinary composition.
There are actually two Category instances: one for Lazy composition and
one for Strict composition. Both instances satisfy the Category laws.

Intuitive: Pipe composition is easier to reason about because it is a true
Category. Composition works seamlessly and you don't have to worry about
restarting iteratees, feeding new input, etc. "It just works".

"Vertical" concatenation works flawlessly on everything: (>>)
concatenates Pipes, but since everything is a Pipe, you can use it to
concatenate Producers, Consumers, and even intermediate Pipe stages.
Vertical Concatenation always works the way you expect, picking up where the
previous Pipe left off.

Symmetric implementation: Most iteratee libraries are either
enumerator-driven or iteratee-driven. Pipes are implemented
symmetrically, which is why they can be composed with either Lazy
(Consumer-driven) or Strict (Producer-driven) semantics.

Check out Control.Pipe for a copious introduction (in the spirit of the
iterIO library) and Control.Pipe.Common for the actual implementation.

This library does not yet provide convenience Pipes for common operations,
but they are forthcoming. However, there are several examples in the
documentation to get you started and I encourage you to write your own to see
how easy they are to write.