Smalltalk and Object Orientation: an Introduction - Free

11.9.3 The reject: message
The reject: aBlock message evaluates aBlock for each element in the receiving collection. The
result of this message is then a collection c ontaining the objects selected when aBlock evaluated to
false. For example:
(letters reject: [:each | each == $a] ) size
This will return a collection containing all the elements in letters which weren’t the lower case ‘a’
character. That is, this message returns all the elements in letters which fail the comparison test.
11.9.4 The collect: message
With the collect: aBlock message aBlock is again evaluated for each element in the receiving
collection. The resulting returned collection object is the same size as the receiving collection. The
returned collection contains the result of evaluating the block for each of the elements in the receiving
collection. For example:
(letters collect: [:each | each == $a] ) size
This will return a collection of the same size as letters, with either true or false in each element
depending on the outcome of the comparison.
11.9.5 The detect: message
In some cases we want to retrieve the first element in a collection which passes some test. The
detect: aBlock message does this for us. It evaluates aBlock for each element in the receiving
collection and answers with the first element where aBlock evaluates to true. For example:
letters detect: [:each | (each asUppercase == $A) |
(each asUppercase == $B)]
This can be extremely useful if you have a collection of records and you need the first one which
matches some test.
11.10 Inserting into a collection
The insert message is a very useful and very efficient operation. For example, if you have a collectio n
of numbers which you wish to total you would either need to iterate over the collection using a do loop
or convert the collection to an array and use an interval to mimic a Pascal style for loop.
In Smalltalk, however, this type of operation (i.e. where you want to initialize some values and then
perform the same thing on all elements in a collection) is so common that an extremely efficient
construct is provided. This construct is called the inject: mechanism. For example, assume you have
a bag of integers and real numbers which you want to sum. You can use inject: to do this, for
example:
| aBag result |
aBag := Bag new.
aBag add: 12; add: 24; add: 23.56; add: 7.
result := aBag inject: 0 into: [:sum :item | sum + item ].
This injects the initial value zero into sum and item. It then binds item to each of the elements of the bag
in turn. Each time it does so, it adds item to the current value in sum and saves the result into sum. This
is therefore equivalent to writing:
| sum aBag |
aBag := Bag new. sum := 0.
aBag add: 12; add: 24; add: 23.56; add: 7.
aBag do: [:item | sum := sum + item].
result := sum.
101