«

Is there a reason why I can't do this?

foo = lambda { |foo = bar| puts foo }
foo.call

I can't think of any good reason why this isn't valid.


Cheers,
Daniel Schierbeck

Daniel Schierbeck wrote:
> Is there a reason why I can't do this?
>
> foo = lambda { |foo = bar| puts foo }
> foo.call
>
> I can't think of any good reason why this isn't valid.
>
>
> Cheers,
> Daniel Schierbeck

I of course meant |foo = "bar"|

Sorry

Hi,

In message "Re: Default argument values for blocks"
on Wed, 12 Oct 2005 01:56:52 +0900, Daniel Schierbeck <> writes:

|Is there a reason why I can't do this?
|
| foo = lambda { |foo = bar| puts foo }
| foo.call
|
|I can't think of any good reason why this isn't valid.

Mostly because yacc does not allow it. It confuses

lambda { |foo = bar| puts foo }

as

lambda { |foo = (bar| puts foo) }

and causes syntax error.

matz.

Hi,

In message "Re: Default argument values for blocks"
on Wed, 12 Oct 2005 02:25:33 +0900, Yukihiro Matsumoto <> writes:

||Is there a reason why I can't do this?
||
|| foo = lambda { |foo = bar| puts foo }
|| foo.call
||
||I can't think of any good reason why this isn't valid.
|
|Mostly because yacc does not allow it. It confuses
|
| lambda { |foo = bar| puts foo }
|
|as
|
| lambda { |foo = (bar| puts foo) }
|
|and causes syntax error.

For your information, you can do

foo = ->(foo="bar"){puts foo}
foo.call

in 1.9.

matz.

On Wed, 12 Oct 2005, Yukihiro Matsumoto wrote:

> Hi,
>
> In message "Re: Default argument values for blocks"
> on Wed, 12 Oct 2005 02:25:33 +0900, Yukihiro Matsumoto <> writes:
>
> ||Is there a reason why I can't do this?
> ||
> || foo = lambda { |foo = bar| puts foo }
> || foo.call
> ||
> ||I can't think of any good reason why this isn't valid.
> |
> |Mostly because yacc does not allow it. It confuses
> |
> | lambda { |foo = bar| puts foo }
> |
> |as
> |
> | lambda { |foo = (bar| puts foo) }
> |
> |and causes syntax error.
>
> For your information, you can do
>
> foo = ->(foo="bar"){puts foo}
> foo.call
>
> in 1.9.

-> means lambda?

-a
--
================================================== =============================
| email :: ara [dot] t [dot] howard [at] noaa [dot] gov
| phone :: 303.497.6469
| Your life dwells amoung the causes of death
| Like a lamp standing in a strong breeze. --Nagarjuna
================================================== =============================

Yukihiro Matsumoto wrote:
> Hi,
>
> In message "Re: Default argument values for blocks"
> on Wed, 12 Oct 2005 02:25:33 +0900, Yukihiro Matsumoto <> writes:
>
> ||Is there a reason why I can't do this?
> ||
> || foo = lambda { |foo = bar| puts foo }
> || foo.call
> ||
> ||I can't think of any good reason why this isn't valid.
> |
> |Mostly because yacc does not allow it. It confuses
> |
> | lambda { |foo = bar| puts foo }
> |
> |as
> |
> | lambda { |foo = (bar| puts foo) }
> |
> |and causes syntax error.
>
> For your information, you can do
>
> foo = ->(foo="bar"){puts foo}
> foo.call
>
> in 1.9.
>
> matz.
>
>

Cool. Is "->" the same as "lambda"? Can you write this:

collection.each -> (element) { puts element }

Yukihiro Matsumoto wrote:
> Mostly because yacc does not allow it. It confuses
>
> lambda { |foo = bar| puts foo }
>
> as
>
> lambda { |foo = (bar| puts foo) }
>
> and causes syntax error.

yacc? Maybe I was informed wrong, but I was under the impression that
Ruby used a hand-rolled parser.

Yukihiro Matsumoto wrote:
> Hi,
>
> In message "Re: Default argument values for blocks"
> on Wed, 12 Oct 2005 02:25:33 +0900, Yukihiro Matsumoto <> writes:
>
> ||Is there a reason why I can't do this?
> ||
> || foo = lambda { |foo = bar| puts foo }
> || foo.call
> ||
> ||I can't think of any good reason why this isn't valid.
> |
> |Mostly because yacc does not allow it. It confuses
> |
> | lambda { |foo = bar| puts foo }
> |
> |as
> |
> | lambda { |foo = (bar| puts foo) }
> |
> |and causes syntax error.
>
> For your information, you can do
>
> foo = ->(foo="bar"){puts foo}
> foo.call
>
> in 1.9.
>
> matz.

MY EYES!!!!

Please, no.

Dan

On Oct 11, 2005, at 12:21 PM, Kevin Ballard wrote:

> Yukihiro Matsumoto wrote:
>> Mostly because yacc does not allow it.
>
> yacc? Maybe I was informed wrong, but I was under the impression that
> Ruby used a hand-rolled parser.

You were informed wrong.

Hi --

On Wed, 12 Oct 2005, Yukihiro Matsumoto wrote:

> Hi,
>
> In message "Re: Default argument values for blocks"
> on Wed, 12 Oct 2005 02:25:33 +0900, Yukihiro Matsumoto <> writes:
>
> ||Is there a reason why I can't do this?
> ||
> || foo = lambda { |foo = bar| puts foo }
> || foo.call
> ||
> ||I can't think of any good reason why this isn't valid.
> |
> |Mostly because yacc does not allow it. It confuses
> |
> | lambda { |foo = bar| puts foo }
> |
> |as
> |
> | lambda { |foo = (bar| puts foo) }
> |
> |and causes syntax error.
>
> For your information, you can do
>
> foo = ->(foo="bar"){puts foo}
> foo.call
>
> in 1.9.

Is this definitely going to remain? (Please say no....


David

--
David A. Black