python-peps / pep-0309.txt

The default branch has multiple heads

PEP: 309
Title: Partial Function Application
Version: $Revision$
Last-Modified: $Date$
Author: Peter Harris <>
Status: Final
Type: Standards Track
Content-Type: text/x-rst
Created: 08-Feb-2003
Python-Version: 2.5
Post-History: 10-Feb-2003, 27-Feb-2003, 22-Feb-2004, 28-Apr-2006


Following the acceptance of this PEP, further discussion on python-dev and
comp.lang.python revealed a desire for several tools that operated on
function objects, but were not related to functional programming.  Rather
than create a new module for these tools, it was agreed [1]_ that the
"functional" module be renamed to "functools" to reflect its newly-widened

References in this PEP to a "functional" module have been left in for
historical reasons.


This proposal is for a function or callable class that allows a new
callable to be constructed from a callable and a partial argument list
(including positional and keyword arguments).

I propose a standard library module called "functional", to hold
useful higher-order functions, including the implementation of

An implementation has been submitted to SourceForge [2]_.


Patch #941881 was accepted and applied in 2005 for Py2.5.  It is
essentially as outlined here, a partial() type constructor binding
leftmost positional arguments and any keywords.  The partial object has
three read-only attributes func, args, and keywords.  Calls to the partial
object can specify keywords that override those in the object itself.

There is a separate and continuing discussion of whether to modify the
partial implementation with a __get__ method to more closely emulate
the behavior of an equivalent function.


In functional programming, function currying is a way of implementing
multi-argument functions in terms of single-argument functions.  A
function with N arguments is really a function with 1 argument that
returns another function taking (N-1) arguments.  Function application
in languages like Haskell and ML works such that a function call::

    f x y z

actually means::

   (((f x) y) z)

This would be only an obscure theoretical issue except that in actual
programming it turns out to be very useful.  Expressing a function in
terms of partial application of arguments to another function can be
both elegant and powerful, and in functional languages it is heavily

In some functional languages, (e.g. Miranda) you can use an expression
such as ``(+1)`` to mean the equivalent of Python's
``(lambda x: x + 1)``.

In general, languages like that are strongly typed, so the compiler
always knows the number of arguments expected and can do the right
thing when presented with a functor and less arguments than expected.

Python does not implement multi-argument functions by currying, so if
you want a function with partially-applied arguments you would
probably use a lambda as above, or define a named function for each

However, lambda syntax is not to everyone's taste, so say the least.
Furthermore, Python's flexible parameter passing using both positional
and keyword presents an opportunity to generalise the idea of partial
application and do things that lambda cannot.

Example Implementation

Here is one way to do a create a callable with partially-applied
arguments in Python.  The implementation below is based on improvements
provided by Scott David Daniels::

    class partial(object):

        def __init__(*args, **kw):
            self = args[0]
            self.fn, self.args, = (args[1], args[2:], kw)

        def __call__(self, *args, **kw):
            if kw and
                d =
                d = kw or
            return self.fn(*(self.args + args), **d)

(A recipe similar to this has been in the Python Cookbook for some
time [3]_.)

Note that when the object is called as though it were a function,
positional arguments are appended to those provided to the
constructor, and keyword arguments override and augment those provided
to the constructor.

Positional arguments, keyword arguments or both can be supplied at
when creating the object and when calling it.

Examples of Use

So ``partial(operator.add, 1)`` is a bit like ``(lambda x: 1 + x)``.
Not an example where you see the benefits, of course.

Note too, that you could wrap a class in the same way, since classes
themselves are callable factories for objects.  So in some cases,
rather than defining a subclass, you can specialise classes by partial
application of the arguments to the constructor.

For example, ``partial(Tkinter.Label, fg='blue')`` makes Tkinter
Labels that have a blue foreground by default.

