Question

Python has the idea of metaclasses that, if I understand correctly, allow you to modify an object of a class at the moment of construction. You are not modifying the class, but instead the object that is to be created then initialized.

Python (at least as of 3.0 I believe) also has the idea of class decorators. Again if I understand correctly, class decorators allow the modifying of the class definition at the moment it is being declared.

Now I believe there is an equivalent feature or features to the class decorator in Ruby, but I’m currently unaware of something equivalent to metaclasses. I’m sure you can easily pump any Ruby object through some functions and do what you will to it, but is there a feature in the language that sets that up like metaclasses do?

So again, Does Ruby have something similar to Python’s metaclasses?

Edit I was off on the metaclasses for Python. A metaclass and a class decorator do very similar things it appears. They both modify the class when it is defined but in different manners. Hopefully a Python guru will come in and explain better on these features in Python.

But a class or the parent of a class can implement a __new__(cls[,..]) function that does customize the construction of the object before it is initialized with __init__(self[,..]).

Edit This question is mostly for discussion and learning about how the two languages compare in these features. I’m familiar with Python but not Ruby and was curious. Hopefully anyone else who has the same question about the two languages will find this post helpful and enlightening.

Answer 1

Ruby doesn’t have metaclasses. There are some constructs in Ruby which some people sometimes wrongly call metaclasses but they aren’t (which is a source of endless confusion).

However, there’s a lot of ways to achieve the same results in Ruby that you would do with metaclasses. But without telling us what exactly you want to do, there’s no telling what those mechanisms might be.

In short:

• Ruby doesn’t have metaclasses
• Ruby doesn’t have any one construct that corresponds to Python’s metaclasses
• Everything that Python can do with metaclasses can also be done in Ruby
• But there is no single construct, you will use different constructs depending on what exactly you want to do
• Any one of those constructs probably has other features as well that do not correspond to metaclasses (although they probably correspond to something else in Python)
• While you can do anything in Ruby that you can do with metaclasses in Python, it might not necessarily be straightforward
• Although often there will be a more Rubyish solution that is elegant
• Last but not least: while you can do anything in Ruby that you can do with metaclasses in Python, doing it might not necessarily be The Ruby Way

So, what are metaclasses exactly? Well, they are classes of classes. So, let’s take a step back: what are classes exactly?

Classes …

• are factories for objects
• define the behavior of objects
• define on a metaphysical level what it means to be an instance of the class

For example, the Array class produces array objects, defines the behavior of arrays and defines what “array-ness” means.

Back to metaclasses.

Metaclasses …

• are factories for classes
• define the behavior of classes
• define on a metaphysical level what it means to be a class

In Ruby, those three responsibilities are split across three different places:

• the Class class creates classes and defines a little bit of the behavior
• the individual class’s eigenclass defines a little bit of the behavior of the class
• the concept of “classness” is hardwired into the interpreter, which also implements the bulk of the behavior (for example, you cannot inherit from Class to create a new kind of class that looks up methods differently, or something like that – the method lookup algorithm is hardwired into the interpreter)

So, those three things together play the role of metaclasses, but neither one of those is a metaclass (each one only implements a small part of what a metaclass does), nor is the sum of those the metaclass (because they do much more than that).

Unfortunately, some people call eigenclasses of classes metaclasses. (Until recently, I was one of those misguided souls, until I finally saw the light.) Other people call all eigenclasses metaclasses. (Unfortunately, one of those people is the author of one the most popular tutorials on Ruby metaprogramming and the Ruby object model.) Some popular libraries add a metaclass method to Object that returns the object’s eigenclass (e.g. ActiveSupport, Facets, metaid). Some people call all virtual classes (i.e. eigenclasses and include classes) metaclasses. Some people call Class the metaclass. Even within the Ruby source code itself, the word “metaclass” is used to refer to things that are not metaclasses.