Soon after I started learning Smalltalk, I found my brain broken. Smalltalk doesn’t have control structures. No ifs, no whiles, no for loops. All these structures are instead patterns of message

passing [1].

Conditionals in Smalltalk work like this: the class Boolean has two subclasses, True and False. Each has a well-known instance, true and false, respectively [2].

The equivalent of C’s

if (condition) { one_func(); } else { other_func(); }

is

condition ifTrue: [ self oneMethod ] ifFalse: [ self anotherMethod ]

How does it work? Boolean defines a method #ifTrue:ifFalse: taking two blocks as parameters. (Remember, what Smalltalkers call a block other folks call a closure. A Lisper might call the parameterless blocks that #ifTrue:ifFalse: takes thunks.) True and False in turn implement #ifTrue:ifFalse: thusly:

True>>ifTrue: trueBlock ifFalse: falseBlock ^ trueBlock value. False>>ifTrue: trueBlock ifFalse: falseBlock ^ falseBlock value.

So we evaluate condition to either true or false, send it the #ifTrue:ifFalse: message, and we’re done.

After reading Peter Seibel’s Practical Common Lisp I had the mistaken impression that IF was a necessary special form, and I couldn’t understand why that would be the case, when Smalltalk manages to avoid the issue.

I grabbed Wikipedia (font of all true information, of course) and looked at the lambda calculus. You can implement conditionals like this, in the untyped lambda calculus:

TRUE = Î»xy. x FALSE = Î»xy. y IFTHENELSE = Î»cxy. c x y

Hang on, that looks a bit familiar! True is a function that takes two thunks and returns the value of the first, and False one that returns the second? And a conditional’s a function taking a condition and two thunks?

And lo and behold, I recently finally finished reading – after three attempts, I’m ashamed to admit – William Cook’s rather excellent On Understanding Data Abstraction, Revisited, and there in section 5.4 Cook says just that – “The implementation of Booleans and conditionals [in Smalltalk] is exactly the same as for Church booleans in the lambda-calculus.”

So then I went back to Common Lisp, boggling anew. And then I realised what I’d missed. PCL says “Because all the arguments to a function are evaluated before the function is called, there’s no way to write a function that behaves like the IF operator you used in Chapter 3.” But the way to avoid evaluation of an argument is to wrap it up in a thunk. And then I realised what I had missed: In Smalltalk, true and

false are functions, but in Common Lisp they’re just values, not functions [3]. So when you turn true and false into values, you then have to make your conditional special. It, too, needs to be early bound.

[1] Semblance to Hewitt’s paper Viewing Control Structures as Patterns of Passing Messages entirely deliberate.

[2] That uses two of Smalltalk’s 5 reserved words, but I see no reason why true and false couldn’t simply be in the Smalltalk dictionary (as opposed to being used by the VM as a(n important) optimisation). If I’m talking nonsense, and you simply have to have these as reserved words, feel free to correct me!

[3] I’m not knocking Common Lisp here! You prematurely bind T and NIL for efficiency. Smalltalk does the same: #ifTrue:ifFalse: and friends are all inlined.