Clojure 1.2 introduces two very remarkable features – Protocols and Datatypes. Clojure is defined in terms of abstractions and various implementations of those abstractions. For example, vectors, maps, lists, sets in Clojure implement the sequence abstraction which lets us treat any of those data structures as sequences.
Until recently it was not possible feasible to define and implement such core abstractions in Clojure itself; one had to drop down to Java (or C#) for those tasks, but not anymore 
Clojure 1.2 now has excellent facilities for defining and implementing similar abstractions in a highly dynamic manner while maintaining fantastic performance characteristics.
In this post, I will give you a brief overview of these new features and will show you how they are useful.
Protocols
Protocols in Clojure are similar to Java Interfaces, though not quite. Basically a protocol is a contract, a set of functionalities without any implementation. Let’s consider a simple protocol –
(defprotocol Fly
"A simple protocol for flying"
(fly [this] "Method to fly"))
So here we have a trivial protocol Fly which declares a method fly which takes one argument ‘this’ (which is actually the type implementing the protocol itself). In case of all methods defined via Protocols, the first argument is always the implementing type itself. The name ‘this’ is just a convention; it could be ‘self’, etc. or anything.
When we declared the Fly protocol, two new vars were created. One is ‘Fly’, the protocol itself, and the other is ‘fly’ which is a polymorphic function that will get called when we execute it on an implementation of Fly.
Right now, if you try to execute the method ‘fly’ on any object, you will get an exception because no types are implementing that protocol yet, which brings us to the next topic, DataTypes.
DataTypes
Traditionally in Clojure whenever we wanted to have some kind of record or a property-only Class, we used maps or struct-maps. Those serve the purpose perfectly well in most cases but the problem was that those maps didn’t have any type information attached to them. As a result, we had to put some extra keys in maps to help us determine the type of a record before we could dispatch methods. There were some obvious performance limitations too; being vanilla maps, they were never as fast as Plain Old Java Objects (POJOs). Enter deftype and its cousin defrecord.
In Clojure 1.2 we can define our own types using defrecord like this -
(defrecord Bird [nom species])
Boom! We have a custom type, Bird with two fields, name and species. We can now instantiate a Bird like this -
(def crow (Bird. "Crow" "Corvus corax"))
We can access the fields of the Bird instance by treating it like
a normal map -
user› (:species crow)
"Corvus corax"
We can also add/remove/modify keys in a record like we would do with a
normal map.
(def sparrow (assoc crow :nom "Sparrow" :species "Passer domesticus"))
This will create a new immutable instance of Bird with different data. Note that since Clojure records are persistent and immutable, the original crow instance is not affected.
Now to make the Bird fly. We already have a protocol called Fly. We need to implement the protocol so that our birds can actually fly. One way to do that is to put the protocol implementation inline with the record definition itself -
(defrecord Bird [nom species]
Fly
(fly [this] (str (:nom this) " flies..."))
So easy, right? If we now create another instance of Bird, it will actually be able to fly -
user› (def kiwi (Bird. "Kiwi" "Apteryx australis"))
#'user/kiwi
user› (fly kiwi)
"Kiwi flies..."
Great! But what happens to the Crow, and Sparrow? We created those instances when the Bird record didn’t have any implementation of the Fly protocol. You might face similar issues when you don’t have control over the code which defines the record/class. You will need to extend those types dynamically with implementation of a protocol. Enter extend-type. extend-type (and its cousin extend-protocol) allows us to implement protocols on pre-existing types. Consider the following example -
(defprotocol Walk
"A simple protocol to make birds walk"
(walk [this] "Birds want to walk too!"))
(extend-type Bird
Walk
(walk [this] (str (:nom this) " walks too..."))
We just added an implementation of the Walk protocol to the existing type Bird. All new Bird instances created from now on will be able to Walk and Fly.
user› (def hummingbird (Bird. "Hummingbird" "Selasphorus rufus"))
user› (fly hummingbird)
"Hummingbird flies..."
user› (walk hummingbird)
"Hummingbird walks too..."
Cool, right? At times you might require a anonymous object which implements some protocol or interface. You could utilise those objects in cases where you just need an object which implements a given protocol but you don’t care about its type. Clojure 1.2 gives you reify. reify allows us to create one-off anonymous objects which implement one or more protocols.
user› (fly (reify Fly (fly [_] "Swine flu...")))
"Swine flu..."
Woah! Clojure can make Pigs fly Jokes apart, what we just did was very interesting. We just created an anonymous type which implements the Fly protocol and called the fly method on it; and it flu[sic]
We could implement multiple protocols in the same reify statement too,
like this -
(def pig (reify
Fly (fly [_] "Swine flu...")
Walk (walk [_] "Pig-man walking...")))
user› (fly pig)
"Swine flu..."
user› (walk pig)
"Pig-man walking..."Beautiful. reify is quite similar to proxy and it is now recommended to use reify instead of proxy wherever possible because reify is much faster than proxy.
Before I finish off, let me explain the differences between defrecord and deftype. defrecord creates a new type and implements a few core Clojure interfaces like that of the persistent map, hashcode, keyword accessors, etc. If you are using deftype, Clojure will not implicitly implement any interface not provided by the user. In short, if you are using deftype, you will have to implement your own accessors, hashcode, etc. In most cases defrecord should suffice, but in other cases like when you need mutable fields, use deftype.
There is some in-depth explanation of Protocols and Datatypes on the Clojure website which you should consult if you need more information.
Bonus Material
Making Java Strings fly and walk
user› (extend-type java.lang.String
Fly (fly [this] "See me fly?")
Walk (walk [this] "Yes, that's me walking!"))
nil
user› (walk "foo")
"Yes, that's me walking!"
user› (fly "bar")
"See me fly?"PS – I wrote this today because I was sitting at home, sick. There are possibly some mistakes in this post; in which case, please let me know.
