On May 26, 2008, at 8:54 AM, Yukihiro Matsumoto wrote:

"trouble with recognition"? I thought they hated the -> mark, mostly
because it's different from lambda symbols (and syntax) in other
languages (except for Perl6). I assumed those hatred will decrease
once they used to the new syntax. But I didn't recognized they had
recognition problem.

My personal experience is that I don't find it a natural notation: when I see ->, I don't immediately think 'block coming'. Instead, I think 'pointer', 'member access', or something similar. So, for me, it really is a 'cognition' issue (so I guess the second time it's recognition).

You asked people to try the patched syntax that allows

meth {|a| a+1}, {|b| b*2}

I think that this particular syntax is a lot less obtrusive, and a lot easier to recognize, than

Actually, in my patch (and I believe ruby from r8044), the above is equivalent to:

(meth {|a| a+1}), lambda {|b| b*2}

If you want these to be lambda arguments, you'll need parens around your args:

meth( {|a| a+1}, {|b| b*2} )

Personally, for most cases I use ()'s around my args to reduce confusion about precedence, so the above isn't a problem for me. With this patch you'll need to use () for your arguments if your first argument is a bare block (that gets interpreted as a lambda).

Regardless of this patch, this precedence/ambiguity problem already exists today. Take a look at this example:

[meth {}, {}]

The first {} is the block for meth and the second is a Hash as the second item in a list (the first is the meth call). The interpretation of the above won't change with this patch. You'll need to use {|| } to get a lambda to differentiate it from a Hash.

I think it all comes down to a matter of clearly describing the precedence.

meth -> a { a + 1}, -> b { b * 2 }

The first one is obviously a couple of blocks: that's what I read when I see {|a| ...}.

It seems that most of the posters on this thread agree. And, using your criteria of "try it for a while and see", I'd judge that people have tried -> for a while, and might well be happier with the {|| } version.

I'd also argue that the {|a| } makes for a better language. My experience teaching this stuff shows that people are confused by the large number of different options that surround blocks. Unifying block parameters with method parameters, and then removing the need for this somewhat strange -> notation, will reduce the number of special cases, and make it a lot easier for people to understand the language. And that's a major cognition win.

Please, please consider adding both these patches into 1.9.

Dave