Why Ruby?

[Lutger Blijdestijn]

Andrei Alexandrescu wrote:

> On 12/12/10 6:44 AM, Jacob Carlborg wrote:
> [snip]
>> Conclusion:
>>
>> D needs a better and nicer looking syntax for passing delegates to
>> functions.
>>
>> Suggestion:
>>
>> If a function takes a delegate as its last parameter allow the delegate
>> literal to be passed outside the parameter list, after the function
>> call, and allow to drop the semicolon. Also allow type inference of the
>> delegate parameters. Looking like this:
>>
>> foo(bar) {
>> // do something with bar
>> }
>>
>> If the function takes other arguments before the delegate I have two
>> suggestions, either just have two parameter lists, each in its own pair
>> of parentheses:
>>
>> foo(3, 'a')(bar) {
>> // do something with bar
>> }
>>
>> Or have two parameter lists in one pair of parentheses seperated by a
>> semicolon:
>>
>> foo(3, 'a' ; bar) {
>> // do something with bar
>> }
>>
>> I think that the syntax I've used in these examples has previously been
>> proposed.
> 
> Yah, it's been discussed a couple of times in the past. Both Walter and
> myself are favorable to finding a good, simple lowering that improves
> syntax without adding burden to the person who learns the language.
> 
> By the way, lowerings are great. Defining features as lowerings is a
> huge win in language definition, ease of understanding, and correctness
> of implementation. Features that have been implemented through lowering
> have had very few bugs - e.g. scope() and the new operator overloading,
> which was only a week's work.
> 
> Getting back to finding a good lowering, consider:
> 
> foreach (a, b ; c) stmt
> 
> A Ruby syntactic equivalent that clarifies what belongs to the block and
> what belongs to the invoker of the block is:
> 
> c.each do |a, b|
>    stmt
> end
> 
> So a and b are passed to the block and each is a method of c (or more
> general, each is a function called taking c as an argument). Going now
> back to D, we can imagine the following lowering:
> 
> fun (a, b ; c) stmt
> 
> =>
> 
> fun(c, (a, b) { stmt })
> 
> This could and should be generalized for more parameters, which I'm sure
> is very useful:
> 
> fun (a, b ; c, d) stmt
> 
> =>
> 
> fun(c, d, (a, b) { stmt })
> 
> Of course "fun" could be actually "obj.method".
> 
> With this we have a compelling syntax that has semantics obtained via
> lowering.
> 
> 
> Andrei

This would be so nice. You could even implement foreach as a library 
function this way.