Ruby Made Simple: Blocks Plus Iterators

BlocksBlocks++

IteratorsIterators

Blocks + IteratorsBlocks + Iterators

RUBY MADE SIMPLEAugust 08 2013John R Schmidt

2


RUBY MADE SIMPLE

Traditional Loops

10 FOR N=1 TO 1020 PRINT "WE LOVE RUBY"30 RETURN

for ( int i=0; i<10; i++) { System.out.println("We love Ruby");}

200 J=0210 J=J+1220 S$=T$[J]230 IF S$="END" GOTO 300240 PRINT S$+" LOVES RUBY"250 GOTO 210

j = 0;name = rubyists[0];while (!name.equals( "empty") ) { message = name + " loves Ruby" System.out.println(message); name = rubyists[j]; j++;}

August 08 2013John R Schmidt

3

Similar structures exist in Ruby ...

for n in (1..10) do puts "We love Ruby"end



j = 0name = rubyists[0]while name != "empty" do puts "#{name} loves Ruby" j += 1 name = rubyists[j];end (also: until)

4

Similar structures exist in Ruby ...

… but Ruby has something even better ...

for n in (1..10) do puts "We love Ruby"end



j = 0name = rubyists[0]while name != "empty" do puts "#{name} loves Ruby" j += 1 name = rubyists[j];end (also: until)

5

It looks like this:

1.upto(10) { puts "We love Ruby" }

rubyists.each { |name| puts "#{name} loves Ruby" }



6

It looks like this:





What is it ?

7





This is the block

8





These are the iterators

9


rubyists.each do |person| full_name = person.name first = full_name.get_first_name first = first.downcase first[0] = first[0].upcase puts "#{first} loves Ruby"end



A block is a sequence of one or more executable Ruby statements.

10




The convention is to enclose one-line blocks in curly brackets.

{ }

11

rubyists.each do |name| full_name = person.name first = full_name.get_first_name first = first.downcase first[0] = first[0].upcase puts "#{first} loves Ruby"end



And enclose multi-line blocks with the do and end keywords.

12

10.times { puts "We love Ruby" }



The iterators are instance methods that operate on the object they belong to.

[1,2,3,4].map { |x| x**3 - x**2 }


1.upto(15) { |n| puts "Programmer number #{n} loves Ruby" }

13




So the syntax is the same as any other method call.

[1,2,3,4].map { |x| x**3 - x**2 }



14




Except that the method call is followed by the block.

[1,2,3,4].map { |x| x**3 - x**2 }



15

1.upto(5) { |x| puts x**2 }

accounts.each do |account| account[:date_updated] = today account[:status] = :past_due if account[:balance] < 0.0 todays_batch << accountend



Parameters supplied to the block are put at the beginning of the block inside "pipe" characters (vertical lines).

|var|

16

1.upto(5) { |x| puts x**2 }

accounts.each do |account| account[:date_updated] = today account[:status] = :past_due if account[:balance] < 0.0 todays_batch << accountend



Parameters supplied to the block are put at the beginning of the block inside "pipe" characters (vertical lines).

17

1.upto(5) { |x| puts x**2 }

1491625



The block executes once for each value returned by the iterator method, using that value as the value for the parameter.

18




1.upto(10) { |n| puts @comments[n] }

max.downto(5) { |y| draw_box(xx,y) }

0.step (10.0,0.2) { |x| delta = base + x**3 }

Objects that have iterators are most commonly either numbers . . .

19



history.each { |point| plot(point) }

last_job.each_pair { |k,v| log_item[k] = v }

list.find { |task| task[:status] == :pending }

[1,2,3,4,5,6,7,8,9,10].find_all { |z| z%3 == 0 }

Objects that have iterators are most commonly either numbers . . .

or collections.

20






Numbers with iterator methods are usually integers.

df.step (10.0,0.2) { |x| delta = base + x**3 }

The step method can also be called on a real number object (Float class).

21



Collection objects using iterators are usually arrays or hashes.




[1,2,3,4,5,6,7,8,9,10].find_all { |z| z%3 == 0 }

columns.map { |c| dot_product(c,row) }

22



Collection objects using iterators are usually arrays or hashes.




[1,2,3,4,5,6,7,8,9,10].find_all { |z| z%3 == 0 }


NOTE : There is no predefined class or module named Collection. "Collection" is merely a term used to describe objects that contain a group of items. Usually these are arrays or hashes, but also include specialized classes such as Set or Range.

23



timestimes 10.times { puts "We love Ruby" }

uptoupto 1.upto(10) { |n| puts @comments[n] }

downtodownto max.downto(5) { |y| draw_box(xx,y) }

stepstep df.step (10.0,0.2) { |x| delta = base_value + x**3 }

Common iterator methods for numbers

24



eacheach history.each { |point| draw_point(point) }

each_paireach_pair last_job.each_pair { |k,v| log_entry[k] = v }

findfind list.find { |task| task[:status] == :pending }

find_allfind_all [1,2,3,4,5,6,7,8,9,10].find_all { |z| z%3 == 0 }

Common iterator methods for collections

25



countcount history.each { |point| plot(point) }

