Editing Smalltalk (section)

==Control structures==
Control structures do not have special syntax in Smalltalk. They are instead implemented as messages sent to objects. For example, conditional execution is implemented by sending the message ifTrue: to a Boolean object, passing as an argument the block of code to be executed if and only if the Boolean receiver is true. The two subclasses of Boolean both implement ifTrue:, where the implementation in subclass True always evaluates the block and the implementation in subclass False never evaluates the block.

The following code demonstrates this:
<syntaxhighlight lang="smalltalk">
result := a > b
    ifTrue:[ 'greater' ]
    ifFalse:[ 'less or equal' ]
</syntaxhighlight>
Blocks are also used to implement user-defined control structures, enumerators, visitors, [[exception handling]], pluggable behavior and many other patterns.
For example:
<syntaxhighlight lang="smalltalk">
| aString vowels |
aString := 'This is a string'.
vowels := aString select: [:aCharacter | aCharacter isVowel].
</syntaxhighlight>
In the last line, the string is sent the message select: with an argument that is a code block literal. The code block literal will be used as a predicate function that should answer true if and only if an element of the String should be included in the Collection of characters that satisfy the test represented by the code block that is the argument to the "select:" message.

A String object responds to the "select:" message by iterating through its members (by sending itself the message "do:"), evaluating the selection block ("aBlock") once with each character it contains as the argument. When evaluated (by being sent the message "value: each"), the selection block (referenced by the parameter "aBlock", and defined by the block literal "[:aCharacter | aCharacter isVowel]"), answers a Boolean, which is then sent "ifTrue:". If the Boolean is the object true, the character is added to a string to be returned.
Because the "select:" method is defined in the abstract class Collection, it can also be used like this:
<syntaxhighlight lang="smalltalk">
| rectangles aPoint collisions |
rectangles := OrderedCollection
  with: (Rectangle left: 0 right: 10 top: 100 bottom: 200)
  with: (Rectangle left: 10 right: 10 top: 110 bottom: 210).
aPoint := Point x: 20 y: 20.
collisions := rectangles select: [:aRect | aRect containsPoint: aPoint].
</syntaxhighlight>
The exception handling mechanism uses blocks as handlers (similar to CLOS-style exception handling):
<syntaxhighlight lang="smalltalk">
[
  some operation
] on:Error do:[:ex |
  handler-code
  ex return
]
</syntaxhighlight>
The exception handler's "ex" argument provides access to the state of the suspended operation (stack frame, line-number, receiver and arguments etc.) and is also used to control how the computation is to proceed (by sending one of "ex proceed", "ex reject", "ex restart" or "ex return").