Metaclass

In Smalltalk-80

In Smalltalk, everything is an object. Additionally, Smalltalk is a class based system, which means that every object has a class that defines the structure of that object (i.e. the instance variables the object has) and the messages an object understands. Together this implies that a class in Smalltalk is an object and that, therefore a class needs to be an instance of a class (called metaclass).

As an example, a car object c is an instance of the class Car. In turn, the class Car is again an object and as such an instance of the metaclass of Car called Car class. Note the blank in the name of the metaclass. The name of the metaclass is the Smalltalk expression that, when evaluated, results in the metaclass object. Thus evaluating Car class results in the metaclass object for Car whose name is Car class (one can confirm this by evaluating Car class name which returns the name of the metaclass of Car.)

Class methods actually belong to the metaclass, just as instance methods actually belong to the class. When a message is sent to the object 2, the search for the method starts in Integer. If it is not found it proceeds up the superclass chain, stopping at Object whether it is found or not.

When a message is sent to Integer the search for the method starts in Integer class and proceeds up the superclass chain to Object class. Note that, so far, the metaclass inheritance chain exactly follows that of the class inheritance chain. But the metaclass chain extends further because Object class is the subclass of Class. All metaclasses are subclasses of Class.

In early Smalltalks, there was only one metaclass called Class. This implied that the methods all classes have were the same, in particular the method to create new objects, i.e., new. To allow classes to have their own methods and their own instance variables (called class instance variables and should not be confused with class variables), Smalltalk-80 introduced for each class C their own metaclass C class. This means that each metaclass is effectively a singleton class.

Since there is no requirement that metaclasses behave differently from each other, all metaclasses are instances of only one class called Metaclass. The metaclass of Metaclass is called Metaclass class which again is an instance of class Metaclass.

In Smalltalk-80, every class (except Object) has a superclass. The abstract superclass of all metaclasses is Class, which describes the general nature of classes.

The superclass hierarchy for metaclasses parallels that for classes, except for class Object. ALL metaclasses are subclasses of Class, therefore:

• Object class superclass == Class.

Like conjoined twins, classes and metaclasses are born together. Metaclass has an instance variable thisClass, which points to its conjoined class. Note that the usual Smalltalk class browser does not show metaclasses as separate classes. Instead the class browser allows to edit the class together with its metaclass at the same time.

The names of classes in the metaclass hierarchy are easily confused with the concepts of the same name. For instance:

• Object is the base class that provides common methods for all objects; "an object" is an integer, or a widget, or a Car, etc.
• Class is the base of the metaclasses that provides common methods for all classes (though it is not a metaclass itself); "a class" is something like Integer, or Widget, or Car, etc.
• Metaclass provides common methods for all metaclasses.

Four classes provide the facilities to describe new classes. Their inheritance hierarchy (from Object), and the main facilities they provide are:

Object - default behavior common to all objects, like class access

Behavior - minimum state for compiling methods and creating/running objects

ClassDescription (abstract class) - class/variable naming, comments

Class - similar, more comprehensive, facilities to superclasses

Metaclass - initializing class variables, instance creation messages

In Ruby

Ruby purifies the Smalltalk-80 concept of metaclasses by introducing eigenclasses, removing the Metaclass class, and (un)redefining the class-of map. The change can be schematized as follows:

Note in particular the correspondence between Smalltalk's implicit metaclasses and Ruby's eigenclasses of classes. The Ruby eigenclass model makes the concept of implicit metaclasses fully uniform: every object x has its own meta-object, called the eigenclass of x, which is one meta-level higher than x. The "higher order" eigenclasses usually exist purely conceptually – they do not contain any methods or store any (other) data in most Ruby programs.

The following diagrams show a sample core structure of Smalltalk-80 and Ruby in comparison. In both languages, the structure consists of a built-in part which contains the circular objects (i.e. objects that appear in a cycle formed by a combination of blue or green links) and a user-part which has four explicit objects: classes A and B and terminal objects u and v. Green links show the child→parent relation of inheritance (with the implicit upward direction), blue links show the complementary member→container relation of instantiation (a blue link from x points to the least actual container of x that is the start point for the method lookup when a method is invoked on x). Gray nodes display the eigenclasses (resp. implicit metaclasses in the case of Smalltalk-80).

