# Curry¶

Traditionally partial evaluation of functions is handled with the `partial` higher order function from `functools`. Currying provides syntactic sugar.

```>>> double = partial(mul, 2)    # Partial evaluation
>>> doubled = double(2)         # Currying
```

This syntactic sugar is valuable when developers chain several higher order functions together.

## Partial Evaluation¶

Often when composing smaller functions to form big ones we need partial evaluation. We do this in the word counting example:

```>>> def stem(word):
...     """ Stem word to primitive form """
...     return word.lower().rstrip(",.!:;'-\"").lstrip("'\"")

>>> wordcount = compose(frequencies, partial(map, stem), str.split)
```

Here we want to map the `stem` function onto each of the words produced by `str.split`. We want a `stem_many` function that takes a list of words, stems them, and returns a list back. In full form this would look like the following:

```>>> def stem_many(words):
...     return map(stem, words)
```

The `partial` function lets us create this function more naturally.

```>>> stem_many = partial(map, stem)
```

In general

```>>> def f(x, y, z):
...     # Do stuff with x, y, and z

>>> # partially evaluate f with known values a and b
>>> def g(z):
...     return f(a, b, z)

>>> # partially evaluate f with known values a and b
>>> g = partial(f, a, b)
```

## Curry¶

In this context currying is just syntactic sugar for partial evaluation. A curried function partially evaluates if it does not receive enough arguments to compute a result.

```>>> from toolz import curry

>>> @curry              # We can use curry as a decorator
... def mul(x, y):
...     return x * y

>>> double = mul(2)     # mul didn't receive enough arguments to evaluate
...                     # so it holds onto the 2 and waits, returning a
...                     # partially evaluated function, double

>>> double(5)
10
```

So if `map` was curried…

```>>> map = curry(map)
```

Then we could replace the `partial` with a function evaluation

```>>> # wordcount = compose(frequencies, partial(map, stem), str.split)
>>> wordcount = compose(frequencies, map(stem), str.split)
```

In this particular example it’s probably simpler to stick with `partial`. Once `partial` starts occurring several times in your code it may be time to switch to the `curried` namespace.

## The Curried Namespace¶

All functions present in the `toolz` namespace are curried in the `toolz.curried` namespace.

So you can exchange an import line like the following

```>>> from toolz import *
```

For the following

```>>> from toolz.curried import *
```

And all of your favorite `toolz` functions will curry automatically. We’ve also included curried versions of the standard Python higher order functions like `map`, `filter`, `reduce` so you’ll get them too (whether you like it or not.)