Comments on: Using “foldr” in Haskell

By: cptfinch

cptfinch — Fri, 18 Jul 2008 10:50:38 +0000

Thanks chaps for that. I’m working my way through the YAHT pdf (Yet Another Haskell Tutorial) and the explanation of currying and parital application has cleared it up somewhat.

By: BMeph

BMeph — Thu, 17 Jul 2008 18:52:52 +0000

Oh sorry for making another entry, but a help to see why/how your update works is to note the use of the function “flip.” Here’s the Haskell-style type signature (what you’d call a “function declaration” in C or Java, except in Haskell, they’re almost always optional)

flip :: (a -> b -> c) -> b -> a -> c

In short: what “flip” does, is take a two-argument function (more-or-less; there are points to make on whether “two-argument function” even makes sense - I’ll assume you get my meaning), and gives back a two-argument function, just with the order of the arguments switched. So, look back at your original MyAppend:

myAppend a b = foldr (:) b a

You could, using that whole “partial application” thing, call the “foldr (:)” part a function in its own right (since it is), and use flip on it to flip the arguments back around:

myAppend a b = flip (foldr (:)) a b

Even better: you can see now, that the arguments (a b) are given to the functions in the same order - so that means they’re the same function! In the world of Lambda Calculus, it’s called “eta reduction,” but I like to think of it as transitivity on functions. Or to put it into regular talk, “two things equal to the same thing are equal to each other,” once more taking liberties with the language - please don’t hurt me, Math Gods!

So, we can just drop the arguments out of the picture and write:

myAppend = flip (foldr (:))

and Haskell accepts that as a perfectly valid definition for a function! Of course, we still have to remember that it needs two arguments given to it, to give an answer (useful to us, anyway), but that’s our problem.

So, to quote your quote, that’s another reason Haskell is “precision engineering for programmers”

By: BMeph

BMeph — Thu, 17 Jul 2008 16:59:25 +0000

I think when you say “currying,” you really mean “partial application”. Currying (which I associate with brushing down a horse), is where you have a function that takes, say, a pair of arguments (p,q), and “changes” it into a function that takes one argument, p, and gives back another function that takes the second argument, q, as an argument, and that function gives the same answer that just giving (p,q) to the original function gave. Partial application is where you take that other function (not the “changed” one, but the resulting function you get from giving p to the “changed” one), and use that function as a separate function in its own right (which, well, it is, it just isn’t emphasized as such usually).

The point is, especially in “imperative” language use, you can’t do partial application “on the fly” - you have to deliberately define a new function, with separate arguments, that calls the original function in its body. Another point is, that the arguments of a function aren’t thought of as being a tuple (a pair, triple, quadruple, or whatever); the argument list is just a convenient way to show that those particular arguments are the ones being given to the function. Functions aren’t thought of as being given a single, “tuple” argument; they’re thought of as having multiple arguments, with a syntax that specifies those arguments which go to the function.

It helps if you have a language that facilitates returning a function as a result, as well as functions that accept other functions as arguments.