Portar código de Common Lisp a Clojure

common-lisp (4)

¿Qué tan práctico es portar una aplicación Common Lisp a Clojure? Para ser más específico, ¿qué características existen en Common Lisp que no existen en Clojure y que deberían ser reescritas?

Hay una lista en clojure.org de las diferencias entre Clojure y otros Lisp. Algunas otras cosas que he notado al usar Clojure:

Idiomatic Clojure se inclina fuertemente hacia estructuras de datos inmutables. En cualquier lugar que vea SETF en CL, deberá cambiarse en Clojure para aprovechar al máximo. (Siempre tiene la opción de utilizar estructuras de datos Java mutables en Clojure, pero la mayoría de las personas no).
Los métodos multimétodos de Clojure son similares a los de CL (posiblemente más potentes, ya que puedes enviarlos a otras cosas que no sean de tipo), pero un CLOS completo no está disponible en Clojure. Clojure usa struct lugar, que es solo un hashmap sofisticado. El sistema OOP de Java también está disponible, por supuesto. Algunas personas están trabajando en portar CLOS a Clojure, pero no estoy seguro de qué tan avanzado están esos esfuerzos en este punto.
Las macros Clojure funcionan de forma ligeramente diferente que las macros CL cuando se trata de la resolución de símbolo / espacio de nombres. No estoy seguro si entiendo lo suficiente como para dilucidar las diferencias. Sin embargo, en Clojure no tienes que meterte con los gensimos tanto, lo cual es bueno.
Clojure no tiene un sistema de condición como CL''s. Solo tiene Java try / catch / finally para el manejo de excepciones.
Clojure no permite macros de lector definidas por el usuario.
Clojure no tiene múltiples valores de retorno. La desestructuración en Clojure es muy buena (admite listas, vectores, hash-maps, conjuntos, etc.) y está incorporada en más lugares que CL de forma predeterminada, por lo que este es un problema menor de lo que podría ser.

Dependiendo de la aplicación y de cómo esté escrita, puede ser práctico y sencillo pasar de CL a Clojure, o puede ser más práctico reescribirla desde cero de una manera más funcional y segura para subprocesos para ajustarse mejor con el estilo Clojure. .

Hay una serie de cuentas de la transición de CL a Clojure ( blog , otro blog , Thread on HN ).

El mayor problema que muchos de los Lispers comunes tienen con Clojure cuando lo comprueban es su falta de Optimización de Llamada de Cola , que no es posible en la JVM.

No tengo una respuesta específica, pero recomendaría estos recursos:

Charla de two part Rich Hickey Clojure para programadores Lisp
El work Stuart Halloway para traducir los ejemplos de Practic Common Lisp de Peter Seibel a Clojure.

Para el código CL idiomático es una reescritura.

CL es imperativo, Clojure es más puramente "funcional".
CL está orientado a objetos (CLOS), Clojure no (usa objetos Java y tiene algunos mecanismos OO)
Los identificadores y la sintaxis son en su mayoría diferentes.
Las estructuras de datos son diferentes.
CL es principalmente estricto (no perezoso), Clojure usa cálculo perezoso.

Incluso trasladar la infraestructura necesaria (CLOS, manejo de errores, flujos) a Clojure tiene poco sentido, ya que Clojure es realmente un lenguaje diferente con un estilo de programación diferente.

Si no se quiere reescribir el código, existe, por ejemplo, ABCL , que es un Common Lisp para la JVM.