Why Ruby?

[retard]

Sat, 18 Dec 2010 19:09:24 +0100, Jacob Carlborg wrote:

> As Nick writes here the Scala/C#-style syntax is one suggestion. There
> are also several other syntaxes available, one just have to look at
> other languages to get ideas. Here's a list of the syntax used by a
> couple of different language, some languages are list more than once
> because they support more than one syntax. I've listed the languages in
> order from, what I think, the least verbose to the most verbose
> lambda/delegate syntax (the number in front of the languages is the
> level of verbose, if two languages are at the same level I think they
> are equally verbose).
> 
> 1 D: foo(writeln(3)); // lazy argument

That's not really equivalent to lambdas. It would be unfair to not 
mention Scala which also supports lazy arguments.

> 1 Scala: foo(_ * _)

This isn't the same. _ * _ is equivalent to (a, b) => a * b

1 Scala: foo(x => x * x)

> 2 C#: foo(x => x * x);
> 3 Scala: foo((x) => x * x)

foo(x => x * x) also works in this case

> 4 Python: foo(lambda x: x * x)
> 5 Ruby: foo { |bar| x * x }

Maybe you meant

foo { |x| x * x }

> 5 Ruby: foo do |x| x * x end
> 6 D: foo((int x) { return x * x; });
> 7 C++1x: foo([](int x){ return x * x; });
> 7 Apple's (Objective)-C(++)
> block extension: foo(^(int x){ return x * x; });
> 8 JavaScript:
> foo(function(x){ return x * x })
> 9 PHP: foo(function ($x) use($fooBar) {
> return $x * $x; }); // "use" is used for explicitly telling what
> variables should be available when the scope is gone.
> 
> Note that I have not listed any functional languages here because I've
> never used one.

For example:

Lambda calculus: λx.x*x
Haskell: \x -> x * x

As you can see, most of the verbosity comes from the fact that lambdas in 
D and C++ contain statements, not a single expression. It's like if-then-
else vs ternary ?:  -- In languages like Scala these are the same built-in 
feature.