4

Disclaimer

Despite the title, this is a genuine question, not an attempt at Emacs/Vi flamewars.

Context

I've used Haskell for a few months, and written a small ~10K LOC interpreter. In the past year, I've switched to Clojure. For quite a while, I struggled with Clojure's lack of types. Then I switched into using defrecords in Clojure, and now, switched to Clojure's defprotocols.

I really really like defprotocols. In fact, more than types.

I'm now at the point where for my Clojure functions, for it's documentation string, I just specify:

* the protocols of the inputs
* the protocols of the outputs

Using this, it appears I now have an ad-hoc type system (not compiler checked; but human checked).

Question

I suspect there's something about types that I'm missing. What does types provide over protocols?

Improve this question

3 Answers 3

Reset to default
3

Questioning the question...

Your question "What [do] types provide over protocols?" seems awkward to me. Types and protocols are perpendicular; They describe different things. Types/records define structure of data, while Protocols define the structure of some behavior or functionality. And part of why this question seems weird to me is that these things are not mutually exlusive! You can have types implement a protocol, thereby giving them whatever behaviour/functionality that protocol describes. In fact, since your context makes it clear that you have been using protocols, I have to wonder how you've been using them. My guess is that you've been using them with records (or possibly reifying them), but you could just as easily use protocols and (def)types together.

So to me, it seems you've compared apples with oranges here. To help clarify, let me compare apples to apples and oranges to oranges with a couple of different questions:

What problems do protocols solve, and what are the alternatives and their respective advantages/disadvantages?

Protocols let you define functions that operate in different ways on different types. The only other ways to do this are multimethods and simple function logic:

  • multimethods: have value in being extremely flexible. You can dispatch behavior on type by passing type as the dispatch function, but you can also use any other arbitrary function for dispatching.
  • internal function logic: You can also (of course) manually check for types in conditionals in your function definitions to decide how to process differently given different types. This is more primitive than multimethod dispatch, and also less extensible. Except in simple cases, multimethods are preferred.

Protocols have the advantage of being much more performant, being based on JVM class/method dispatch, which has been highly optimized. Additionally, protocols were designed to address the expression problem (great read), which makes them really powerful tools for crafting nice, modular, extensible APIs.

What are the advantages/disadvantages of (def)records or reify over (def)types?

On the side of how we specify the structure of data, we have a number of options available:

  • (def)records: produce a type good for "representing application domain information" (from http://clojure.org/datatypes; worth a read)
  • (def)types: produce a lighter weight type for creating "artifacts of the implementation/programming domain", such as the standard collection types
  • reify: construct a one-off object with an anonymous type implementing one or more protocols; good for... one-off things which need to implement a protocol(s)

Practically, records behave like clojure hash-maps, but have the added benefit of being able to implement protocols and have faster attribute lookup. Conveniently, the remain extensible via assoc, though attributes added in this fashion do not share the compiled lookup performance. This is what makes these constructs convenient for implementing applciation logic. Using deftype is advantageous for aspects of implementation/programming domain because they don't implement excess bagage, making the the use cleaner for these cases.

Improve this answer
Sign up to request clarification or add additional context in comments.

Comments

0

Protocols create interfaces and interfaces are a well, the interface to a type. they describe some aspects of a type though with much less rigor than you would come to expect in a language like Haskell.

Improve this answer

Comments

0
  • machine checking
  • type inference (you don't get some of your protocols generated from docs of others)
  • parametric polymorphism (parameterised protocols / protocols with generics don't exist)
  • higher order protocols (what is the protocol for a function that returns a protocol?)
  • automatic generation of code / boilerplate
  • inter-operation with automated tools
Improve this answer

2 Comments

protocols are already polymorphic. protocols support delegation so you can implement a protocol which returns something which does implement the protocol allowing you to compose protocols quite easily. Some of your other points are true and some of them are irrelevant in the context of a Lisp.
can you explain the polymorphism one? i've added "parametric" since in this context i think it's clear the idea is to be explicit, no? also, the "irrelevant to lisp" seems odd since the whole idea is to make something less like lisp / compare with other languages. will look at delegation, though - thanks.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.