HOM

From GNUstepWiki

(Difference between revisions)
Revision as of 09:54, 21 June 2006
Cbv (Talk | contribs)
Added a link to POC
← Previous diff
Revision as of 10:49, 28 June 2006
Cbv (Talk | contribs)
Link to Trampoline, added -ifResponds and some beautifications
Next diff →
Line 3: Line 3:
Objective-C does not have blocks. They're not a part of the language, although [http://virtualschool.edu/cox/ Brad Cox]'s [http://virtualschool.edu/cox/pub/TaskMaster/index.html TaskMaster Paper] outlines them nicely (and the [http://users.pandora.be/stes/compiler.html Portable Object Compiler] implements them). Objective-C does not have blocks. They're not a part of the language, although [http://virtualschool.edu/cox/ Brad Cox]'s [http://virtualschool.edu/cox/pub/TaskMaster/index.html TaskMaster Paper] outlines them nicely (and the [http://users.pandora.be/stes/compiler.html Portable Object Compiler] implements them).
-However, it is possible to implement HOM (using trampolines), but HOM is not a language feature at this point.+However, it is possible to implement HOM (using [[trampoline|trampolines]]), but HOM is not a language feature at this point.
Line 20: Line 20:
Simply put: the ''-do'' message tells myArray to call ''-someOtherMessage'' on each of its objects. Simply put: the ''-do'' message tells myArray to call ''-someOtherMessage'' on each of its objects.
 +
 +
== HOM related messages == == HOM related messages ==
Line 36: Line 38:
-* -select+* ''-select''
Returns members of the array if they respond YES to the argument message -- which necessarily returns a BOOL. Returns members of the array if they respond YES to the argument message -- which necessarily returns a BOOL.
Line 47: Line 49:
-* -reject+* ''-reject''
The inverse of ''-select''; it returns the elements responding NO. The inverse of ''-select''; it returns the elements responding NO.
Line 58: Line 60:
-* -collect+* ''-collect''
Executes the argument message and returns an array of the responses to the argument message. Executes the argument message and returns an array of the responses to the argument message.
- NSArray *array4 = [[array3 collect] stringByAppendingString: @" book"];+ NSArray *array4 = [[array3 collect] stringByAppendingString: @" books"];
NSLog([array4 description]); NSLog([array4 description]);
-will add ''book'' to all objects in ''array3''+will add ''books'' to all objects in ''array3''
- ("two book", "ten book")+ ("two books", "ten books")
Line 125: Line 127:
[[someArray ignoreExceptions] messageThatMayRaiseAnException]; [[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].
 +
[[Category:Objective-C]] [[Category:Objective-C]]
[[Category:Snippets]] [[Category:Snippets]]

Revision as of 10:49, 28 June 2006

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 myArray containing objects you want to call a message on. Normally you would have to do something like

 [myArray makeObjectsPerformSelector: @selector(someOtherMessage)];

With HOM you simply write

 [[myArray do] someOtherMessage];

instead.

Simply put: the -do message tells myArray 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

 NSString *dummy;
 NSArray *array;
 
 dummy = @"one two three four five six seven eight nine ten";
 array = [dummy 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].