Methods

Neutrino is an object-oriented language and as such the most fundamental operation is the method call. Neutrino methods are not smalltalk-style single dispatch ones, however, but multimethods.

The smalltalk model is nice and simple — but also limiting in practice. This obviously doesn’t just apply to smalltalk but any single dispatch language. You find yourself repeating the double dispatch pattern over and over. Operations that are binary by nature, such as addition and equality, are difficult to express in a way that is fully general. Generalizations such as catch-all methods or proxy objects can be awkward to express. Single dispatch is like an iceberg: the tip, the mechanism itself, has little complexity but there is a huge amount of hidden complexity that comes from having to express operations that are not, by nature, singly dispatched using only that mechanism. With neutrino I wanted to try a slightly more complex basic mechanism, under the assumption that it would reduce the amount of hidden complexity drastically.

The mechanism works like this. When defining what looks like a method you’re actually defining a matcher, so

`def (this is Point).norm() -> Math.sqrt(this.x*this.x + this.y*this.y);`

might look like a method definition on Point but is, in reality a matcher that matches any call where the name is `"norm"` and the first argument is an instance of Point. Similarly,

`def (this is Point)+(this is Point) -> ...`

is not a method on Point but a matcher that matches any call with the name `"+"` and a first and second argument which are Points.

Using this model method lookup becomes a matter of, given a call, finding the matcher that best matches the call. This is done using a scoring function which, for each possible matcher, gives an integer value to each entry in the matcher and then takes the lowest scoring (best matching) function. In the first example, if you pass a Point then the match is perfect and the score is 1. If you pass an instance of a subtype, say a CartesianPoint then the match is less perfect and the score is 1 + the shortest distance through the inheritance hierarchy. This means that if there is a more specific method, one that takes a CartesianPoint, then it will score lower and be preferred over the method that takes general Points. If no method matches a LookupError is thrown. If there is no unique best match then an AmbiguityError is thrown. That’s it.

When matching, all parts of the matcher are treated equally. Some parts will usually be known at compile time, for instance the method name, which means that the compiler will be able to generate more efficient code. However, that is an implementation detail and the method name is a parameter like any other. In particular, a matcher that matches any String as the name and a Point as the first argument is as valid and no different from one that happens to have a compile-time known name.

I’ve been using this mechanism for a while and find it to be much more convenient than single dispatch. There is really no comparison. No more visitors, you get to just express what you’re trying to do. Multimethods are often accused of being confusing and hard to understand. I think this is a matter of keeping the lookup rules simple and not being afraid to report an error if there is no obvious best match, rather than use elaborate tie-breaker rules.

This may look like a challenge to implement efficiently but the mechanism has been designed such that you only pay for the generality if you actually use it. If you do normal single or double dispatch with compile-time known method names then that’s what you pay for and, in particular, double dispatch can be less expensive because you can express it directly rather than through chains of separate calls, which means that the system can more easily optimize for it.

I’ve written up the details of the mechanism on the wiki under MultiMethodDispatch. This also describes how this works with keyword methods, which neutrino has but which I haven’t described here.

2 Responses to Methods

1. Hi Christian

Read through your wiki. I like your idea of multimethods. It seems quite simple on the surface, but has lots of “power”…

Would it be possible to extent a method in a way that would break method lookup of existing code?
I.e. if you have the method foo defined and used in module M, could you extend foo in another module, N, such that calls to foo in M would now fail with method lookup error?

Hope you enjoy life down under.

— Peter Mechlenborg

2. Hey Peter
Yes, assuming that you can define methods in one module that are visible in another, which you can, you can introduce ambiguities.

It can be very useful to be able to define methods that work on types defined in other modules, and have those methods be visible outside the defining module, including potentially the module that originally defined the type. Just like the ability for subclasses to define or override methods, which has a similar but more limited effect, you need to be disciplined about how and when you do this.

And yes, life is good down under :-).