Pipe is a Python module enabling infix syntax in Python. For those asking "Why ?" let's take an example: Compare the readability of the classical prefix syntax:

sum(select(where(take_while(fib(), lambda x: x < 1000000) lambda x: x % 2), lambda x: x * x))

And the infix syntax:

fib() | take_while(lambda x: x < 1000000) \ | where(lambda x: x % 2) \ | select(lambda x: x * x) \ | sum()

Isn't the infix syntax more readable? The base class of Pipe is kept
simple (7 lines of python) and is usable as a decorator permitting you
to create new 'pipeable' functions easily. The module provides like 30
prepared pipes functions like `where`

, `group_by`

, `sort`

,
`take_while`

... A pipeable function takes an iterable (`tuple`

, `list`

,
`generator`

) and yields to be itself an iterator, so pipeable function can
be piped together. Let me introduce the basic usage of the `Pipe`

module,
then I'll write some bits on how to build new ones: To start, get it
from PyPI http://pypi.python.org/pypi/pipe/1.3 and install it, open a
REPL, import pipe, and play:

Python 2.6.6 (r266:84292, Dec 26 2010, 22:31:48) [GCC 4.4.5] on linux2 Type "help", "copyright", "credits" or "license" for more information. >>> from pipe import * >>> [1, 2, 3, 4, 5] | add 15 >>> [5, 4, 3, 2, 1] | sort [1, 2, 3, 4, 5]

Until here it's easy, to know more about available pipes, just read the
`help(pipe)`

in the REPL, all are explained with an example as a doctest
Now as we know that pipeable functions use iterables, we can try to pipe
together two or more pipeables:

>>> [1, 2, 3, 4, 5] | where(lambda x: x % 2) | concat '1, 3, 5' >>> [1, 2, 3, 4, 5] | where(lambda x: x % 2) | tail(2) | concat '3, 5' >>> [1, 2, 3, 4, 5] | where(lambda x: x % 2) | tail(2) | select(lambda x: x * x) | concat '9, 25' >>> [1, 2, 3, 4, 5] | where(lambda x: x % 2) | tail(2) | select(lambda x: x * x) | add 34

Now, a bit about lazyness, as Pipe use iterables, the evaluation of a whole Pipe is lazy, so we can play with infinite generators like this one :

>>> def fib(): ... a, b = 0, 1 ... while True: ... yield a ... a, b = b, a + b

Now we can do every kind of stuff into the fibonacci sequence, like solving the 2nd problem of http://projecteuler.net in a readable one liner:

Find the sum of all the even-valued terms in Fibonacci which do not exceed four million.

>>> euler2 = fib() | where(lambda x: x % 2 == 0) | take_while(lambda x: x < 4000000) | add >>> assert euler2 == 4613732

Isn't it pretty? Let now see how to create new pipeable functions using
the `@pipe`

decorator: You want to create a function that yields the
first x elements from its input You want its usage to be ```
(1, 2, 3, 4, 5)
| take(2)
```

to take the fist 2 elements. I know that you are thinking
about a basic implementation like:

def take(iterable, qte): for item in iterable: if qte > 0: qte -= 1 yield item else: return

Right? You take an iterable, a qantity, and while the quantity is not
reached, you just have to yield? OK, just add `@pipe`

to you take
function and it's pipeable :-)