rename meta to singleton class

seems more appropriate, as it is the class for a single object
Also seems to be called that on the net (don't remember where the meta came from, but it's gone)

lib/parfait.rb

@@ -9,7 +9,7 @@ require_relative "parfait/integer"
 require_relative "parfait/factory"
 require_relative "parfait/behaviour"
 require_relative "parfait/class"
-require_relative "parfait/meta_class"
+require_relative "parfait/singleton_class"
 require_relative "parfait/list"
 require_relative "parfait/word"
 require_relative "parfait/binary_code"

lib/parfait/behaviour.rb

@@ -1,12 +1,12 @@
 module Parfait
-  # Behaviour is the old smalltalk name for the duperclass of class and meta_class
+  # Behaviour is the old smalltalk name for the duperclass of class and singleton_class
   #
-  # Classes and meta_classes are in fact very similar, in that they manage
+  # Classes and singleton_classes are in fact very similar, in that they manage
   # - the type of instances
   # - the methods for instances
   #
   # The main way they differ is that Classes manage type for a class of objects (ie many)
-  # whereas meta_class, or singleton_class manages the type of only one object (here a class)
+  # whereas singleton_class, or singleton_class manages the type of only one object (here a class)
   #
   # Singleton classes can manage the type/methods of any single object, and in the
   # future off course they will, just not yet. Most single objects don't need that,

lib/parfait/class.rb

@@ -17,7 +17,7 @@
 module Parfait
   class Class < Behaviour
 
-    attr_reader :name , :super_class_name , :meta_class
+    attr_reader :name , :super_class_name , :singleton_class
 
     def self.type_length
       6
@@ -30,7 +30,7 @@ module Parfait
       super(instance_type)
       @name = name
       @super_class_name = superclass
-      @meta_class = MetaClass.new( self , self.type || @name)
+      @singleton_class = SingletonClass.new( self , self.type || @name)
     end
 
     def rxf_reference_name

lib/parfait/singleton_class.rb

@@ -1,20 +1,20 @@
 #
-# In many respects a MetaClass is like a Class. We haven't gone to the full ruby/oo level
-# yet, where the metaclass is actually a class instance, but someday.
+# In many respects a SingletonClass is like a Class. We haven't gone to the full ruby/oo level
+# yet, where the singleton_class is actually a class instance, but someday.
 
 # A Class in general can be viewed as a way to generate methods for a group of objects.
 
-# A MetaClass serves the same function, but just for one object, the class object that it
-# is the meta_class of.
+# A SingletonClass serves the same function, but just for one object, the class object that it
+# is the singleton_class of.
 # This is slightly different in the way that the type of the class must actually
 # change, whereas for a class the instance type changes and only objects generated
 # henceafter have a different type.
 
-# Another current difference is that a metaclass has no superclass. Also no name.
-# There is a one to one relationship between a class instance and it's meta_class instance.
+# Another current difference is that a singleton_class has no superclass. Also no name.
+# There is a one to one relationship between a class instance and it's singleton_class instance.
 
 module Parfait
-  class MetaClass < Behaviour
+  class SingletonClass < Behaviour
 
     attr_reader :clazz
 
@@ -36,7 +36,7 @@ module Parfait
     end
 
     def inspect
-      "MetaClass(#{@clazz.name})"
+      "SingletonClass(#{@clazz.name})"
     end
 
     def to_s

lib/risc/parfait_boot.rb

@@ -51,7 +51,7 @@ module Parfait
     classes.each do |name , cl|
       object_type = Parfait.object_space.get_type_by_class_name(name)
       raise "nil type" unless object_type
-      cl.meta_class.instance_eval{ @instance_type = class_type}
+      cl.singleton_class.instance_eval{ @instance_type = class_type}
       cl.instance_eval{ @instance_type = object_type}
       cl.instance_eval{ @super_class_name = super_names[name] || :Object}
       object_type.instance_eval{ @object_class = cl }
@@ -85,7 +85,7 @@ module Parfait
        CallableMethod: :Callable,
        Block: :Callable,
        Class: :Behaviour,
-       MetaClass: :Behaviour ,
+       SingletonClass: :Behaviour ,
        ReturnAddress: :Integer}
   end
 
@@ -106,7 +106,7 @@ module Parfait
                        arguments_type: :Type , self_type: :Type, frame_type: :Type ,
                        name: :Word , blocks: :Block} ,
       Class: {instance_methods: :List, instance_type: :Type,
-              name: :Word, super_class_name: :Word , meta_class: :MetaClass},
+              name: :Word, super_class_name: :Word , singleton_class: :SingletonClass},
       DataObject: {},
       Data4: {},
       Data8: {},
@@ -129,7 +129,7 @@ module Parfait
                  local5: :Object, local6: :Object ,local7: :Object, local8: :Object ,
                  local9: :Object ,local10: :Object, local11: :Object , local12: :Object,
                  local13: :Object, local14: :Object, local15: :Object},
-      MetaClass: {instance_methods: :List, instance_type: :Type, clazz: :Class },
+      SingletonClass: {instance_methods: :List, instance_type: :Type, clazz: :Class },
       NilClass: {},
       Object: {},
       ReturnAddress: {next_integer: :ReturnAddress},

lib/vool/class_expression.rb

@@ -37,7 +37,7 @@ module Vool
         when MethodExpression
           node.to_mom(@clazz)
         when ClassMethodExpression
-          node.to_mom(@clazz.meta_class)
+          node.to_mom(@clazz.singleton_class)
         else
           raise "Only methods for now #{node.class}:#{node}"
         end
@@ -62,7 +62,7 @@ module Vool
     end
 
     # goes through the code looking for instance variables (and their assignments)
-    # adding each to the respective type, ie class or meta_class, depending
+    # adding each to the respective type, ie class or singleton_class, depending
     # on if they are instance or class instance variables.
     #
     # Class variables are deemed a design mistake, ie not implemented (yet)
@@ -72,7 +72,7 @@ module Vool
         when MethodExpression
           target = @clazz
         when ClassMethodExpression
-          target = @clazz.meta_class
+          target = @clazz.singleton_class
         else
           raise "Only methods for now #{node.class}:#{node}"
         end

lib/vool/class_method_expression.rb

@@ -8,7 +8,7 @@ module Vool
     end
 
     def to_mom(clazz)
-      raise "not meta" unless clazz.class == Parfait::MetaClass
+      raise "not singleton" unless clazz.class == Parfait::SingletonClass
       raise( "no class in #{self}") unless clazz
       method = clazz.add_instance_method_for(name , make_arg_type , make_frame , body )
       #puts "CLass method Class:#{clazz}:#{name}"

lib/vool/variables.rb

@@ -49,7 +49,7 @@ module Vool
   class ModuleName < Expression
     include Named
     def ct_type
-      get_named_class.meta_class.instance_type
+      get_named_class.singleton_class.instance_type
     end
     def to_slot(_)
       return Mom::SlotDefinition.new( get_named_class, [])