[lnkForumImage]
TotalShareware - Download Free Software

Confronta i prezzi di migliaia di prodotti.
Asp Forum
 Home | Login | Register | Search 


 

Forums >

comp.lang.ruby

Shadowing bug??

Vasco Andrade e silva

11/13/2007 6:20:00 PM

Hi,

def f_ok(node)
func = lambda {|n| p(:in_lambda, n); n }
p node, func.call(node[:xpto]), node
end

> f_ok({:xpto => "ohoh"})
:in_lambda
"ohoh"
{:xpto=>"ohoh"}
"ohoh"
{:xpto=>"ohoh"}

def f_ko(node)
func = lambda {|node| p(:in_lambda, node); node }
p node, func.call(node[:xpto]), node
end

> f_ko({:xpto => "ohoh"})
:in_lambda
"ohoh"
{:xpto=>"ohoh"}
"ohoh"
"ohoh" # ohoh... should be {:xpto=>"ohoh"}, or not??

I can't get any kind of explanation for this. Does anybody have one?
Why "node" in lambda isn't shadowed correctly (as i expected, at least)?
Well "node" is shadowed correctly but seems to be producing side
effects...

Thanks,
Vasco Andrade e Silva
--
Posted via http://www.ruby-....

6 Answers

Marcin Raczkowski

11/13/2007 8:22:00 PM

0

Vasco Andrade e Silva wrote:
> Hi,
>
> def f_ok(node)
> func = lambda {|n| p(:in_lambda, n); n }
> p node, func.call(node[:xpto]), node
> end
>
>> f_ok({:xpto => "ohoh"})
> :in_lambda
> "ohoh"
> {:xpto=>"ohoh"}
> "ohoh"
> {:xpto=>"ohoh"}
>
> def f_ko(node)
> func = lambda {|node| p(:in_lambda, node); node }
> p node, func.call(node[:xpto]), node
> end
>
>> f_ko({:xpto => "ohoh"})
> :in_lambda
> "ohoh"
> {:xpto=>"ohoh"}
> "ohoh"
> "ohoh" # ohoh... should be {:xpto=>"ohoh"}, or not??
>
> I can't get any kind of explanation for this. Does anybody have one?
> Why "node" in lambda isn't shadowed correctly (as i expected, at least)?
> Well "node" is shadowed correctly but seems to be producing side
> effects...
>
> Thanks,
> Vasco Andrade e Silva

I remember someone mentioned that it's possible to do some strange
things in lambda (modyfing variable passed beeing one of them), but
there's nothing in this funcition or lambda that would modify "node", i
think there might be a scope problem that makes node variable in
function beeing overvriten when part of node is in lambda


irb(main):014:0> def f_ko(node)
irb(main):015:1> func = lambda {|node| p(:in_lambda, node); node }
irb(main):016:1> p node, func.call("bleh"), node
irb(main):017:1> end
=> nil
irb(main):018:0> f_ko({:xpto => "ohoh"})
:in_lambda
"bleh"
{:xpto=>"ohoh"}
"bleh"
"bleh"
=> nil


this seems to confirm that using |node| will overwrite node in function,
i'm not sure if it's intended scope behaviour tho

ThoML

11/13/2007 10:12:00 PM

0

This is a somewhat similar situation where a variable isn't all that
local:

x = 1
(2..3).each {|x|}
p x
=> 3

I think this is intended though and AFAIK this behaviour is subject
to
change in 2.0 and maybe has already changed in 1.9.


Vasco Andrade e silva

11/14/2007 12:11:00 PM

0

tho_mica_l wrote:
> This is a somewhat similar situation where a variable isn't all that
> local:
>
> x = 1
> (2..3).each {|x|}
> p x
> => 3
Exactly!

>
> I think this is intended though and AFAIK this behaviour is subject
> to
> change in 2.0 and maybe has already changed in 1.9.

I tested in ruby1.9 and the "bug" seems fixed:
> RUBY_VERSION
"1.9.0"
> x = 1
> (2..3).each {|x|}
> p x
1

> f_ko({:xpto => "ohoh"})
:in_lambda
"ohoh"
{:xpto=>"ohoh"}
"ohoh"
{:xpto=>"ohoh"} # :-)

Thank you people,
Vasco Andrade e Silva
--
Posted via http://www.ruby-....

Peña, Botp

11/15/2007 1:17:00 PM

0

From: tho_mica_l [mailto:micathom@gmail.com]=20
# x =3D 1
# (2..3).each {|x|}
# p x
# =3D> 3
#=20
# I think this is intended though and AFAIK this behaviour is subject
# to change in 2.0 and maybe has already changed in 1.9.

indeed.
C:\ruby1.9\bin>irb

irb(main):001:0> x =3D 1
=3D> 1
irb(main):002:0> (2..3).each {|x|}
=3D> 2..3
irb(main):003:0> p x
1
=3D> 1

kind regards -botp

Robert Klemme

11/15/2007 4:57:00 PM

0

2007/11/14, Vasco Andrade e Silva <vascoas@gmail.com>:
> tho_mica_l wrote:
> > This is a somewhat similar situation where a variable isn't all that
> > local:
> >
> > x = 1
> > (2..3).each {|x|}
> > p x
> > => 3
> Exactly!
>
> >
> > I think this is intended though and AFAIK this behaviour is subject
> > to
> > change in 2.0 and maybe has already changed in 1.9.
>
> I tested in ruby1.9 and the "bug" seems fixed:
> > RUBY_VERSION
> "1.9.0"
> > x = 1
> > (2..3).each {|x|}
> > p x
> 1
>
> > f_ko({:xpto => "ohoh"})
> :in_lambda
> "ohoh"
> {:xpto=>"ohoh"}
> "ohoh"
> {:xpto=>"ohoh"} # :-)

Just let me add that even though this is fixed IMHO it is a bad idea
to use the same identifier in both cases if you want to keep them
separate. This can likely cause confusion.

Kind regards

robert

--
use.inject do |as, often| as.you_can - without end

Vasco Andrade e silva

11/20/2007 10:18:00 PM

0

Hi (again),

In "Programing Ruby: The Pragmatic Programmers Guide (2dn Ed.)" Book,
pp. 333:
<quote>
Block parameters are assigned values when the block is invoked.
...
If a local variable (including a block parameter) is first assigned in a
block, it is local to the block. If instead a variable of the same name
is already established at the time the block executes, the block will
inherit that variable.
</quote>

As far as i can see in that text it describes (spec's)
x = 1
(2..3).each {|x|}
p x
=> 3
to a correct case..

I need to know:
1) Is this the behavior we should expect from the ruby language (1.8)?
2) Since ruby (1.9) does not behave the same way:
x = 1
(2..3).each {|x|}
p x
=> 1
what should be the spec for block parameters?

Thanks (once more),
Vasco
--
Posted via http://www.ruby-....