M{\mu}l: The Power of Dynamic Multi-Methods

TL;DR

M{b}l introduces a minimal dynamic language supporting multi-methods and flexible polymorphism without traditional class-based features, enabling dynamic modification of object behavior.

Contribution

It demonstrates how multi-methods and runtime method definitions can replace classes and inheritance for flexible object-oriented programming.

Findings

Supports dynamic multi-method dispatch based on multiple arguments.

Allows runtime modification of object behavior and state.

Simplifies language design while retaining powerful abstraction capabilities.

Abstract

Multi-methods are a straightforward extension of traditional (single) dynamic dispatch, which is the core of most object oriented languages. With multi-methods, a method call will select an appropriate implementation based on the values of multiple arguments, and not just the first/receiver. Language support for both single and multiple dispatch is typically designed to be used in conjunction with other object oriented features, in particular classes and inheritance. But are these extra features really necessary? M{\mu}l is a dynamic language designed to be as simple as possible but still supporting flexible abstraction and polymorphism. M{\mu}l provides only two forms of abstraction: (object) identities and (multi) methods. In M{\mu}l method calls are dispatched based on the identity of arguments, as well as what other methods are defined on them. In order to keep M{\mu}ls design simple, when multiple method definitions are applicable, the most recently defined one is chosen, not the most specific (as is conventional with dynamic dispatch). In this paper we show how by defining methods at runtime, we obtain much of the power of classes and meta object protocols, in particular the ability to dynamically modify the state and behaviour of 'classes' of objects.