maat/docs/inheritance.md

Classes

Overview

Class Artichecture

Inheritances

Maat uses C3 mro as resolution order for resolving method calls, method resolution is done during compilation which makes Maat pretty fast at execution.

                (f(D))        (f(Z))
                 D ──────────► Z
                 ▲
                 │
                 │
                 │

                (f(B))
        ┌──────►  B ────────► E (f(E))
        │                    ▲
 (f(A)) A                    │
        │                    │
        │       (f(C))       │
        └──────► C ──────────┘
                 │
                 │
               │       (f(M))     (f(K))
                 └──────► M ───────► K

The above diagram shows the inheritance relationships between the classes A, B, C, D, E, M, K, and Z. For example we have class A which directly inherits from class B and C and indirectly inherits from class K.

Problem

We wish to resolve a method f when calling it from an object which is an instance of A.

Solution

Let X be a class belonging to the set of classes {A, B, C, D, E, M, K, Z}, X may have its own implementation of f denoted f(X). By applying the C3 method resolution algorithm at compilation, we use the divide and conquer approach to perform a breadth-first traversal on the inheritance tree of X, this yields an array which contains contains in C3 order pointers to all the implementations of f we found. This array is recorded as the value stored at the entry of f in the method hash table of X, the first element of this arrays is the top level method that is going to be called during an f call by an object instance of X. The rest of the elements are used to handle __SUPER__ calls, especially when they are chained across multiple f calls.

Let function R(X:f) denotes the f method resolution of class X that returns the array we were talking of.

We have the following:

For an object instance of A, the following is true

...