Talk:Partial function application

Explicit curry vs Partial application

In Python there is a clear difference. Here's explicit currying:

<lang python>def fsf1(fs, f1):

   return lambda s: fs(f1, s)</lang>

I would like to tie this task down, but now recognise that it may be difficult.

Any programmers, especially those with functional as well as none functional language experience care to comment? --Paddy3118 02:28, 26 March 2011 (UTC)

With Common Lisp, the explicit currying seems to be the only way to do the partial application. I try to show this with code. This is mapcar with 2 arguments.

<lang lisp>CL-USER> (defun f1 (n) (* n 2))

F1 CL-USER> (mapcar #'f1 '(2 3 5 7)) (4 6 10 14)</lang>

I can use lambda for the explicit currying, like one would in Python.

<lang lisp>CL-USER> ((lambda (s) (mapcar #'f1 s)) '(2 3 5 7))

(4 6 10 14)</lang>

I can also define a partial function for the partial application; but it uses the explicit currying to do so.

<lang lisp>CL-USER> (defun partial (f &rest args)

(lambda (&rest args2) (apply f (append args args2)))) PARTIAL CL-USER> (funcall (partial #'mapcar #'f1) '(2 3 5 7)) (4 6 10 14)</lang>

There is not much reason to write (partial #'mapcar #'f1) instead of (lambda (s) (mapcar #'f1 s)). This would be like writing sum((2, 3)) instead of 2 + 3 in Python. --Kernigh 02:34, 1 April 2011 (UTC)

Is it the case that there is no real distinction in Lisp, but a significant distinction in other languages?

What about the other feature I seem to see in partial application: that of not needing to refer explicitely to the other arguments of the function being partially applied? E.g. with function f(a,b,c,d); you can partial(f, a=value1) to produce f'(b,c,d) without mention of b, c, and d when calling partial. --Paddy3118 06:29, 1 April 2011 (UTC)

First considering the feature of not referring to other arguments, I would expect this to be possible in most languages with dynamic types, but not possible in languages with static type checking. Kernigh's partial handles this just fine using apply, for example. This document I found calls it generalized explicit currying and gives example code in Scheme. In Go, with it's static type checking, I can write a partial that does explicit currying for functions with specific type signatures, but I can't write a partial that does generalized explicit currying for functions with arbitrary type signatures.

Which leads back to the first question of the distinction between (partial #'mapcar #'f1) and (lambda (s) (mapcar #'f1 s)). There are two distinctions! Function/lambda expression and generalized/specific. (And they are orthogonal: You could write a specific function or a generalized lambda expression.) Anyway, there seems little point in either a function or generality in the case of this task as currently written. You could just write fsf1 = lambda s: fs(f1, s) in Python, for example.

As far as changes to the task, I think it's fine the way it is. —Sonia 06:28, 13 April 2011 (UTC)

Hi. Ocaml and Haskell are statically typed and yet don't seem to need to mention the other arguments. At this stage, I want a task that fits the page title so am trying to explore what partial function application could mean for many languages. --Paddy3118 07:00, 13 April 2011 (UTC)