Logo Questions Linux Laravel Mysql Ubuntu Git Menu
 

Clojure multimethods vs. protocols

I'm a Clojure novice and was looking for some concrete examples of when to use protocols and when to use multimethods. I know that protocols are generally geared towards creating a type hierarchy and typical OOP things, that they were added to the language after multimethods, and that protocols generally have better performance so my question is this:

Are protocols meant to replace multimethods? If not, could you give me an example where I would use multimethods instead of protocols?

like image 940
Sean Nilan Avatar asked Nov 09 '11 19:11

Sean Nilan


3 Answers

Protocol and multimethods are complementary and intended for slightly different use cases.

  • Protocols provide efficient polymorphic dispatch based on the type of the first argument. Because the is able to exploit some very efficient JVM features, protocols give you the best performance.
  • Multimethods enable very flexible polymorphism which can dispatch based on any function of the method's arguments. Multimethods are slower but very flexible

In general, my advice is to use protocols unless you have a specific case that requires multimethods.

A case where you could require multimethods is something like the following:

(defn balance-available? [amount balance] (> balance amount))

(defmulti withdraw balance-available?)

(defmethod withdraw true [amount balance] 
  (- balance amount))

(defmethod withdraw false [amount balance] 
  (throw (Error. "Insufficient balance available!")))

Note that you can't use protocols here for both of the following reasons:

  • The dispatch function needs to use both arguments to determine which method implementation to use (i.e. it is a multiple dispatch case).
  • You also can't distinguish on the type of the first argument (which is presumably always a numeric value)
like image 176
mikera Avatar answered Nov 15 '22 20:11

mikera


Multimethods are more powerful and more expensive,

use protocols when they are sufficient but if you need to dispatch based on the phase of the moon as seen from mars then multimethods are your best choice.

Protocols exist to allow the simple stuff to stay simple and provide a way for clojure to generate very much the same bytecode that the equivalent java would. It seems that most people use protocols most of the time. I use multimethods when I need to dispatch on more than one argument, though I have to admit that this has only come up once, and full isa hierarchies are used even less often (by me). so in short use Multimethods when you need them

the best example In my expierence is right at the start, in core.clj

like image 44
Arthur Ulfeldt Avatar answered Nov 15 '22 22:11

Arthur Ulfeldt


As mention by Arthur, multimethods are more powerful and more expensive. Indeed, protocols can be thought of as a special case of mutlimethods where the dispatch function is class. Of course, this is not really the case as protocols are more than that.

If you need to dispatch on something other than the class of the first argument, you'll need to use a multimethod, or redesign. Dispatching on type is a good use case for protocols.

like image 6
M Smith Avatar answered Nov 15 '22 22:11

M Smith