Hacker News Reader

Comment by dkersten | Hacker News Reader

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).

View on HN

I wonder how Clojure deals with ambiguities when dispatching by arbitrary predicates. Also in this case, the overhead of of generic call will grow linearly with the number of methods, right?

In Python, you could limit generic dispatch to argument type only without losing generality since you could override the `isinstance` operator. For instance, you could define a `const()` type so that `isinstance(x, const(100))` is true if and only if `x == 100`. Then your example could be written in Python as:

  foo = generic()

  foo.when(const(0))
  def foo_0(x): print "passed in zero"
  foo.when(const(100))
  def foo_100(x): print "passed in 100"
  foo.when(const(200))
  def foo_200(x): print "passed in 200"
  foo.when(int)
  def foo_default(x): print "passed in", x

This is not as elegant as in a language with native support for generic functions, but it works. I wish mainstream languages started to adopt multi-methods; it's conceptually very simple and much more extension-friendly than traditional OOP. Sadly it doesn't seem to happen.

the overhead of of generic call will grow linearly with the number of methods

As far as I know, no. I could be wrong, but I think how it works is this: each method is added to a map for that multimethod. When dispatching, the dispatch function is applied to the arguments and the result is used as the key into the map of methods. I'm pretty sure that the compiler could optimise the lookup too, though I don't know if Clojure does or not.

Thats just what I would do if I wrote Clojure - I don't actually know how Clojure manages it in real life (and am too lazy to check).

Yeah. I've always wished that languages like C++ had two things: multimethods and ML-style pattern matching (well, three things - I guess you'd want ML-style parametric types to go with the pattern matching).

This is correct, C++ does dispatch based of the type of the arguments. That's how also ties in further into how linking and name mangling works.

Reply on news.ycombinator.com