The diagram on the right also provides a picture of lazy evaluation of eigenclasses in Ruby. The v object can have its eigenclass evaluated (allocated) as a consequence of adding singleton methods to v.

According to the Ruby's introspection method named class, the class of every class (and of every eigenclass) is constantly the Class class (denoted by c in the diagram). Class, and Struct are the only classes that have classes as instances. Subclassing of Class is disallowed. Following the standard definition of metaclasses we can conclude that Class and Struct are the only metaclasses in Ruby. This seems to contradict the correspondence between Ruby and Smalltalk, since in Smalltalk-80, every class has its own metaclass. The discrepancy is based on the disagreement between the class introspection method in Ruby and Smalltalk. While the map x ↦ x.class coincides on terminal objects, it differs in the restriction to classes. As already mentioned above, for a class x, the Ruby expression x.class evaluates constantly to Class. In Smalltalk-80, if x is a class then the expression x class corresponds to the Ruby's x.singleton_class – which evaluates to the eigenclass of x.

In Objective-C

Metaclasses in Objective-C are almost the same as those in Smalltalk-80—not surprising since Objective-C borrows a lot from Smalltalk. Like Smalltalk, in Objective-C, the instance variables and methods are defined by an object's class. A class is an object, hence it is an instance of a metaclass.

Like Smalltalk, in Objective-C, class methods are simply methods called on the class object, hence a class's class methods must be defined as instance methods in its metaclass. Because different classes can have different sets of class methods, each class must have its own separate metaclass. Classes and metaclasses are always created as a pair: the runtime has functions objc_allocateClassPair() and objc_registerClassPair() to create and register class-metaclass pairs, respectively.

There are no names for the metaclasses; however, a pointer to any class object can be referred to with the generic type Class (similar to the type id being used for a pointer to any object).

Because class methods are inherited through inheritance, like Smalltalk, metaclasses must follow an inheritance scheme paralleling that of classes (e.g. if class A's parent class is class B, then A's metaclass's parent class is B's metaclass), except that of the root class.

Unlike Smalltalk, the metaclass of the root class inherits from the root class (usually NSObject using the Cocoa framework) itself. This ensures that all class objects are ultimately instances of the root class, so that you can use the instance methods of the root class, usually useful utility methods for objects, on class objects themselves.

Since metaclass objects do not behave differently (you cannot add class methods for a metaclass, so metaclass objects all have the same methods), they are all instances of the same class—the metaclass of the root class (unlike Smalltalk). Thus, the metaclass of the root class is an instance of itself. The reason for this is that all metaclasses inherit from root class; hence, they must inherit the class methods of the root class.

C++ proposal

Herb Sutter of the ISO C++ Committee, first proposed the inclusion of metaclasses to C++ for C++20 using C++17 features. With the adoption of reflection in C++26, this paper was revised.

Its primary goal is to expand C++ abstraction beyond defined vocabulary (class, struct, union, enum, etc.) to allow adoptable vocabulary (such as interface, value), for the purpose of a more liberal approach to programming free of rule-memorisation. This feature would also allow non-standard features (such as interfaces) to be expressed as core features within libraries, and eliminate the necessity of specialised compilers (such as Qt moc, C++/CX, etc.) to express specific information using standardised features.

Using code injection (another proposed addition to C++ reflection which would add token sequence injection into source code), one would be able to create a Java/C# style "interface" using a consteval function:

