RetroSearch Browse

Mon Feb 23 11:58:23 EST 2004 · https://mail.python.org/pipermail/python-dev/2004-February/042683.html

On Monday 2004-02-23 16:06, Andrew Koenig wrote:

> 	Function currying is the process of transforming a function that
> 	expects all of its arguments at once into a delayed function
> 	(called a curried function), that expects only its first argument.
> 	If the first argument is the only argument, currying is the
> 	identity function.  Otherwise, the delayed function, itself also
> 	curried, expects the first of the remaining arguments and yields
> 	either the result (if there is only one remaining argument) or
> 	a similarly delayed, curried function that deals with the second
> 	and subsequent remaining arguments.

I think it's better to define partical application and
currying together, as follows.

    Partial application is a way of transforming a function by
    specifying values for some of its arguments.

    If f is a function of n arguments and 0 <= m <= n, then the
    partial application of f to y1,...,ym is a function f1
    of n-m arguments such that

        f1(x(m+1),...,xn) = f(y1,...,ym, x(m+1),...,xn).

    Currying is a way of transforming a function so that instead
    of accepting all its arguments at once it accepts just the first,
    returning a function which accepts just the second, returning
    a function which accepts just the third, and so on. Formally,
    denote the partial application of f to y1,...,ym by f[y1,...,ym];
    then currying is the function transformer C such that

      - when f is a function of no arguments, C(f) = f();
      - when f is a function of at least one argument,
        C(f) is the 1-argument function taking y1 to C(f[y1]).

    Note that currying a no-argument function yields not a
    function but a constant; currying a 1-argument function
    yields the same function.

    It follows that C(f)(x1)(x2)...(xn) = f(x1,x2,...,xn).

In a context where the definition of partial application isn't
useful, this can be shortened to

    Currying is a way of transforming a function so that instead
    of accepting all its arguments at once it accepts just the first,
    returning a function which accepts just the second, returning
    a function which accepts just the third, and so on. Formally,
    given a function of at least one argument and a value y1, denote
    by f[y1] the function that takes (x2,...,xn) to f(y1,x2,...,xn).
    Then currying is the function transformer C such that

      - when f is a function of no arguments, C(f) = f();
      - when f is a function of at least one argument,
        C(f) is the 1-argument function taking y1 to C(f[y1]).

    It follows that C(f)(x1)(x2)...(xn) = f(x1,x2,...,xn).

    Note that currying a no-argument function yields not a
    function but a constant; currying a 1-argument function
    yields the same function; currying any function with at
    least one argument yields a function that takes exactly
    one argument.

I think it's elegant to start the definition at 0-argument
functions, but obviously you can alternatively define currying
only for functions of at least one argument, in which case
you have the advantage that it always yields a function :-).

-- 
g

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://mail.python.org/pipermail/python-dev/2004-February/042683.html below:

[Python-Dev] PEP 309, function currying