Attempted roadmap of future instance variables....

[David A. Black]

Hi --

I figure that I owe the world at least a shot at clearing the cobwebs
(of my own creation, that is on this instance variable thing.

So... for those still reading... here's what I *really* think is being
proposed:


class A
def m
@var = "hi" # regular instance variable
@_var = "hello" # class-local instance variable
end
end

class B < A
def n
puts @var # same as @var, above
puts @_var # not same as @_var above
end
end

o = B.new
o.m
o.n

=> Output:

hi # the @var that was set in A#m is used here
nil # the @_var that was in A#m is *not* used here
# (because we're now in a method defined in B,
# a subclass of A, and class local instance
# variables are not shared by subclasses)

In other words:

* Regular instance variables live per-name per-object
(o has exactly one @var).

* Class-local instance variables live per-name per-object per-class
(o's methods defined in A have a @_var, and o's methods defined in
B have a different @_var).


David

 

[Ben Giddings]

So... for those still reading... here's what I *really* think is being
proposed:

class A
def m
@var = "hi" # regular instance variable
@_var = "hello" # class-local instance variable
end
end

For what it's worth, I don't think this is a good syntax. To me, an
underscore is an alphanumeric character. It's special because it is the
only non-letter, non-number that can appear in the middle of a variable name:

@foo_bar # legal
@foo.bar # not the same thing
@foo@bar # illegal
...

Making @_ a special case is bound to be confusing, because of this. There
is also the fact that normally variable names with a leading underscore are
a notation that something is internal, and not normally enforced as
something different.

On the other hand, this is consistent with other instances where the first
character of a symbol modifies its behaviour (i.e. if it starts with an
uppercase letter, it is a constant).

Mainly, I suppose, this just brings back ugly memories of languages that
lack truly private variables, so resort to notational hacks like leading
underscores.

Maybe a leading underscore by itself would be less confusing/distasteful?

class A
def m
@var = "hi" # regular instance variable
_var = "hello" # class-local instance variable
end
end

Ben