HOM

HOM (short for High Order Messaging) is a mechanism for encapsulating control structures and other programming patterns. It is similar to blocks in Smalltalk and higher order functions in functional languages.

Objective-C does not have blocks. They're not a part of the language, although Brad Cox's TaskMaster Paper outlines them nicely (and the Portable Object Compiler implements them).

However, it is possible to implement HOM (using trampolines), but HOM is not a language feature at this point.

What does HOM look like?

Suppose you have an NSArray containing objects you want to call a message on. Normally you would have to do something like

 [anArray makeObjectsPerformSelector: @selector(someOtherMessage)];

With HOM you simply write

 [[anArray do] someOtherMessage];

instead.

Simply put: the -do message tells the array to call -someOtherMessage on each of its objects.

HOM related messages

To further explain how HOM works, here's a list of usual methods including a simple example.

We start by assuming there's an array

 NSArray *array;
 
 array = [@"one two three four five six seven eight nine ten" componentsSeparatedByString: @" "];

Now let's see how to use HOM methods on that array and what the results will be:

• -select

Returns members of the array if they respond YES to the argument message -- which necessarily returns a BOOL.

 NSArray *array2 = [[array select] hasPrefix: @"t"];
 NSLog([array2 description]);

This will give us all numbers starting with a t

 (two, three, ten)

• -reject

The inverse of -select; it returns the elements responding NO.

 NSArray *array3 = [[array2 reject] hasSuffix: @"e"];
 NSLog([array3 description]);

will return all numbers in array2 that do not end with an e

 (two, ten)

• -collect

Executes the argument message and returns an array of the responses to the argument message.

 NSArray *array4 = [[array3 collect] stringByAppendingString: @" books"];
 NSLog([array4 description]);

will add books to all objects in array3

 ("two books", "ten books")

• -do

Executes the argument message.

 NSArray *array5 = [[array collect] mutableCopy];
 [[array5 do] appendString: @" eggplants"];
 NSLog([array5 description]);

will create a mutable copy of array and append eggplants to each object.

 (
   "one eggplants",
   "two eggplants",
   "three eggplants",
   "four eggplants",
   "five eggplants",
   "six eggplants",
   "seven eggplants",
   "eight eggplants",
   "nine eggplants",
   "ten eggplants"
 )

As you can see, -do is quite similar to -collect but works on the objects inside the collection (here array5 -- the mutable copy of array) instead of returning a new array (as -collect does).

• -each

Returns each object, similar to -objectEnumerator.

 NSArray *string = [[@"I like to eat " collect]  stringByAppendingString: [array5 each]];

This is a stupid example (because I do not like eggplants) that would give us

 (
   "I like to eat one eggplants",
   "I like to eat two eggplants",
   "I like to eat three eggplants",
   "I like to eat four eggplants",
   "I like to eat five eggplants",
   "I like to eat six eggplants",
   "I like to eat seven eggplants",
   "I like to eat eight eggplants",
   "I like to eat nine eggplants",
   "I like to eat ten eggplants"
 )

• -performAfterDelay:

Performs the argument message after a specified delay.

 [[someArray performAfterDelay: 5] delayedMessage];

• -ignoreExceptions

Traps and ignores any exception that may occur during execution of the argument message.

 [[someArray ignoreExceptions] messageThatMayRaiseAnException];

• -ifResponds

Sends the argument message only if the receiver reponds to it. Instead of writing

 if( [receiver respondsToSelector: @selector(foobar)] ) [receiver foobar]

you simply use

 [[receiver ifResponds] foobar].