=begin
   A method definition with no receiver creates an instance method.
     e.g def x
           2
         end
Instance methods are added to the object representing the class.  If the class in named K then the object representing 
the class is a constant K and K.class is Class.  Inside the class definition this object provides the context.
   A method definition with the method name prefixed by a constant or an expression creates a method associated with 
the object that is the value of the constant or expression.  This is a singleton method because it is associated only 
with one object.
    e.g. def a.x or def MyClass.x or def self.x or def (1.class).x

   We could define instance methods in the class Class or the class Module that would be class methods of every class 
because they would be instance methods of the constant object that represents the class.  But if we want to add class 
methods to class C only then we can add them as instance methods to the singleton class associated with C.
           class <<self
              # add here
           end 
=end

 class C 
   @y = 55                                # instance variable of class C
   p self, self.class

   name = gets.chomp.intern
   eval("def self.#{name}(val); 33+ val; end")   # public in Object
   p xx(5)
 
   def x(v)              
      p self, self.class
      p @y                                # instance variable of C objects
                                          # no value yet, so nil
      v+3                                  
   end
 # p x(20)                                # error

   class << self                          
     def z(val)           
        p @y                              # executes in context of
        val + 7                           # singleton class 
     end                                  # associated with C
  end                                     # which holds C class methods

  p z(20)
  a = :hat
  s = <<-e
        def self.#{a}(val)
          val + 122
        end
      e
  p s
  eval(s) 
 
 end

 c = C.new
 p c.x(2)
 p C.z(2)
 p C.xx(20)
 p C.hat(10)
 p class <<c
    self
   end