Eiffel for Rubyists

After several months programming with Ruby scripting language, and related libraries, I got quite used to the intensive use of iterators and blocks (closures) that give Ruby programs a particular coding flavour. Switching back to Eiffel, I wondered how to reproduce this coding style in Eiffel programs: apart from discussing about this being an healthy practice or not, let's see some funny examples !

Simple iterators

One of the most frequently used iterators in Ruby is the each method in container classes like Array:

languages = Array.new(['Eiffel', 'Ruby', 'Python', 'C++', 'Perl', 'Java']) languages.each do |lang| puts "I like " + lang end

this fragment of code basically gives:

I like Eiffel I like Ruby I like Python I like C++ I like Perl I like Java

The same result can be achieved in Eiffel by means of the do_all iterator of ARRAY class; the basic step is to substitute Ruby blocks (the portion do |varbind| ... end) with Eiffel inline agents:

feature languages: ARRAY[STRING] is -- once Result := <<"Eiffel", "Ruby", "Python", "C++", "Perl", "Java" >> end test is -- do languages.do_all (agent (lang: STRING) do print("I like " + lang + "%N") end) end

Integer class iterators

Other common Ruby iterators can be found in the Integer class:

4.times do |t| puts "Hello, world!" end 1.upto(5) do |n| puts "going up: #{n}" end 10.downto(5) do |n| puts "going down: #{n}" end

The output of these three instructions is the following: Hello, world! Hello, world! Hello, world! Hello, world! going up: 1 going up: 2 going up: 3 going up: 4 going up: 5 going down: 10 going down: 9 going down: 8 going down: 7 going down: 6 going down: 5

In Eiffel, INTEGER class is not equipped with such iterators, one could think of an INTEGER_ITERATOR class that implements them or, alternatively, write the following features that make the first integer argument explicit:

feature times (n: INTEGER; action: PROCEDURE[ANY,TUPLE]) is -- repeat `action' for `n' times local l_times: INTEGER do from l_times := 0 until l_times = n loop action.call ([l_times]) l_times := l_times + 1 end end upto (min,max: INTEGER; action: PROCEDURE[ANY,TUPLE]) is -- require min_lt_max: min <= max local l_index: INTEGER do from l_index := min until l_index > max loop action.call([l_index]) l_index := l_index + 1 end end downto (max,min: INTEGER; action: PROCEDURE[ANY,TUPLE]) is -- require min_lt_max: min <= max local l_index: INTEGER do from l_index := max until l_index < min loop action.call([l_index]) l_index := l_index - 1 end end

Keeping in mind the Ruby example, these features should be called as follows:

times(4, agent (num: INTEGER) do print("time: " + num.out + "%N") end) upto(1,5, agent (num: INTEGER) do print("going up: " + num.out + "%N") end) downto(10,5, agent (num: INTEGER) do print("going down: " + num.out + "%N") end)

Reading a file the Ruby way

And now a more advanced example, in Ruby a text file can be read as follows:

File.open("myfile.rb", "r") do |infile| while (line = infile.gets) puts line end end

The open method in class File takes as argument a block operating on the file itself, it also takes care of closing the file after block execution, indeed a neat and compact style (but maybe not so explicit: should it be called open_do_something_and_close ?).

So, let's mimic this behaviour in Eiffel:

class RUBY_FILE feature open (name: STRING; action: PROCEDURE[ANY,TUPLE]) is -- local l_file: PLAIN_TEXT_FILE do create l_file.make_open_read (name) action.call ([l_file]) l_file.close end end

class RUBY_FILE exports the open feature as seen for the File class in Ruby, an usage example is the following:

feature test_ruby_file is -- local l_ruby_file: RUBY_FILE do create l_ruby_file l_ruby_file.open ("myfile.rb", agent (f: PLAIN_TEXT_FILE) do from f.start until f.after loop f.readline print (f.last_string + "%N") end end) end

have fun with Eiffel and Ruby !