> > It'll probably work as general mapping to #call so it would
> > work with
> > everything that has #call.
> > 
> > Cheers
> > 
> >     robert
> 
> Thanks Robert.  If that is the case, it sounds like I'll get
> the main thing I wanted - ()/null operator.
> 
> Anybody know if lambdas will also support blocks anytime
> soon? 
> It doesn't seem to make sense why I can't do this:
> 
> f = lambda {|*args,&block|puts(*args);block[]}
> f[1,2,3] { puts("hi") }
> 
> or in the 1.9 syntax:
> 
> f = {|*args,&block|puts(*args);block[]}
> f(1,2,3) { puts("hi") }
> 
> I just grabbed 1.9 and none of this new syntax seems to work.

whoops.  I was still running 1.8.2.

It looks like you can put &block as a lambda argument now.  So
the above 1.9 example works.

Unfortunately, when "calling" an object, you have to do it from
a local variable.  Also, you have to have the parens in there
even if you have a block.  These don't work:

{|*args,&block|puts(*args);block()}(1,2,3) { puts("hi") }
f { puts("hi") } # f() { puts("hi") } works

I'm not sure why f can't be an arbitrary expression instead.  I
also tried this:

class Class;alias call new;end

This doesn't work:

Range(0,7)

and this does:

range = Range
range(0,7)          -> 0..7

And one more thing.  If someone has both a local variable f and
a method f, we have different behavior in 1.8.2 vs. 1.9:

f = lambda {|*args|puts("lambda",*args)}
def f(*args);puts("method",*args);end
f(1,2,3)

1.8.2 calls the method and 1.9 calls the lambda.  This seems
bad.  So it looks like the priority between local variables and
methods has been reversed - 1.8.2 prefers methods and 1.9
prefers local variables.  You can no longer use "()" to
distinguish the two.  Maybe is does make sense because they are
in the same namespace and local usually overrides, but people
need to be aware.



		
__________________________________ 
Yahoo! Mail Mobile 
Take Yahoo! Mail with you! Check email on your mobile phone. 
http://mobile.yahoo.com/learn/mail