mapmap columns.map { |c| dot_product(c,row) }

map!map! coordinates.map! { |c| standard_format(c) }

Common iterator methods for collections

26



times

upto

downto

step

count

map

map!

What do these do ?

each

each_pair

find

find_all

27



times


Iterates block int times, passing in values from zero to int - 1.

times { block }

Ruby 2.0 API :

● Method called upon an integer object.

● Executes the statements in the block as many times as the value of the integer.

● Values passed to the block as a parameter iterate from zero to the value of the integer object minus 1.

28



upto


Iterates block, passing in integer values from int up to and including limit.

upto(limit) {|int| block }

Ruby 2.0 API :

● Method called upon an integer object, with another integer as the method's parameter.

● Iterates from the value of the integer object to the value of the method's parameter, incrementing by 1 for each iteration.

● Executes the block with each iteration and passes the value of the iteration to the block parameter.

29



downto


Iterates block, passing decreasing values from int down to and including limit.

downto(limit) {|int| block }

Ruby 2.0 API :

● Method called upon an integer object, with another integer as the method's parameter.

● Iterates downward from the value of the integer object to the value of the method's parameter, decrementing by 1 for each iteration.

● Executes the block with each iteration and passes the value of the iteration to the block parameter.

30



step

10.step (100,5) { |n| sigma += t/n }

df.step (10.0,0.2) { |x| delta = base_value + x**3 }

Invokes block with the sequence of numbers starting at num, incremented by step on each call.

step(limit, step) {|int| block }

Ruby 2.0 API :

● Method called upon a numeric object, with two numeric parameters.

● Iterations begin at the value of the object and are incremented by the value of the second parameter, which can be positive or negative.

● Iterations end at the maximum value less than or equal to the first parameter (or the minimum for negative iterations).

31



each

history.each { |point| draw_point(point) }

Calls the given block once for each element in self, passing that element as a parameter.

each { |item| block }

Ruby 2.0 API :

● Method called upon an array, a hash, or other "collection" object.

● Iterates once for each item in the collection, passing that item as the parameter.

● Iterates through a hash in the order the pairs were added in Ruby 1.9 and 2.0. Order is not guaranteed in Ruby 1.8 and older.

32



each_pair


Calls block once for each key in hash, passing the key-value pair as parameters.

each {| key, value | block }

Ruby 2.0 API :

● Method called upon a hash object.

● Iterates once for each key-value pair in the hash, passing each key and its corresponding value as the parameters.

● The block's parameter declaration should have two parameters, one for key and one for value.

33



find


Returns the first entry for which block is not false.

find { |obj| block }

Ruby 2.0 API :

● Method called upon a collection object.

● Returns the first object it finds for which the block returns true.

34



find_all

[1,2,3,4,5,6,7,8,9,10].find_all { |z| z%3 == 0 }

Returns an array containing all elements for which the given block returns true.

find_all { |obj| block }

Ruby 2.0 API :


● Returns an array containing all items in the collection for which the block returns true.

( ALIAS: select )

35



count

failures = attempts.count { |z| z[:status] == :fail }

Counts the number of elements for which the block returns true.

count { |item| block }

Ruby 2.0 API :


● Returns an integer representing the number of objects in the collection for which the block returns true.

36



map


Creates a new array containing the values returned by the block.

map { |item| block }

Ruby 2.0 API :


● Iterates once for each item in the collection, passing that item as the parameter.

● Returns an array with the same number of elements as the collection, using each member of the collection as the parameter supplied to the block.

37



map!

coordinates.map! { |c| standard_format(c) }

Replaces each element with the value returned by the block.

map! {|item| block }

Ruby 2.0 API :

● The "destructive version" of the map method. Available to arrays only.

● Same as the map method, except that the values of the original array are changed to the new values determined by the statements in the block.

38



Beyond MADE SIMPLE

● detect, select, reject, collect, inject, inspect

● inject/ reduce

● cycle

● Internal iterators/ external iterators

● Define or overwrite your own iterator

● Mix in Enumerable

39



Beyond MADE SIMPLE


Rhyming alias names for find, find_all, opposite of find_all, map, reduce and to_s

● inject/ reduce

● cycle




40



Beyond MADE SIMPLE


● inject/ reduce

"Inject" a function (+,-,*, …) or method into a collection to "reduce" it to a single value.

● cycle




41



Beyond MADE SIMPLE


● inject/ reduce

● cycle

Executes the block repeatedly until stopped by something else, such as end of input, an exception or error, or turning off the machine.




42



Beyond MADE SIMPLE


● inject/ reduce

● cycle


Methods that iterate over their own objects are called "internal iterators". A separate object that iterates over other objects is called an "external iterator". You can define external iterators in Ruby, if you wish.



43



Beyond MADE SIMPLE


● inject/ reduce

● cycle



Write a custom each or other iterator method for your classes.


44



Beyond MADE SIMPLE


● inject/ reduce

● cycle




Declare your class with the Enumerable mix-in, define an each method, and you get other methods such as map, find and include? for free. Define a comparator <=> and you also get min, max, sort, etc.

45




Ruby Made Simple: Blocks Plus Iterators

Technology