[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
Re: It's not currying!
This page is part of the web mail archives of SRFI 26 from before July 7th, 2015. The new archives for SRFI 26 contain all messages, not just those from before July 7th, 2015.
> Stephan wrote:
> I have a very simple problem with this SRFI:
> the name is wrong. What is described is
> not currying (that much is admitted in
> the draft itself!)
> What *is* described is partial application.
> Now it so happens that if
> 1. multiple-argument functions are really
> curried, single-argument functions, and
> 2. all evaluation is lazy,
> then there is no semantic difference between
> partial application on the first argument and
> full application. So one gets partial application
> "for free".
Indeed, the macro 'curry' provides only partial
application, and this is clearly stated in the
"The mechanism proposed here is in fact only a
specialization of parameters. It does not really do
currying in the sense of constructing a procedure in
one argument that returns a procedure in one argument
and so on."
So, let me briefly explain why I have nevertheless
proposed a certain name for "a macro that does not
In the first place, currying is a very important
theoretical device because it reduces multiple-argument
functions to single-argument functions only (Schoenfinkel,
1924). Moreover, as you point out quite correctly,
programming languages in which functions are inherently
curried can provide a notation for partial application
on the first argument "for free". Scheme, on the other
hand is not curried, in the sense that functions are
inherently multiple-argument, and hence does not provide
any compact notation for partial application.
Even worse, Scheme is not prepared to deal with
nested single-argument functions. For example, there is
no function to apply several arguments to such a curried
function. Moreover, there is no way at all to deal with
variable-arity functions---which have proven quite a
useful feature of Scheme after all.
Hence, the usual concept of currying a multiple-argument
function into a nesting of lambda-_expression_ (although
possible) is of very limited use in Scheme. In fact,
it facilitates programming less than one might expect.
After this observation, I concluded that an efficient
notation for partial evaluation might be as good as
it gets when it comes to currying in Scheme. In fact,
partial application does what you want to achieve with
currying in other languages. (There is another aspect
related to typing, though.)
Because of this I saw (and still see) little harm in
calling the macro for partial application 'curry'.
Obviously, this point of view is not always shared
as several people have already complained about it.
As I do not put too much emphasis on the name of the
macro, as long as it is specific and intuitive, I
would like to propose the name
and offer to rewrite the SRFI-document accordingly.
This includes a better explanation of what the difference
and relation is between currying and partial application.
Does this resolve you problem with the name?