Why Ruby?

[Stephan Soller]

>>
>> I think it's a matter of consistency. In Ruby blocks are used all the
>> time for pretty much everything. In D this isn't the case because
>> usually templates are used for stuff where blocks are used in Ruby (e.g.
>> map, group and find in std.algorithm).
>
> I think that the templates that take a string as a predicate is just an
> ugly hack because D has a too verbose delegate syntax.
>

I absolutely agree with that. However I don't have a better idea how to 
write it. Delegate syntax is already fairly compact in D.

For example code as this isn't very uncommon in Ruby:

	[1, 2, 3, 4, 5].select{|e| e > 3}.collect{|e| e*e}

Of course this is a simplified example. Usually the collection would 
contain some objects and the blocks would filter for a method call (like 
"e.even?"). However I built a small D1 struct that implements a select 
and collect function. With the unified function call synatax for array 
with code should actually work:

	[1, 2, 3, 4, 5].select((int e){ return e > 3; })
		.collect((int e){ return e*e; });

It's already fairly compact. The main overhead is the parameter type and 
the return statement. I don't believe this can be reduced any more 
without breaking consistency of the language.

Delegates are way more verbose in other languages like PHP and 
JavaScript (more or less the same syntax in both languages). Despite 
that it's no problem to use it and in case of jQuery it's used very 
often. I think the main reason why delegates are not used like that in D 
is performance. I'm really not sure about it but I suspect that 
delegates are less effective than code directly generated by a template 
like map!(). I don't know how efficient templates can integrate 
delegates so I just suspect that this is a performance problem.

Happy programming
Stephan Soller