MultiMethods for Python

http://alexgaynor.net/2010/jun/26/multimethods-python/

by twampss • 16 years ago

24 10 16 years ago

gometro33• 16 years ago

The difference between this and true overloaded methods (which, correct me if I'm wrong, is the what he meant by "MultiMethod") is that an overloaded method is created at compile-time and does not incur the added cost of determining the type of the object at runtime.

That being said, I didn't know that Python doesn't have function signatures. Would someone care to comment on how a function is identified?

tomjen3• 16 years ago

It is true that one of the advantages of overloaded methods is that the cost is payed at compiler time, but it does also limit its flexibility, since it can only dispatch based on the information available at compile time (this isn't enough to implement oop polymorphism for example, except if you know no derived class override the method).

Python makes this much more complicated, because it doesn't have types (actually all the variables have dynamic types, so the type of a variable depends on what value it has) - and it is interpretated, so there isn't a compile step where it could resolve something like this.

Oh and usually multimethods dispatch based on the actual type of _multiple_ arguments, not just one.

Ixiaus• 16 years ago

I think Erlang does MultiMethods properly, it will call a function based on it's arity...

dfox• 16 years ago

The difference between method overloading and true multimethods (see CLOS, Dylan, Perl 6...) is that multimethods are resolved runtime (depending on actual argument types or even their values itself).

xi2• 16 years ago

Multi-methods are not overloaded functions (in the C++ sense). You are correct that overloaded function calls are resolved at compile-time while multi-method calls are resolved at runtime, but if you want to make a C++ analogy, you'd better compare them to virtual methods. Multi-methods work almost like virtual methods, with two exceptions:

1) multi-methods are declared outside the class definitions; it is important since it allows you to extend a class without directly modifying its definition or implementation.

2) virtual functions do dispatch by one argument (`this` in C++) while multi-methods could perform dispatch by an arbitrary number of arguments.

That said, I don't like this implementation that much since it does not respect class inheritance. Suppose you defined a MultiMethod with two registered implementations, for class A and class B, where B is inherited from A. Then the result of the multi-method call with an object of type B is undefined. A proper multi-method would call the most specific implementation in this case.

dkersten2• 16 years ago

In C++, methods are only dispatched by the type of the arguments. In, for example, Clojure's multimethods you can dispatch on pretty much anything: type of some or all arguments, their values, function of either (or both)... etc.

Quick example:

    (defmulti foo #(* % 100))
    (defmethod foo 0 [_] "passed in zero")
    (defmethod foo 100 [_] "passed in one")
    (defmethod foo 200 [_] "passed in two")
    (defmethod foo :default [n] (str "passed in " n))
    ...
    >>> (foo 2)
    "passed in two"
    >>> (foo 5)
    "passed in 5"

(written off the top of my head, so excuse any mistakes..)

I'm only using a single argument here and I'm dispatching on a function of its value. I could just as easily dispatch on multiple arguments (or an arbitrary amount).

deno• 16 years ago

You shouldn't test for arguments with isinstance(). Better test for specific functionality. It's like FreeBSD developers being angry that people use tests like 'somecmd --version' in autoconf scripts and thus software not compiling even though required functionality was available.

MultiMethods for Python

Related Stories