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?)
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
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.
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.