HOM

From GNUstepWiki

(Difference between revisions)
Revision as of 09:19, 21 September 2005
Cbv (Talk | contribs)
Added links to Brad Cox and his TaskMaster Paper
← Previous diff
Current revision
Newacct (Talk | contribs)

Line 1: Line 1:
-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.+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 [http://virtualschool.edu/cox/ Brad Cox]'s [http://virtualschool.edu/cox/pub/TaskMaster/index.html TaskMaster Paper] outlines them nicely (and the 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 9: Line 9:
== What does HOM look like? == == 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+Suppose you have an [[NSArray]] containing objects you want to call a message on. Normally you would have to do something like
- [myArray makeObjectsPerformSelector: @selector(someOtherMessage)];+ [anArray makeObjectsPerformSelector: @selector(someOtherMessage)];
With HOM you simply write With HOM you simply write
- [[myArray do] someOtherMessage];+ [[anArray do] someOtherMessage];
instead. instead.
-Simply put: the ''-do'' message tells myArray to call ''-doSomething'' on each of its objects.+Simply put: the ''-do'' message tells the array to call ''-someOtherMessage'' on each of its objects.
Line 29: Line 29:
We start by assuming there's an array We start by assuming there's an array
- NSString *dummy; 
NSArray *array; NSArray *array;
- dummy = @"one two three four five six seven eight nine ten";+ array = [@"one two three four five six seven eight nine ten" componentsSeparatedByString: @" "];
- array = [dummy componentsSeparatedByString: @" "];+
Now let's see how to use HOM methods on that array and what the results will be: Now let's see how to use HOM methods on that array and what the results will be:
-* -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.
NSArray *array2 = [[array select] hasPrefix: @"t"]; NSArray *array2 = [[array select] hasPrefix: @"t"];
- NSLog([array2 description]);+ NSLog(@"%@", array2);
This will give us all numbers starting with a ''t'' This will give us all numbers starting with a ''t''
Line 49: Line 47:
-* -reject+* ''-reject''
The inverse of ''-select''; it returns the elements responding NO. The inverse of ''-select''; it returns the elements responding NO.
NSArray *array3 = [[array2 reject] hasSuffix: @"e"]; NSArray *array3 = [[array2 reject] hasSuffix: @"e"];
- NSLog([array3 description]);+ NSLog(@"%@", array3);
will return all numbers in ''array2'' that do '''not''' end with an ''e'' will return all numbers in ''array2'' that do '''not''' end with an ''e''
Line 60: Line 58:
-* -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);
-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 76: Line 74:
NSArray *array5 = [[array collect] mutableCopy]; NSArray *array5 = [[array collect] mutableCopy];
[[array5 do] appendString: @" eggplants"]; [[array5 do] appendString: @" eggplants"];
- NSLog([array5 description]);+ NSLog(@"%@", array5);
will create a mutable copy of ''array'' and append ''eggplants'' to each object. will create a mutable copy of ''array'' and append ''eggplants'' to each object.
Line 127: Line 125:
[[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:Snippets]]

Current revision

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);

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);

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);

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);

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].