From: Robert Klemme <bob.news@...>
Date: 2003-12-04T02:32:05+09:00
Subject: Re: Attempted roadmap of future instance variables....


"David A. Black" <dblack@wobblini.net> schrieb im Newsbeitrag
news:Pine.LNX.4.44.0312030558560.27096-100000@wobblini.net...
> Hi --
>
> On Wed, 3 Dec 2003, Robert Klemme wrote:
>
> >
> > "Yukihiro Matsumoto" <matz@ruby-lang.org> schrieb im Newsbeitrag
> > news:1070389195.767662.15370.nullmailer@picachu.netlab.jp...
> > > Hi,
> > >
> > > In message "Re: Attempted roadmap of future instance variables...."
> > >     on 03/12/03, Steve Tuckner <STUCKNER@MULTITECH.COM> writes:
> > >
> > > |OK so the jist of it is that @_var variables are stored with the
class
> > of
> > > |the instance but the class has no access to that. That is all.
Right?
> > >
> > > No. @_var variables are stored in the instance, but they are
> > > accessible only from methods defined in the same class.
> >
> > Still a number of questions arise to me: How then are @_ variables
treated
> > with respect to methods instance_variables, instance_variable_set and
> > instance_variable_get?  Are they ignored and there is a second set of
> > methods that receives the class as argument (e.g.
> > instance_local_variables, instance_local_variable_get,
> > instance_local_variable_set)
>
> I assume they work as always, constrained only by the scope.  So:
>
>   class A
>     def m
>       instance_variable_set("@x",1)
>       instance_variable_set("@_y",2)
>     end

This is all well, but what if you invoke those methods from the outside?

>     def n
>       # @x and @_y, if used here, are the same objects here as above
>     end
>   end
>
>   class B
>     def mm
>       # @x same as above
>       # @_y different (class [B] local)
>     end
>   end
>
> > If so, what, if they are defined in an instance's private class like
this:
> >
> > class <<obj
> >   def get_foo; @_foo; end
> >   def set_foo(f); @_foo = f; end
> > end
> >
> > Do we use the instance instead of the class as method argument to
those
> > methods (see above) to get access to them via those methods?  If so,
how
> > is that disambiguited if obj is a class?
>
> Applying the rule: @_ variables are visible only from methods defined
> in the same class, I guess that would mean if you did:
>
>   class A
>     def x; @x; end
>     def x=(y); @x=y; end
>     def _x; @_x; end
>     def _x=(y); @_x=y; end
>   end
>
>   a = A.new
>
>   class << a
>     def showx; @x; end     # same @x as in A#x and A#x=
>     def show_x; @_x; end   # different @_x (same object (a) but defined
>                                             in a method in a different
class
>                                             (a's singleton as opposed to
A)
>   end
>
> I think (?) this is similar to Guy's example with singleton methods
> (which I'm still puzzling over :-)
>
> > Or do we make them unique by modifying the identifier, e.g. @_var
becomes
> > @Foo:_var if it was defined in class Foo?
>
> I don't think so; that kind of direct access to instance vars would
> break privacy and encapsulation.

??? That's broken already since I can invoke instance_variable_get from
the outside already now.

Cheers

    robert