Протоколы Clojure против структурных типов Scala

Совершенно не связаны.

Scala - это язык со статической типизацией. Clojure - это язык с динамической типизацией. Эта разница в корне формирует их обоих.

Структурные типы - статические типы, период. Это просто способ заставить компилятор статически доказать, что объект будет иметь определенную структуру (здесь я говорю «доказать», но приведение типов, как всегда, может привести к ложным доказательствам).

Протоколы в Clojure - это способ создания динамической диспетчеризации, который намного быстрее, чем отражение или поиск вещей на карте. В семантическом смысле они на самом деле не расширяют возможности Clojure, но с точки зрения работы они значительно быстрее, чем механизмы, которые использовались ранее.

Черты Scala немного ближе к протоколам, как и интерфейсы Java, но опять же существует проблема статики и динамики. Черты Scala должны быть связаны с классом во время компиляции, подобно интерфейсам Java. Протоколы Clojure могут быть добавлены к типу данных во время выполнения постфактум даже третьей стороной.

Что-то вроде протоколов Clojure возможно в Java и Scala с помощью таких механизмов, как шаблоны оболочки / прокси или динамические прокси (http://download.oracle.com/javase/1.4.2/docs/guide/reflection/proxy.html). Но они будут намного более неуклюжими, чем протоколы Clojure, и получить правильную идентификацию объекта также сложно.

Цель протоколов в Clojure - эффективное решение проблемы выражения.

[См .: Простое объяснение протоколов закрытия.]

Решение проблемы выражения в Scala - неявное. Итак, семантически this является ближайшим эквивалентом Clojure Protocols в Scala. (В Haskell это будут классы типов или, возможно, семейства типов.)

Как я понял из этого вводного сообщения в блоге, Протоколы закрытия ближе к Scala Traits, чем к структурным типам (и, таким образом, не могут использоваться в качестве их замены, отвечая на мой второй вопрос):

/* ----------------------- */
/* --- Protocol definition */
/* ----------------------- */

(defprotocol Fly
  "A simple protocol for flying"
  (fly [this] "Method to fly"))

/* --- In Scala */    
trait Fly{
    def fly: String
}

/* --------------------------- */
/* --- Protocol implementation */
/* --------------------------- */

(defrecord Bird [nom species]
  Fly
  (fly [this] (str (:nom this) " flies..."))

/* --- In Scala */    
case class Bird(nom: String, species: String) extends Fly{
    def fly = "%s flies..." format(nom)
}

/* --------------------- */
/* --- Dynamic extension */
/* --------------------- */

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

/* --- In Scala */    
trait Walk{
    def walk = "Birds want to walk too!"
}

implicit def WalkingBird(bird: Bird) = new Walk{
    override def walk = "%s walks too..." format(bird.nom)
}

/* --------------- */
/* --- Reification */
/* --------------- */

(def pig (reify
                Fly (fly [_] "Swine flu...")
                Walk (walk [_] "Pig-man walking...")))

/* --- In Scala */    
object pig extends Fly with Walk{
    def fly = "Swine flu..."
    override def walk = "Pig-man walking..."
}

Другие ответы лучше отражают другие части вашего вопроса, но:

Реализуются ли они через отражения?

Нет - протоколы компилируются в интерфейсы JVM. Вещи, которые реализуют протоколы (reify, defrecord и т. Д.), Скомпилированы в классы JVM, которые реализуют интерфейс протокола, поэтому вызовы функций протокола такие же, как и стандартные вызовы методов JVM под капотом.

Фактически это было одним из мотивов создания протоколов - многие внутренние структуры данных Clojure были написаны на Java из соображений скорости, потому что не было возможности выполнить полиморфную отправку на полной скорости в чистом Clojure. Протоколы это обеспечивают. В исходном коде Clojure по-прежнему много Java, но теперь все это можно переписать на Clojure без потери производительности.