Here's a simple example that uses partial application to construct
callbacks for Tkinter widgets on the fly::

    from Tkinter import Tk, Canvas, Button
    import sys
    from functional import partial

    win = Tk()
    c = Canvas(win,width=200,height=50)

    for colour in sys.argv[1:]:
        b = Button(win, text=colour,
                   command=partial(c.config, bg=colour))


Abandoned Syntax Proposal

I originally suggested the syntax ``fn@(*args, **kw)``, meaning the
same as ``partial(fn, *args, **kw)``.

The @ sign is used in some assembly languages to imply register
indirection, and the use here is also a kind of indirection.
``f@(x)`` is not ``f(x)``, but a thing that becomes ``f(x)`` when you
call it.

It was not well-received, so I have withdrawn this part of the
proposal.  In any case, @ has been taken for the new decorator syntax.

Feedback from comp.lang.python and python-dev

Among the opinions voiced were the following (which I summarise):

* Lambda is good enough.

* The @ syntax is ugly (unanimous).

* It's really a curry rather than a closure.  There is an almost
  identical implementation of a curry class on ActiveState's Python

* A curry class would indeed be a useful addition to the standard

* It isn't function currying, but partial application.  Hence the
  name is now proposed to be partial().

* It maybe isn't useful enough to be in the built-ins.

* The idea of a module called ``functional`` was well received, and
  there are other things that belong there (for example function

* For completeness, another object that appends partial arguments
  after those supplied in the function call (maybe called
  ``rightcurry``) has been suggested.

I agree that lambda is usually good enough, just not always.  And I
want the possibility of useful introspection and subclassing.

I disagree that @ is particularly ugly, but it may be that I'm just
weird.  We have dictionary, list and tuple literals neatly
differentiated by special punctuation -- a way of directly expressing
partially-applied function literals is not such a stretch.  However,
not one single person has said they like it, so as far as I'm
concerned it's a dead parrot.

I concur with calling the class partial rather than curry or closure,
so I have amended the proposal in this PEP accordingly.  But not
throughout: some incorrect references to 'curry' have been left in
since that's where the discussion was at the time.

Partially applying arguments from the right, or inserting arguments at
arbitrary positions creates its own problems, but pending discovery of
a good implementation and non-confusing semantics, I don't think it
should be ruled out.

Carl Banks posted an implementation as a real functional closure::

    def curry(fn, *cargs, **ckwargs):
        def call_fn(*fargs, **fkwargs):
            d = ckwargs.copy()
            return fn(*(cargs + fargs), **d)
        return call_fn

which he assures me is more efficient.

I also coded the class in Pyrex, to estimate how the performance
might be improved by coding it in C::

    cdef class curry:

        cdef object fn, args, kw

        def __init__(self, fn, *args, **kw):
   = kw

        def __call__(self, *args, **kw):
            if        # from Python Cookbook version
                d =
            return self.fn(*(self.args + args), **d)

The performance gain in Pyrex is less than 100% over the nested
function implementation, since to be fully general it has to operate
by Python API calls.  For the same reason, a C implementation will be
unlikely to be much faster, so the case for a built-in coded in C is
not very strong.


I prefer that some means to partially-apply functions and other
callables should be present in the standard library.

A standard library module ``functional`` should contain an
implementation of ``partial``, and any other higher-order functions
the community want.  Other functions that might belong there fall
outside the scope of this PEP though.

Patches for the implementation, documentation and unit tests (SF
patches 931005_, 931007_, and 931010_ respectively) have been
submitted but not yet checked in.

A C implementation by Hye-Shik Chang has also been submitted, although
it is not expected to be included until after the Python
implementation has proven itself useful enough to be worth optimising.


.. [1]

.. [2] Patches 931005_, 931007_, and 931010_.

.. [3]

.. _931005:
.. _931007:
.. _931010:


This document has been placed in the public domain.

   Local Variables:
   mode: indented-text
   indent-tabs-mode: nil
   sentence-end-double-space: t
   fill-column: 70