0 to(4) foreach(i, writeln("This is loop " .. i))

Arrogant, can you explain the strange dots in that expression to the readers at home?

I don’t get Arrogant’s point. This blog is obviously about Ruby, so why would you complain about praise for this particular language in place like this? Also: Stating that Ruby is beautiful is non-exclusive. Io may as well be very easy to comprehend. Subjective opinion: I think the Ruby bit is easier on the eyes (less parens). Whatever suits you best.

Arrogant: Fanboyism? Is that something like hijacking a ruby thread to promote your own favorite language? otaku taku? :)

Also, where is your implementation of the Number#to method?

ExceptionId: Io.Object.doesNotRespond
Description: Number does not respond to message 'to'

You know that…

0.upto(4) { |i| print("Ruby is ", i, " times neater\n") }

:P (all in good humor)

Manfred: In Io ’..’ is the concatination operator.

Hmm, maybe Arrogant needed to pick a better example.

Reading both I think the Ruby version is a little more direct—“do X five times” versus IO’s “for each integer in the range 0 through 4 (inclusive) do X”. I mean yeah?

Granted, in the Ruby version it’s slightly less obvious where i is coming from, except that the context of its use makes it a bit clearer.

I was writing that response to the interview at 2am in the morning, and that was the only thing I could think of at the moment. Blushes on the not too good English.

I have yet to penetrate the deep mystery that is Hoodwink.d :-) When I get time I’d like to explore Io, it’s get-new-object-by-cloning is a style I’ve never used, so it would be interesting to experience that. It will have been chosen for a reason I don’t yet appreciate.

0 to(4) foreach(i, writeln(“This is loop ” .. i))

rofl

Granted, in the Ruby version it’s slightly less obvious where i is coming from, except that the context of its use makes it a bit clearer.

Fortunately, my proposal solves this problem.

5.times do HEY RUBY PLEASE GET ME MY VARIABLE i AND USE IT IN THIS BLOCK/CLOSURE THING
  puts "DAMN, IT'S #{i}" 
end

I expect this to be parsed forthwith.

Arrogant’s code is nasty, give me Ruby any day.

The double pipes take some time to get used to, but I really see no other nice syntactical way to declare how variables are to be passed into the block.

5.times do i

for(0..4) -> $i {
  say "This is loop $i" 
}

I like the fieldgoals, personally. They syntactically distinguish block arguments from method arguments, and (to me at least) appear to be passive, thus recieving the arguments, whereas the arrow looks to me to be active, like it’s injecting something into the mix. But the arrow thing is mainly a learned/cultural convention…there could be some culture somewhere or in theory that sees the “pointy” end of the arrow as a collector and the “stem” end as doing the pointing so that it would mean to them the exact reverse of what I percieve it to mean. I still like the fieldgoals, though.

BTW , Sausheong, your English was fine. Keep up the good work or promoting ruby. :)

*or promoting = of promoting

I agree Ruby is very readable.

5.times { |i| puts “This is loop #{i}” }

...and then one could ask, whats the { } for? :)

but I degress…I think has the cleanest syntax of the languages I currently use and it is a pleasure to work with.

-happy coding

I also hate Ruby’s #{} and =>, and :var rather than var, but other than that I like Ruby!

Well, sometimes it’s just enough to ask “Can your programming language do this?” ( http://www.joelonsoftware.com/items/2006/08/01.html ) !

Joe Ruby: You don’t have to use the string interpolation syntax; you could use the format syntax:

a, b  = 'string', 2
s1, s2 = 'This is a %s', 'A %s and a %d'
#these all do the same thing
#literal
p(s1 % a) 
p(s2 % [a, b])
#format
p(format(s1, a))
p(format(s2, a, b))
#sprintf (see also printf)
p(sprintf(s1, a))
p(sprintf(s2, a, b))

The => can be replaced by commas when using the literal or square-bracket constructor:

h = {"a", 100, "b", 200}
h = Hash["a", 100, "b", 200]

And the :symbol notation can be avoided by using only strings:

m = method('puts') # means the same as:
m = method(:puts)
#The string will get converted to a symbol
#internally if necessary (this isn't always
#true--e.g., hashes indexed by symbols--but 
#there is always "string".to_sym)

The || goalposts is all you’re really stuck with.

Hmm. In thinking about format and sprintf...wouldn’t the Ruby Way™ be to add those methods to String...something like:

class String
    def format(*args); Kernel.format(self, *args); end
    alias_method(:sprintf, :format)
  end

Then you’d do:

'I like %s'.format('ruby')

And that also makes me wonder about top-level print functions from Kernel also…shouldn’t it be:

'Fire on the mount'n, run boys, run'.puts

Kind of strange since I’m used to top-level print functions…but what say ye, oh austere rubyists of the red hand?

"I like %s".%('ruby')
"Fire on the mount'n, run boys, run".display(STDOUT)
STDOUT.print("Fire on the mount'n, run boys, run")

I was suggesting that format and sprintf act like the “literal” with modulo. ;) I figured that p, puts and print could be added to Object and format, sprintf and printf could be added to String. It works. I wasn’t aware of Object#display! Learn somthin’ new every day.