for i in [1, 2, 3]
# do something
end

or for a hash:

for (key, value) in {:one => 1, :two => 2}
# …
end

or:

{:one => 1, :two => 2}.each do |(key, value)|
# …
end

I think most ruby programmers will do this:

list = [�dog�, “cat�, “weasel�, “fish�, “canary�, “monkey�]
puts list.sort.map{|animal| “would you like to pet my #{animal}?�)

instead of:

list = [�dog�, “cat�, “weasel�, “fish�, “canary�, “monkey�]
list.sort.each do |animal|
puts “would you like to pet my #{animal}?�
end

Foo f=null;
try{
f= someDangerousCall();
} catch (SomeException e){
f= someThingElse;
}

in ruby you’d do:
f= dangerous_call() rescue something_else

The other nice thing is that, when you’re writing methods, the method block acts as an enclosing try/catch, so you would write:
def foo
bla bla bla
rescue
yuk yuk
end

where in java you’d write:
Foo foober( ) {
try {
bla bla bla
} catch(Excep e){
yuk yuk
}
return something
}

and since the ruby stile is to write many little methods, you almost never use the begin/end thing

Hope I didn’t scare you off with the…intensity…of my first response. I saw these lines:

> I’m fairly sure that there’s no such ability in the Ruby world.
> …the big enterprise stuff doesn’t exist yet in Rubyland:

and had to speak up. Guess they weren’t really ‘conclusions’ per say.

Good luck, as you’ve probably noticed, there’s quite a community out there to support (chastize? you in your ruby adventures.

Dan

The only conclusion that I’ve made about Ruby so far is this one:

So Ruby’s good. I’m into it. My first experience was good, which means that I’ll certainly have a second experience.

Zdennis,

Thanks for your interesting thoughts about list iteration. What I’m seeing is again reminiscent of one of the differences between Perl and Java: the size of the language. Java is actually a much smaller language than Perl is, precisely because it doesn’t have built-in support for things like iteration… all of Java’s cool features are in classes that exist outside of java.lang (like java.util’s collections, iterators, etc.) while Perl has all of this stuff baked into the language as builtin functions (keys, each, etc.). Notice again how I’m not drawing any conclusions about Ruby but rather am making a general comparision of the design of the language.

list = ["dog", "cat", "weasel", "fish", "canary", "monkey"]
list.sort.each do
|animal|
puts “would you like to pet my #{animal}?”
end

The only variable there is “animal”, there is no “i”, this makes it much easier to have nested looping constructs, and to copy and paste these loops around all over the place. If you have to use “i” in your loops, when you stick it into another loop, you have to remember to change that “i” to a “j”.

The bit between “do” and “end” is a block, and they’re also really useful for doing things like connecting to databases. Rather than knowing about “begin”, “rescue”, “ensure”, “end”, you can let that be handled inside the DB layer:

db.connect(foo, bar, baz) do
|handle|
handle.do_something()
end

If do_something() makes the database throw an exception, the db wrapper can clean it all up and you just get to “end” cleanly.

- jruby (like jython)
- ruby’s builtin concurrent programming libraries
- the ruby queue library (http://www.linuxjournal.com/article/7922)

For me, what ruby has over perl is the ease for OOP. I’m highly surprised that you didn’t mention that. The syntax is ‘cute’, as you say, but the ability to easily create/extend classes and the like really is more important IMHO.

Perhaps with a more in-depth analyis of ruby, the real advantages it has will emerge. ‘Ruby first impressions’ is a good title for your entry for that reason, just be wary of what conclusions you arrive at with only a ‘first impression’. You really do take your conclusions a little too far for so little experience.

for i in 0…@recurs.length
r = @recurs[i]
…
end

Now see the ruby way:

@recurs.each { |r| … }

or

@recurs.each do |r| … end

If you need multiline support you can do that:

@recurs.each { |r|
…
}

or

@recurs.each do |r|
…
end

It saves you typing and reduces two unnecessary lines to 1 line. I prefer the ruby way in this case.

Me, why is your approach to iteration the proper way? If you’re iterating through an array of integer values, I think my approach works fine. Am I missing something?