<span id="mwAlw"></span><span class="k" id="mwAl0">import</span><span class="w" id="mwAl4"> </span><span class="n" id="mwAl8">std</span><span class="p" id="mwAmA">;</span> <span class="k" id="mwAmE">using</span><span class="w" id="mwAmI"> </span><span class="n" id="mwAmM">std</span><span class="o" id="mwAmQ">::</span><span class="n" id="mwAmU">string</span><span class="p" id="mwAmY">;</span> <span class="k" id="mwAmc">using</span><span class="w" id="mwAmg"> </span><span class="n" id="mwAmk">std</span><span class="o" id="mwAmo">::</span><span class="n" id="mwAms">string_view</span><span class="p" id="mwAmw">;</span> <span class="k" id="mwAm0">using</span><span class="w" id="mwAm4"> </span><span class="n" id="mwAm8">std</span><span class="o" id="mwAnA">::</span><span class="n" id="mwAnE">meta</span><span class="o" id="mwAnI">::</span><span class="n" id="mwAnM">exception</span><span class="p" id="mwAnQ">;</span> <span class="k" id="mwAnU">using</span><span class="w" id="mwAnY"> </span><span class="n" id="mwAnc">std</span><span class="o" id="mwAng">::</span><span class="n" id="mwAnk">meta</span><span class="o" id="mwAno">::</span><span class="n" id="mwAns">info</span><span class="p" id="mwAnw">;</span> <span class="p" id="mwAn0">[[</span><span class="na" id="mwAn4">nodiscard</span><span class="p" id="mwAn8">]]</span> <span class="k" id="mwAoA">consteval</span><span class="w" id="mwAoE"> </span><span class="n" id="mwAoI">info</span><span class="w" id="mwAoM"> </span><span class="n" id="mwAoQ">makeInterfaceFunctions</span><span class="p" id="mwAoU">(</span><span class="n" id="mwAoY">info</span><span class="w" id="mwAoc"> </span><span class="n" id="mwAog">proto</span><span class="p" id="mwAok">)</span><span class="w" id="mwAoo"> </span><span class="k" id="mwAos">noexcept</span><span class="w" id="mwAow"> </span><span class="p" id="mwAo0">{</span> <span class="w" id="mwAo4"> </span><span class="n" id="mwAo8">info</span><span class="w" id="mwApA"> </span><span class="n" id="mwApE">ret</span><span class="w" id="mwApI"> </span><span class="o" id="mwApM">=</span><span class="w" id="mwApQ"> </span><span class="o" id="mwApU">^^</span><span class="p" id="mwApY">{};</span> <span class="w" id="mwApc"> </span><span class="k" id="mwApg">for</span><span class="w" id="mwApk"> </span><span class="p" id="mwApo">(</span><span class="n" id="mwAps">info</span><span class="w" id="mwApw"> </span><span class="n" id="mwAp0">mem</span><span class="o" id="mwAp4">:</span><span class="w" id="mwAp8"> </span><span class="n" id="mwAqA">std</span><span class="o" id="mwAqE">::</span><span class="n" id="mwAqI">meta</span><span class="o" id="mwAqM">::</span><span class="n" id="mwAqQ">members_of</span><span class="p" id="mwAqU">(</span><span class="n" id="mwAqY">proto</span><span class="p" id="mwAqc">))</span><span class="w" id="mwAqg"> </span><span class="p" id="mwAqk">{</span> <span class="w" id="mwAqo"> </span><span class="k" id="mwAqs">if</span><span class="w" id="mwAqw"> </span><span class="p" id="mwAq0">(</span><span class="n" id="mwAq4">std</span><span class="o" id="mwAq8">::</span><span class="n" id="mwArA">meta</span><span class="o" id="mwArE">::</span><span class="n" id="mwArI">is_nonspecial_member_function</span><span class="p" id="mwArM">(</span><span class="n" id="mwArQ">mem</span><span class="p" id="mwArU">))</span><span class="w" id="mwArY"> </span><span class="p" id="mwArc">{</span> <span class="w" id="mwArg"> </span><span class="n" id="mwArk">ret</span><span class="w" id="mwAro"> </span><span class="o" id="mwArs">=</span><span class="w" id="mwArw"> </span><span class="o" id="mwAr0">^^</span><span class="p" id="mwAr4">{</span> <span class="w" id="mwAr8"> </span><span class="err" id="mwAsA">\</span><span class="n" id="mwAsE">tokens</span><span class="p" id="mwAsI">(</span><span class="n" id="mwAsM">ret</span><span class="p" id="mwAsQ">)</span> <span class="w" id="mwAsU"> </span><span class="k" id="mwAsY">virtual</span><span class="w" id="mwAsc"> </span><span class="p" id="mwAsg">[</span><span class="o" id="mwAsk">:</span><span class="err" id="mwAso">\</span><span class="p" id="mwAss">(</span><span class="n" id="mwAsw">std</span><span class="o" id="mwAs0">::</span><span class="n" id="mwAs4">meta</span><span class="o" id="mwAs8">::</span><span class="n" id="mwAtA">return_type_of</span><span class="p" id="mwAtE">(</span><span class="n" id="mwAtI">mem</span><span class="p" id="mwAtM">))</span><span class="o" id="mwAtQ">:</span><span class="p" id="mwAtU">]</span> <span class="w" id="mwAtY"> </span><span class="err" id="mwAtc">\</span><span class="n" id="mwAtg">id</span><span class="p" id="mwAtk">(</span><span class="n" id="mwAto">std</span><span class="o" id="mwAts">::</span><span class="n" id="mwAtw">meta</span><span class="o" id="mwAt0">::</span><span class="n" id="mwAt4">identifier_of</span><span class="p" id="mwAt8">(</span><span class="n" id="mwAuA">mem</span><span class="p" id="mwAuE">))</span><span class="w" id="mwAuI"> </span><span class="p" id="mwAuM">(</span><span class="err" id="mwAuQ">\</span><span class="n" id="mwAuU">tokens</span><span class="p" id="mwAuY">(</span><span class="n" id="mwAuc">std</span><span class="o" id="mwAug">::</span><span class="n" id="mwAuk">meta</span><span class="o" id="mwAuo">::</span><span class="n" id="mwAus">parameter_list_of</span><span class="p" id="mwAuw">(</span><span class="n" id="mwAu0">mem</span><span class="p" id="mwAu4">)))</span><span class="w" id="mwAu8"> </span><span class="o" id="mwAvA">=</span><span class="w" id="mwAvE"> </span><span class="mi" id="mwAvI">0</span><span class="p" id="mwAvM">;</span> <span class="w" id="mwAvQ"> </span><span class="p" id="mwAvU">};</span> <span class="w" id="mwAvY"> </span><span class="p" id="mwAvc">}</span><span class="w" id="mwAvg"> </span><span class="k" id="mwAvk">else</span><span class="w" id="mwAvo"> </span><span class="k" id="mwAvs">if</span><span class="w" id="mwAvw"> </span><span class="p" id="mwAv0">(</span><span class="n" id="mwAv4">std</span><span class="o" id="mwAv8">::</span><span class="n" id="mwAwA">meta</span><span class="o" id="mwAwE">::</span><span class="n" id="mwAwI">is_variable</span><span class="p" id="mwAwM">(</span><span class="n" id="mwAwQ">mem</span><span class="p" id="mwAwU">))</span><span class="w" id="mwAwY"> </span><span class="p" id="mwAwc">{</span> <span class="w" id="mwAwg"> </span><span class="c1" id="mwAwk">// Note: this is std::meta::exception, not std::exception</span> <span class="w" id="mwAwo"> </span><span class="k" id="mwAws">throw</span><span class="w" id="mwAww"> </span><span class="n" id="mwAw0">exception</span><span class="p" id="mwAw4">(</span><span class="s" id="mwAw8">"Encountered variable in prototype"</span><span class="p" id="mwAxA">,</span><span class="w" id="mwAxE"> </span><span class="o" id="mwAxI">^^</span><span class="n" id="mwAxM">makeInterfaceFunctions</span><span class="p" id="mwAxQ">);</span> <span class="w" id="mwAxU"> </span><span class="p" id="mwAxY">}</span> <span class="w" id="mwAxc"> </span><span class="p" id="mwAxg">}</span> <span class="w" id="mwAxk"> </span><span class="k" id="mwAxo">return</span><span class="w" id="mwAxs"> </span><span class="n" id="mwAxw">ret</span><span class="p" id="mwAx0">;</span> <span class="p" id="mwAx4">}</span> <span class="k" id="mwAx8">consteval</span><span class="w" id="mwAyA"> </span><span class="kt" id="mwAyE">void</span><span class="w" id="mwAyI"> </span><span class="n" id="mwAyM">interface</span><span class="p" id="mwAyQ">(</span><span class="n" id="mwAyU">info</span><span class="w" id="mwAyY"> </span><span class="n" id="mwAyc">proto</span><span class="p" id="mwAyg">)</span><span class="w" id="mwAyk"> </span><span class="k" id="mwAyo">noexcept</span><span class="w" id="mwAys"> </span><span class="p" id="mwAyw">{</span> <span class="w" id="mwAy0"> </span><span class="n" id="mwAy4">string_view</span><span class="w" id="mwAy8"> </span><span class="n" id="mwAzA">name</span><span class="w" id="mwAzE"> </span><span class="o" id="mwAzI">=</span><span class="w" id="mwAzM"> </span><span class="n" id="mwAzQ">std</span><span class="o" id="mwAzU">::</span><span class="n" id="mwAzY">meta</span><span class="o" id="mwAzc">::</span><span class="n" id="mwAzg">identifier_of</span><span class="p" id="mwAzk">(</span><span class="n" id="mwAzo">proto</span><span class="p" id="mwAzs">);</span> <span class="w" id="mwAzw"> </span><span class="n" id="mwAz0">std</span><span class="o" id="mwAz4">::</span><span class="n" id="mwAz8">meta</span><span class="o" id="mwA0A">::</span><span class="n" id="mwA0E">queue_injection</span><span class="p" id="mwA0I">(</span><span class="o" id="mwA0M">^^</span><span class="p" id="mwA0Q">{</span> <span class="w" id="mwA0U"> </span><span class="k" id="mwA0Y">class</span><span class="w" id="mwA0c"> </span><span class="err" id="mwA0g">\</span><span class="n" id="mwA0k">id</span><span class="p" id="mwA0o">(</span><span class="n" id="mwA0s">name</span><span class="p" id="mwA0w">)</span><span class="w" id="mwA00"> </span><span class="p" id="mwA04">{</span> <span class="w" id="mwA08"> </span><span class="k" id="mwA1A">public</span><span class="o" id="mwA1E">:</span> <span class="w" id="mwA1I"> </span><span class="c1" id="mwA1M">// make interface functions</span> <span class="w" id="mwA1Q"> </span><span class="err" id="mwA1U">\</span><span class="n" id="mwA1Y">tokens</span><span class="p" id="mwA1c">(</span><span class="n" id="mwA1g">makeInterfaceFunctions</span><span class="p" id="mwA1k">(</span><span class="n" id="mwA1o">proto</span><span class="p" id="mwA1s">))</span> <span class="w" id="mwA1w"> </span><span class="c1" id="mwA10">// the destructor</span> <span class="w" id="mwA14"> </span><span class="k" id="mwA18">virtual</span><span class="w" id="mwA2A"> </span><span class="o" id="mwA2E">~</span><span class="err" id="mwA2I">\</span><span class="n" id="mwA2M">id</span><span class="p" id="mwA2Q">(</span><span class="n" id="mwA2U">name</span><span class="p" id="mwA2Y">)()</span><span class="w" id="mwA2c"> </span><span class="o" id="mwA2g">=</span><span class="w" id="mwA2k"> </span><span class="k" id="mwA2o">default</span><span class="p" id="mwA2s">;</span> <span class="w" id="mwA2w"> </span><span class="c1" id="mwA20">// the constructor</span> <span class="w" id="mwA24"> </span><span class="err" id="mwA28">\</span><span class="n" id="mwA3A">id</span><span class="p" id="mwA3E">(</span><span class="n" id="mwA3I">name</span><span class="p" id="mwA3M">)()</span><span class="w" id="mwA3Q"> </span><span class="o" id="mwA3U">=</span><span class="w" id="mwA3Y"> </span><span class="k" id="mwA3c">default</span><span class="p" id="mwA3g">;</span> <span class="w" id="mwA3k"> </span><span class="c1" id="mwA3o">// delete the copy constructor</span> <span class="w" id="mwA3s"> </span><span class="err" id="mwA3w">\</span><span class="n" id="mwA30">id</span><span class="p" id="mwA34">(</span><span class="n" id="mwA38">name</span><span class="p" id="mwA4A">)(</span><span class="k" id="mwA4E">const</span><span class="w" id="mwA4I"> </span><span class="err" id="mwA4M">\</span><span class="n" id="mwA4Q">id</span><span class="p" id="mwA4U">(</span><span class="n" id="mwA4Y">name</span><span class="p" id="mwA4c">)</span><span class="o" id="mwA4g">&</span><span class="p" id="mwA4k">)</span><span class="w" id="mwA4o"> </span><span class="o" id="mwA4s">=</span><span class="w" id="mwA4w"> </span><span class="k" id="mwA40">delete</span><span class="p" id="mwA44">;</span> <span class="w" id="mwA48"> </span><span class="c1" id="mwA5A">// delete the copy assignment operator</span> <span class="w" id="mwA5E"> </span><span class="kt" id="mwA5I">void</span><span class="w" id="mwA5M"> </span><span class="k" id="mwA5Q">operator</span><span class="o" id="mwA5U">=</span><span class="p" id="mwA5Y">(</span><span class="k" id="mwA5c">const</span><span class="w" id="mwA5g"> </span><span class="err" id="mwA5k">\</span><span class="n" id="mwA5o">id</span><span class="p" id="mwA5s">(</span><span class="n" id="mwA5w">name</span><span class="p" id="mwA50">)</span><span class="o" id="mwA54">&</span><span class="p" id="mwA58">)</span><span class="w" id="mwA6A"> </span><span class="o" id="mwA6E">=</span><span class="w" id="mwA6I"> </span><span class="k" id="mwA6M">delete</span><span class="p" id="mwA6Q">;</span> <span class="w" id="mwA6U"> </span><span class="p" id="mwA6Y">};</span> <span class="w" id="mwA6c"> </span><span class="p" id="mwA6g">});</span> <span class="p" id="mwA6k">}</span> <span class="c1" id="mwA6o">// use "interface":</span> <span class="k" id="mwA6s">class</span><span class="p" id="mwA6w">(</span><span class="n" id="mwA60">interface</span><span class="p" id="mwA64">)</span><span class="w" id="mwA68"> </span><span class="n" id="mwA7A">IFoo</span><span class="w" id="mwA7E"> </span><span class="p" id="mwA7I">{</span> <span class="w" id="mwA7M"> </span><span class="kt" id="mwA7Q">int</span><span class="w" id="mwA7U"> </span><span class="nf" id="mwA7Y">f</span><span class="p" id="mwA7c">();</span> <span class="w" id="mwA7g"> </span><span class="kt" id="mwA7k">void</span><span class="w" id="mwA7o"> </span><span class="nf" id="mwA7s">g</span><span class="p" id="mwA7w">(</span><span class="n" id="mwA70">string</span><span class="w" id="mwA74"> </span><span class="n" id="mwA78">s</span><span class="p" id="mwA8A">);</span> <span class="p" id="mwA8E">};</span>

It would also be possible to apply multiple metaclass types. For example, for metaclasses x and y, one could write class(x, y) MyClass { /* ... */ };.

The paper proposes that this allows for abstractions to greatly decrease boilerplate by producing generated functions and customisable defaults, semantics, and constraints. It further abolishes the need to create new language feature proposals by allowing such features to be expressed using metaclass features.

Support in languages and tools

The following are some of the most prominent programming languages that support metaclasses.

• Common Lisp, via CLOS
• Delphi and other versions of Object Pascal influenced by it
• Groovy
• Objective-C
• ooRexx
• Python
• Perl, via the metaclass pragma, as well as Moose
• Ruby
• Smalltalk

Some less widespread languages that support metaclasses include OpenJava, OpenC++, OpenAda, CorbaScript, ObjVLisp, Object-Z, MODEL-K, XOTcl, and MELDC. Several of these languages date from the early 1990s and are of academic interest.

Java features java.lang.Class<T> for introspection, similar to metaclasses, but are not actually metaclasses.

Logtalk, an object-oriented extension of Prolog, also supports metaclasses.

Resource Description Framework (RDF) and Unified Modeling Language (UML) both support metaclasses.

Metaclasses were a proposed for a possible inclusion in future version of C++, but currently is not an included feature.