Clojure

Clojure
Desarrollador(es)
http://clojure.org
Información general
Paradigma	Funcional, Lenguaje de programación multiparadigma
Apareció en	2007
Diseñado por	Rich Hickey
Última versión estable	(2011-09-23)
Tipo de dato	dinámico, fuerte
Influido por	Lisp, ML, Haskell, Erlang[1]
Sistema operativo	Multiplataforma
Licencia	Eclipse Public License

Clojure (se pronuncia kloshur) es un dialecto del lenguaje de programacion Lisp. Es un lenguaje de propósito general que ofrece un estilo de programación interactiva y que incentiva una forma de programar funcional, simplificando así la programación concurrente. Clojure puede ser ejecutado sobre la Maquina Virtual Java y la máquina virtual de la plataforma .Net de Microsoft. Clojure se adhiere al principio de "codigo igual a datos" y tiene un sofisticado sistema de macros.

Principios

Rich Hickey desarrolló Clojure porque buscaba un Lisp moderno para una programación funcional actualizada, en simbiosis con la ya asentada Plataforma Java y diseñado especialmente para favorecer la programación concurrente.^[2]

Sintaxis

Como el resto de la familia Lisp, la sintaxis de Clojure está construida sobre expresiones simbólicas que son convertidas en estructuras de datos por un "lector" antes de ser compiladas. Las expresiones se caracterizan por empezar y acabar con paréntesis y por la notación prefija por la que el símbolo que representa la función a evaluar siempre va en primer lugar (no hay operadores). Esta peculiaridad, extraña para los habituados a los lenguajes más populares basados en la sintaxis del lenguaje de programación c es la base misma de su gran flexibilidad. El lector de Clojure admite notación especifica para mapas, sets y vectores, además de listas y todos ellos se proporcionan al compilador tal cual. Dicho de otra manera: el compilador de Clojure no sólo compila listas como suele ser habitual en Lisp, sino que soporta todos los tipos mencionados directamente. Clojure es un Lisp-1 y no se supone que tenga que ser compatible con otros dialectos del Lisp.

Macros

El sistema de macros de Clojure es muy similar al de Common Lisp con la excepción de que la versión de Clojure de la comilla inversa (llamada "comilla sintáctica") cualifica los símbolos con el espacio de nombres al que pertenece. Así se ayuda a prevenir la captura no intencionada ya que enlazar con nombres cualificados está prohibida. Es posible forzar la expansión de una macro que las capture pero debe hacerse explícitamente. Clojure prohíbe también re-enlazar nombre globales en otros espacios de nombres que hayan sido importados en el actual.

Características del lenguaje

• Desarrollo dinámico con una consola de evaluación (en ingles REPL de "read-eval-print loop").
• Las funciones son objetos de primera clase en el lenguaje y se enfatiza la recursion en lugar de la iteracion basada en efectos secundarios.
• Secuencias con evaluación perezosa (los elementos de la secuencia no se computan hasta que son necesarios lo que permite representar conjuntos infinitos en potencia).
• Proporciona un rico conjunto de estructuras de datos persistentes e inmutables.
• Control de la concurrencia a través de una "memoria transaccional por software", un sistema de agentes y un sistema de variables dinámico.
• Clojure es un lenguaje compilado que produce bytecode de la JVM.
• Estrecha integración con java: al compilarse en bytecode de la JVM, las aplicaciones escritas en Clojure pueden ser fácilmente empaquetadas y desplegadas en servidores de aplicaciones y JVMs sin ninguna complejidad adicional. Todas las estructuras de datos de Clojure implementan interfaces de Java, lo que facilita ejecutar código implementado en Clojure desde Java.

Ejemplos

Hola mundo:

(println "Hola, mundo!")

Un generador de números únicos y consecutivos que soporta llamadas concurrentes:

(let [i (atom 0)]
  (defn generar-id-unica
    "Devuelve un identificador numérico distinto para cada llamada."
    []
    (swap! i inc)))

Una subclase anónima de java.io.Writer que no escribe en ningún sitio y una macro que lo usa para silenciar todas las expresiones evaluadas con ella.

(def bit-bucket-writer
  (proxy [java.io.Writer] []
    (write [buf] nil)
    (close []    nil)
    (flush []    nil)))
 
(defmacro noprint
  "Evalua la expresiones dadas con todas las impresiones a *out* silenciadas."  
  [& forms]
  `(binding [*out* bit-bucket-writer]
     ~@forms))
 
(noprint
 (println "Hello, nobody!"))

En este ejemplo diez hilos manipulan una estructura de datos compartida, que consiste en cien vectores que contienen diez números únicos al inicio secuenciales. Cada hilo elige dos posiciones aleatorias en dos vectores aleatorios y los intercambia. Todos los cambios en los vectores se hacen dentro de transacciones usando el sistema de memoria transaccional por software de Clojure. Es por eso que incluso después de mil iteraciones no se pierde ningún numero.

(defn run [nvecs nitems nthreads niters]
  (let [vec-refs (vec (map (comp ref vec)
                           (partition nitems (range (* nvecs nitems)))))
        swap #(let [v1 (rand-int nvecs)
                    v2 (rand-int nvecs)
                    i1 (rand-int nitems)
                    i2 (rand-int nitems)]
                (dosync
                 (let [temp (nth @(vec-refs v1) i1)]
                   (alter (vec-refs v1) assoc i1 (nth @(vec-refs v2) i2))
                   (alter (vec-refs v2) assoc i2 temp))))
        report #(do
                 (prn (map deref vec-refs))
                 (println "Distinct:"
                          (count (distinct (apply concat (map deref vec-refs))))))]
    (report)
    (dorun (apply pcalls (repeat nthreads #(dotimes [_ niters] (swap)))))
    (report)))
 
(run 100 10 10 100000)

Salida del ejemplo anterior:

([0 1 2 3 4 5 6 7 8 9] [10 11 12 13 14 15 16 17 18 19] ...
 [990 991 992 993 994 995 996 997 998 999])
Distinct: 1000
 
([382 318 466 963 619 22 21 273 45 596] [808 639 804 471 394 904 952 75 289 778] ...
 [484 216 622 139 651 592 379 228 242 355])
Distinct: 1000

Bibliografía

• Halloway, Stuart (May 28, 2009), Programming Clojure (1st edición), Pragmatic Bookshelf, pp. 304, ISBN 1934356336, http://pragprog.com/titles/shcloj/programming-clojure 
• VanderHart, Luke (December 31, 2009), Practical Clojure (1st edición), Apress, pp. 350, ISBN 1430272317, http://www.apress.com/book/view/9781430272311 
• Rathore, Amit (December 2009), Clojure in Action (1st edición), Manning, pp. 475, ISBN 9781935182597, http://www.manning.com/rathore/ 
• Fogus, Michael; Houser, Chris (January 2010), The Joy of Clojure (1st edición), Manning, pp. 300, ISBN 9781935182641, http://www.manning.com/fogus/ 

Enlaces externos

• Pagina principal Clojure
• Repositorio del código de Clojure en GitHub
• Una visión general sobre Clojure
• Tutoriales en vídeo

References