By ElfsЯUs

2012-02-26 23:21:49 8 Comments

I am trying to write a currying decorator in python, and I think I've got the general idea down, but still got some cases that aren't working right...

def curry(fun):

    cache = []
    numargs = fun.func_code.co_argcount

    def new_fun(*args, **kwargs):
        print args
        print kwargs

        if len(cache) >= numargs:   # easier to do it explicitly than with exceptions

            temp = []
            for _ in xrange(numargs):

    return new_fun

def myfun(a,b):
    print a,b

While for the following case this works fine:


For the following case it fails:


Any pointers on how to correctly do this would be greatly appreciated!



@czheo 2019-03-01 12:46:44

One-liner just for fun:

from functools import partial
curry = lambda f: partial(*[partial] * f.__code__.co_argcount)(f)

def add(x, y, z):
    return x + y + z

# output = 9

@crazzle 2018-03-17 12:34:23

The solution from Roger Christman will not work with every constellation. I applied a small fix to also handle this situation:


The small fix that makes it work with every constellation lies in the returned lambda:

def curried(func):
    def curry(*args):
        if len(args) == func.__code__.co_argcount:
            ans = func(*args)
            return ans
            return lambda *x: curry(*(args+x))
    return curry

@Roger Christman 2017-03-15 00:06:25

Here is my version of curry that doesn't use partial, and makes all the functions accept exactly one parameter:

def curry(func):
"""Truly curry a function of any number of parameters
returns a function with exactly one parameter
When this new function is called, it will usually create
and return another function that accepts an additional parameter,
unless the original function actually obtained all it needed
at which point it just calls the function and returns its result
def curried(*args):
    either calls a function with all its arguments,
    or returns another functiont that obtains another argument
    if len(args) == func.__code__.co_argcount:
        ans = func(*args)
        return ans
        return lambda x: curried(*(args+(x,)))

return curried

@crazzle 2018-03-17 12:31:20

Hi, this one is not working on all edge cases. I added the solution (with code) in my answer. By the way, I think this solution is by far most intuitive one!

@MRocklin 2013-10-28 01:50:41

The source code for curry in the toolz library is available at the following link.

It handles args, kwargs, builtin functions, and error handling. It even wraps the docstrings back onto the curried object.

@metaperture 2015-10-09 16:36:32

This is by far the best answer, and using the cytoolz version of the library is very fast. I don't think any other answer on here handles default arguments correctly.

@Shashank 2015-06-08 16:07:15

Many of the answers here fail to address the fact that a curried function should only take one argument.

A quote from Wikipedia:

In mathematics and computer science, currying is the technique of translating the evaluation of a function that takes multiple arguments (or a tuple of arguments) into evaluating a sequence of functions, each with a single argument (partial application).

Choosing to decorate it with recursion and without co_argcount makes for a decently elegant solution.

from functools import partial, wraps, reduce

def curry(f):
    def _(arg):
            return f(arg)
        except TypeError:
            return curry(wraps(f)(partial(f, arg)))
    return _

def uncurry(f):
    def _(*args):
        return reduce(lambda x, y: x(y), args, f)
    return _

As shown above, it is also fairly trivial to write an uncurry decorator. :) Unfortunately, the resulting uncurried function will allow any number of arguments instead of requiring a specific number of arguments, as may not be true of the original function, so it is not a true inverse of curry. The true inverse in this case would actually be something like unwrap, but it would require curry to use functools.wraps or something similar that sets a __wrapped__ attribute for each newly created function:

def unwrap(f):
        return unwrap(f.__wrapped__)
    except AttributeError:
        return f

@Julien Palard 2014-08-01 11:03:47

As it's cool to write currying decorators in python, I tried mine: 5 lines of code, readable, and tested curry function.

def curry(func):
    def curried(*args, **kwargs):
        if len(args) + len(kwargs) >= func.__code__.co_argcount:
            return func(*args, **kwargs)
        return (lambda *args2, **kwargs2:
                curried(*(args + args2), **dict(kwargs, **kwargs2)))
    return curried

@alancalvitti 2019-09-03 13:43:49

Julien, can your method be easily extended to curry at a specified position (partial eval)?

@Julien Palard 2019-09-03 13:49:21

@alancalvitti did you tried functools.partial?

@alancalvitti 2019-09-09 19:47:06

I've tested it but I don't see how it can automatically select the specified argument. For example, I'm looking for curry_at(2) (in general, curry_at(n)) to extract the 2nd (nth) argument in args for partial eval.

@Alex Gaudio 2014-05-15 01:46:09

This one is fairly simple and doesn't use inspect or examine the given function's args

import functools

def curried(func):
    """A decorator that curries the given function.

    def a(b, c):
        return (b, c)

    a(c=1)(2)  # returns (2, 1)
    def _curried(*args, **kwargs):
        return functools.partial(func, *args, **kwargs)
    return _curried

@alancalvitti 2019-08-29 20:47:57

Can you extend this method to curry_at a user-specified index position?

@georg 2012-02-26 23:38:28

The below implementation is naive, google for "currying python" for more accurate examples.

def curry(x, argc=None):
    if argc is None:
        argc = x.func_code.co_argcount
    def p(*a):
        if len(a) == argc:
            return x(*a)
        def q(*b):
            return x(*(a + b))
        return curry(q, argc - len(a))
    return p

def myfun(a,b,c):
    print '%d-%d-%d' % (a,b,c)


@ElfsЯUs 2012-02-27 00:00:51

Thanks man! Yah, I realized it needed to be recursive, but just had no idea how to implicitly create a function with n-1 arguments. Very cool!

@NullPointer 2012-03-23 14:11:38

in python 2.6 or python 3, the line 3 should written as: argc = x.__code__.co_argcount

@MB. 2018-12-01 00:29:42

"Google for currying python": that's funny because it's now the top google result.

@James Jensen 2013-06-27 02:23:22

I think I've got a better one:

def curried (function):
    argc = function.__code__.co_argcount

    # Pointless to curry a function that can take no arguments
    if argc == 0:
        return function

    from functools import partial
    def func (*args):
        if len(args) >= argc:
            return function(*args)
            return partial(func, *args)
    return func

This solution uses Python's own functools.partial function instead of effectively recreating that functionality. It also allows you to pass in more arguments than the minimum, -allows keyword arguments,- and just passes through functions that don't have to take arguments, since those are pointless to curry. (Granted, the programmer should know better than to curry zero-arity or multi-arity functions, but it's better than creating a new function in that case.)

UPDATE: Whoops, the keyword argument part doesn't actually work right. Also, optional arguments are counted in the arity but *args are not. Weird.

Related Questions

Sponsored Content

45 Answered Questions

[SOLVED] How do I merge two dictionaries in a single expression in Python?

21 Answered Questions

[SOLVED] What are metaclasses in Python?

42 Answered Questions

[SOLVED] How to get the current time in Python

  • 2009-01-06 04:54:23
  • user46646
  • 3339581 View
  • 2941 Score
  • 42 Answer
  • Tags:   python datetime time

18 Answered Questions

[SOLVED] What is 'Currying'?

26 Answered Questions

[SOLVED] Does Python have a ternary conditional operator?

62 Answered Questions

[SOLVED] Calling an external command from Python

10 Answered Questions

[SOLVED] Does Python have a string 'contains' substring method?

13 Answered Questions

[SOLVED] How does the @property decorator work?

17 Answered Questions

[SOLVED] How to make a chain of function decorators?

Sponsored Content