Odd behaviour concerning procs.

C

Christophe Poucet

Hello,

I've noticed the following behaviour and I'm not certain if this is
expected behaviour, however from the point of view of any other
language, it certainly seems odd.

Assume there is no constant with the name 'X' defined anywhere.

X => NameError: uninitialized constant X
proc{|X| true}.call(15) => true
X => 15
proc{|X| true}.call(15) # true, warning: already initialized constant
X

I would presume that the X would be localized to the proc. I know that
for normal variables, the variable in the calling scope is only changed
if it already exists, but in this case, the constant X does not even
exist. (And when it does exist, is it really preferred behaviour that a
proc will change a constant?)

With regards,
Christophe
 
K

Kevin Ballard

Christophe said:
Hello,

I've noticed the following behaviour and I'm not certain if this is
expected behaviour, however from the point of view of any other
language, it certainly seems odd.

Assume there is no constant with the name 'X' defined anywhere.

X => NameError: uninitialized constant X
proc{|X| true}.call(15) => true
X => 15
proc{|X| true}.call(15) # true, warning: already initialized constant
X

I would presume that the X would be localized to the proc. I know that
for normal variables, the variable in the calling scope is only changed
if it already exists, but in this case, the constant X does not even
exist. (And when it does exist, is it really preferred behaviour that a
proc will change a constant?)

This doesn't seem odd to me. I would read that as the equivalent of

proc{|a| self.class.const_set:)X, a); true}.call(15)

and that certainly defines the constant. Constants are not like local
variables - they don't have scopes. Instead, they exist on objects,
like class and instance variables. So there's no way a constant could
only exist inside the proc and remain undefined outside it.
 
R

Robert Klemme

Christophe said:
Hello,

I've noticed the following behaviour and I'm not certain if this is
expected behaviour, however from the point of view of any other
language, it certainly seems odd.

Assume there is no constant with the name 'X' defined anywhere.

X => NameError: uninitialized constant X
proc{|X| true}.call(15) => true
X => 15
proc{|X| true}.call(15) # true, warning: already initialized
constant X

I would presume that the X would be localized to the proc. I know
that for normal variables, the variable in the calling scope is only
changed if it already exists, but in this case, the constant X does
not even exist. (And when it does exist, is it really preferred
behaviour that a proc will change a constant?)

Basically the part between || leads to a normal assignment. So this
behavior is pretty much in line with other behavior (i.e. for local vars).
I guess the difference comes from the fact that lookup for constants is
done a bit differently. This allows to do what you cannot do with a local
var. It's odd, yes.

Kind regards

robert
 

Ask a Question

Want to reply to this thread or ask your own question?

You'll need to choose a username for the site, which only take a couple of moments. After that, you can post your question and our members will help you out.

Ask a Question

Members online

No members online now.

Forum statistics

Threads
473,744
Messages
2,569,484
Members
44,903
Latest member
orderPeak8CBDGummies

Latest Threads

Top