From: Christoph <chr_mail@...>
Date: 2003-11-30T22:35:37+09:00
Subject: Re: Class-level readers and writers

 

> -----Original Message-----
> From: David A. Black [mailto:dblack@wobblini.net] 
> Sent: Sunday, 30 November, 2003 03:29 AM
> To: ruby-talk ML
> Subject: Re: Class-level readers and writers
> 
> Hi --
> 
> On Sun, 30 Nov 2003, Gavin Sinclair wrote:
> 
> > On Sunday, November 30, 2003, 8:59:15 AM, Christoph wrote:
> > 
> > > David A. Black wrote:
> > > ...
> > >> So that's probably not a great idea in most cases.  
> Class variables 
> > >> have their own quirks, though they're scheduled to be a bit 
> > >> de-quirked in 2.0.
> > 
> > > My understanding (not that my record in reading Matz 2.0 
> intention 
> > > is anything I should be bragging about - not that I mind, 
> since I am 
> > > feeling like a kid in a candy store:-) was that Rite's class 
> > > variables will behave like today's class instance 
> variables without 
> > > the need of  ``class attribute accessors''.
> > 
> > > Personally I am actually in favor of getting ride of 
> class variables 
> > > altogether and only use class attributes accessors + 
> class instance 
> > > variables.
> > 
> > I sympathise.  Maybe @@x could be syntax sugar for 
> > self.class.instance_eval("@x"), if you get my drift.
> > 
> >   class Example
> >     @x = 5
> > 
> >     def meth
> >       @@x      # -> 5
> >     end
> >   end
> > 
> > There's probably a really good reason why not; I've never 
> really been 
> > able to wrap my head around all the issue here.
> 
> That would create a situation where it was awfully easy for 
> one object to get at another object's instance variables, 
> without the second object having granted access.  It's 
> already possible, as your example shows, but I don't think 
> it's the kind of thing one would want to encourage with 
> shortcuts (unless the object itself creates them).  
> 
> I think the new incarnation of class variables might be 
> handier than [I've found] the current one [to be], though 
> sometimes I also wish they'd just disappear :-)  I think part 
> of the trouble people have with the concept of Class objects 
> having instance variables is that they (wrongly but 
> understandably) surmise that there must be some relation or 
> connection with class variables.

To claim that there is no connection is a bit of stretch - as
you pointed out yourself the only difference between Rite's
class variables and (today's) instance is the additional visibility
of Rite's class variables within class instances  - this additional
visibility could easily achieved with accessor methods - which
has the BIG advantage that we could do without additional
Scoping rules of yet another special kind of variables (namely
class variables) reducing the overall complexity of the language. 

This simplification might be especially welcome with the introduction
of yet another kind of variables a.k.a. ``class local variables''.
I am sure you agree with me that there have been demonstrated 
misunderstandings of (today's) Ruby scoping rules not only by Nubies
but by seasoned practitioners as well - lets hope that Rite's will
(okay, given Matz track record, I am certain things will be a lot
better:-) lift today's visiblity (rules) fog.

/Christoph 


Just as reminder here some possible 1.8.1  implementations 
of a variety of nonhierarchical  class accessor methods.


---
class T
  class << self
    attr_accessor :var
  end
  def var
    self.class.var
  end
  def var=(rhs)
    self.class.var= 2
  end
end

T.new.var = 2
p T.new.var  # 2



class A
  __var__ = nil
  
  define_method(:var) {|| __var__ }
  define_method(:var=) {|rhs| __var__ = rhs }
  class << self
    private
    def inherited(sub)
      sub.instance_eval  {
         __var__ = nil
        define_method(:var) {|| __var__ }
        define_method(:var=) {|rhs| __var__ = rhs }
      }
      
    end
    def initialize_copy(orig)
      super
       __var__ = nil
       define_method(:var) {|| __var__ }
       define_method(:var=) {|rhs| __var__ = rhs }
    end
  end
end

class B < A.clone
end
B.new.var = 2
p B.new.var


class AA
  __var__ = nil
  
  define_method(:var) {|| __var__ }
  define_method(:var=) {|rhs| __var__ = rhs }
  class << self; self end.instance_eval {
    define_method(:var) {|| __var__ }
    define_method(:var=) {|rhs| __var__ = rhs }
  }
  class << self
    private
    def inherited(sub)
      sub.instance_eval  {
         __var__ = nil
        define_method(:var) {|| __var__ }
        define_method(:var=) {|rhs| __var__ = rhs }
        class << self; self end.instance_eval {
          define_method(:var) {|| __var__ }
          define_method(:var=) {|rhs| __var__ = rhs }
        }
      }
      
    end
    def initialize_copy(orig)
      super
      __var__ = nil
      define_method(:var) {|| __var__ }
      define_method(:var=) {|rhs| __var__ = rhs }
      class << self; self end.instance_eval {
        define_method(:var) {|| __var__ }
        define_method(:var=) {|rhs| __var__ = rhs }
      }
    end
  end
end

class BB < AA.clone
end


BB.new.var = 2
p BB.new.var # 2
BB.var = 3
p BB.new.var  # 3
---

Ruby.