Smalltalk and Object Orientation: an Introduction - Free

Blocks are represented by square brackets ‘[ ]’ and obviously have a very different meaning to round
brackets ‘( )’. This can be yet another point of confusion for those new to Smalltalk. The round brackets
will return the result of evaluating what they contain, at the point at which the expression is
encountered. The square brackets will return a block object. This block object will contain zero or more
statements. These statements will only be executed when the block is evaluated. This is achieved by
sending the message value to the block. For example:
[counter := counter + 1] value.
However, if we don’t want to execute the statements in this block until later, we don’t have to. In
fact as the block is actually an object, we can assign the block to a variable. Then when we are ready we
can evaluate the block held by the variable. For example:
myBlock := [counter := counter + 1].
....
myBlock value.
Thus when a block expression is encountered, the statements enclosed are
not executed
immediately. In other words, the contents of the square brackets are stored until a value message is sent
to it. Thus in the above example, counter will only be incremented when the message value is sent to
myBlock.
It is important to note that the block will execute within the context in which it was defined and not
necessarily in the c urrent context. This means that the value used for counter will be the value it had
wherever the block was created.
As was explained in Chapter 6 all expressions return a value. In the case of a block, when it is
evaluated, the result returned is the resul t of evaluating the last expression in the block. Thus the value
18 is assigned to the variable result in the following example:
9.3.2 Block parameters
result := [2 * 4. 3 * 6].
Blocks can also take parameters. This is done by pre ceding the statements in the block by a vertical bar
and the input parameter. This parameter has a preceding colon. For example:
[:counter | counter * 2.]
This block takes one input parameter and possesses a single statement which multiples the input
value by 2. This can then be evaluated with a single parameter. This is achieved by sending the block
the keyword message value: ; the argument is the value to bind to the block parameter counter.
For example:
[:counter | counter * 2] value:10.
This would produce the value 20. It is possible to pass in more than one parameter to a block. For
example, if we want to specify that a block takes two parameters, then we could use the following
definition:
[:x :y | x * y ]
This block would be evaluated using the value:value: message.
[:x :y | x + y] value: 10 value: 20.
The same number of arguments must appear in the block and the message. In fact there are also
value:value:value: and value:value:value:value: messages for blocks which take
three and four arguments. There is also a valueWithArguments: message for blocks taking more
than four arguments.
82