Comments on: Currying in Smalltalk, part 2

By: Vassili Bykov

Vassili Bykov — Tue, 27 Mar 2007 05:10:40 +0000

The alternatives show very well what currying (or in fact, multi-argument functions and their applications in general) is all about. If you imagine a system where blocks can only have one argument, you could implement multi-argument blocks by nesting, just like in your last example

[:a1 :a2 ... aN | ...] => [:a1 [:a2 [... [:aN | ... ]]]]

and rewriting every block invocation as nested ‘value:’ message sends

aBlock value: a value: b value: c => ((aBlock value: a) value: b ) value: c

The messages gradually “unwrap” the block. If there are enough of them, you end up running the inner block as in a “regular” block invocation. If not enough, you are left with a closure for the remaining layers, with the arguments provided so far captured in the closure’s environment.

By: Björn

Björn — Mon, 26 Mar 2007 10:48:35 +0000

What comes to my mind is
If you want to define derivation by means of blocks you can do it as follows:
df := [:f :x :h | (f value: x + h) - (f value: x) / h].
func := [:x | x ** 3].
df value: func value: 4711 value: 1000000 reciprocal

Or you can use some kind of more explicit cyrrying (if one should call it currying…)
curry := [:f | [:x :h | (f value: x + h) - (f value: x) / h].].
cyrryDf := curryvalue: [:x | x ** 3] .
cyrryDf value: 4 value: 100000000000 reciprocal

In this way the add example in the text could be written
| add inc |
add := [:x | [:a :b | (a + x) + (b + x)]].
inc := add value: 1.
inc value: 2 value: 3

Any comments on these more explicit alternatives?

By: Vassili Bykov

Vassili Bykov — Sat, 24 Mar 2007 19:35:52 +0000

Yep, you are onto something here, and there will be chapters 3 and 4 at least. :) I’m now in a middle of a move though, so I can’t promise a chapter a day…

By: Travis Griggs

Travis Griggs — Sat, 24 Mar 2007 18:37:38 +0000

So while this is really cool… what’s it good for Vassili? I’m asking a leading question here. :)

I think currying remains a term reserved to “computer theory geeks.” Doing 3 + 4 in a way that looks like (2 + 1) + (3 + 1) -> 7 is lost on the unwashed masses. It’s like telling people that Seaside is cool because it’s based on continuations, and leaving it at that. So how ’bout a “chapter 3″ showing a case where the how to use this for normal programming is illustrated by example?