Peter's Gekko

(See link Blocks and Iterators)
You have same staff in Ruby:

"Blocks and Iterators

This section briefly describes one of Ruby's particular strengths. We're about to look at code blocks: chunks of code that you can associate with method invocations, almost as if they were parameters. This is an incredibly powerful feature. You can use code blocks to implement callbacks (but they're simpler than Java's anonymous inner classes), to pass around chunks of code (but they're more flexible than C's function pointers), and to implement iterators.

Code blocks are just chunks of code between braces or do...end.

{ puts "Hello" } # this is a block

do #
club.enroll(person) # and so is this
person.socialize #
end #




Once you've created a block, you can associate it with a call to a method. That method can then invoke the block one or more times using the Ruby yield statement. The following example shows this in action. We define a method that calls yield twice. We then call it, putting a block on the same line, after the call (and after any arguments to the method).[Some people like to think of the association of a block with a method as a kind of parameter passing. This works on one level, but it isn't really the whole story. You might be better off thinking of the block and the method as coroutines, which transfer control back and forth between themselves.]

def callBlock
yield
yield
end

callBlock { puts "In the block" }


produces: In the block
In the block




See how the code in the block (puts "In the block") is executed twice, once for each call to yield.

You can provide parameters to the call to yield: these will be passed to the block. Within the block, you list the names of the arguments to receive these parameters between vertical bars (``|'').

def callBlock
yield ,
end

callBlock { |, | ... }




Code blocks are used throughout the Ruby library to implement iterators: methods that return successive elements from some kind of collection, such as an array.

a = %w( ant bee cat dog elk ) # create an array
a.each { |animal| puts animal } # iterate over the contents


produces: ant
bee
cat
dog
elk




Let's look at how we might implement the Array class's each iterator that we used in the previous example. The each iterator loops through every element in the array, calling yield for each one. In pseudo code, this might look like:

# within class Array...
def each
for each element
yield(element)
end
end




You could then iterate over an array's elements by calling its each method and supplying a block. This block would be called for each element in turn.

[ 'cat', 'dog', 'horse' ].each do |animal|
print animal, " -- "
end


produces: cat -- dog -- horse --




Similarly, many looping constructs that are built into languages such as C and Java are simply method calls in Ruby, with the methods invoking the associated block zero or more times.

5.times { print "*" }
3.upto(6) {|i| print i }
('a'..'e').each {|char| print char }


produces: *****3456abcde




Here we ask the number 5 to call a block five times, then ask the number 3 to call a block, passing in successive values until it reaches 6. Finally, the range of characters from ``a'' to ``e'' invokes a block using the method each. "