Are they intended to do the same thing as Structural Types in Scala? What benefits do Protocols have over Structural Types (performance, flexibility, code clarity, etc.)? Are they implemented through reflections?

Questions on interoperability with Scala: Can Protocols be used instead of Structural Types in Scala? Can they be extended (if 'extension' term can be applied to Protocols) in Scala?

About the first bullet, aren't type classes from Haskell closer to implicits in Scala?
–
axel22Dec 22 '10 at 10:22

My understanding is that implicits and traits are Scala alternative to Type Classes (especially, when it comes to pimping of an existing functionality). But what can be achieved with Structural Types (and Protocols, I assume) is passing the instance of an existing type that you cannot (or don't want to) change to the API that just expects the passed object to have a special method to call: def call(c:{ def call():Unit }) = c.call()
–
Vasil RemeniukDec 22 '10 at 10:46

4 Answers
4

Scala is a statically typed language. Clojure is a dynamically typed language. This difference shapes both of them fundamentally.

Structural types are static types, period. They're just a way to have the compiler prove statically that an object will have a particular structure (I say prove here, but casting can cause bogus proofs as always).

Protocols in Clojure are a way to create dynamic dispatch that is much faster than reflection or looking things up in a map. In a semantic sense they don't really extend the capabilities of Clojure, but operationally they are significantly faster than the mechanisms used before.

Scala traits are a bit closer to protocols, as are Java interfaces, but again there's a static vs dynamic issue. Scala traits must be associated with a class at compile time, similar to Java interfaces. Clojure protocols can be added to a datatype at runtime after the fact even by a third party.

Although Clojure protocols can be extended at runtime, they are statically typed in the sense that the compiler will produce a statically typed function call based on the type of the first argument (or do a single interface cast if the type is not known / cannot be inferred). This is one of the reasons protocols are very fast compared to multimethods (the fully dynamic equivalent).
–
mikeraJan 25 '12 at 0:36

As I understood from this introductory blogpost, Closure Protocols are closer to Scala Traits, rather than Structural Types (and thus, cannot be used as a replacement for them, answering my second question):

No - protocols are compiled to JVM interfaces. Things which implement protocols (reify, defrecord, etc) are compiled to JVM classes which implement the protocol interface, so calls to protocol functions are the same as standard JVM method calls, under the hood.

That was actually one of the motivators for protocols - a lot of Clojure's internal data structures were written in Java, for speed reasons, because there was no way to do full-speed polymorphic dispatch in pure Clojure. Protocols provide that. Clojure still has a lot of Java in its source code, but that could all can now be rewritten in Clojure with no loss of performance.

So, although the answers above are emphasizing that the two things are different because one (in Clojure) is dynamic typing, but the other (in Scala) is static-typing (James Iry), but still they both correspond to underlying Java interfaces under the hood. So, indeed, they are similar, and even conceptually.
–
imz -- Ivan ZakharyaschevJan 30 '11 at 9:28

BTW, the border between static and dynamic typing is not that strict. And Java was intentionally designed to look, from one side, as a statically typed language like C++, but from another side, to look like Smalltalk (dynamically typed). How is Java similar to dynamically-typed Smalltalk? Define sufficiently many interfaces (one for each method you employ) and you are almost there: whether you can call a method (= "send a specific message") to an object must not be related with whether it inherits some pieces of implementation from a suitable superclass.
–
imz -- Ivan ZakharyaschevJan 30 '11 at 9:35

That programming style in Java (many interfaces to model the feel of Smalltalk)--although conceptually nice--required too much typing though. Scala language makes this style of programing for JVM elegant also on the surface by making these language's contructions short and readable!
–
imz -- Ivan ZakharyaschevJan 30 '11 at 9:38