Primeros pasos con Clojure, parte 6

 

Seguimos con Clojure... 

Antes de empezar a hablar del Relp de Clojure, tenemos que saber un aspecto importante del Relp es que Clojure siempre compila la expresión antes de ejecutarla; Clojure siempre se compila en bytecode de JVM. No hay intérprete de Clojure.

El Relp de Clojure esta recopado, trae como unos trucos, que nos hacen la vida más fácil. Por ejemplo, algunos símbolos especiales recuerdan los resultados de evaluar las últimas tres expresiones:

• * 1 (el último resultado)
• * 2 (el resultado hace dos expresiones)
• * 3 (el resultado hace tres expresiones)

Veamoslo en acción : 

user=> (+ 3 4)

7

user=> (+ 10 *1)

17

user=> (+ *1 *2)

24

Podemos llamar al espacio de nombres clojure.repl que se incluye en la biblioteca estándar de Clojure que proporciona una serie de funciones útiles. Para cargar esa biblioteca y hacer que sus funciones estén disponibles en nuestro contexto actual, debemos escribir :

user=> (require '[clojure.repl :refer :all])

nil

Ahora tenemos acceso a algunas funciones adicionales que son útiles en REPL: doc, find-doc, apropos, source y dir.

La función doc muestra la documentación de cualquier función. Veamos un ejemplo :

user=> (doc +)

-------------------------

clojure.core/+

([] [x] [x y] [x y & more])

  Returns the sum of nums. (+) returns 0. Does not auto-promote

  longs, will throw on overflow. See also: +'

nil

La función doc imprime la documentación para +, incluidas las firmas válidas.

La función doc imprime la documentación, luego devuelve nil como resultado; verá ambos en la salida de evaluación.

También podemos invocar doc sobre sí mismo:

user=> (doc doc)

-------------------------

clojure.repl/doc

([name])

Macro

  Prints documentation for a var or special form given its name,

   or for a spec if given a keyword

nil

Si no estamos seguros de cómo se llama algo podemos usar el comando apropos para buscar funciones que coincidan con una cadena o expresión regular en particular.

user=> (apropos "+")

(clj-stacktrace.repl/pst+ clojure.core/+ clojure.core/+' clojure.core/read+string clojure.spec.alpha/+ clojure.spec.alpha/rep+impl net.cgrand.parsley.grammar/->Repeat+ net.cgrand.parsley.grammar/map->Repeat+ net.cgrand.regex/+ net.cgrand.regex.charset/+)

También puede ampliar la búsqueda para incluir las cadenas de documentos en sí mismas con find-doc:

user=> (find-doc "trim")

-------------------------

clojure.pprint/ltrim

([s c])

  Trim all instances of c from the beginning of sequence s

-------------------------

clojure.pprint/rtrim

([s c])

  Trim all instances of c from the end of sequence s

-------------------------

clj-stacktrace.core/parse-cause-exception

([causer-e caused-parsed-elems])

  Like parse-exception, but for causing exceptions. The returned map has all

  of the same keys as the map returned by parse-exception, and one added one:

  :trimmed-elems  A subset of :trace-elems representing the portion of the

                  top of the stacktrace not shared with that of the caused

                  exception.

-------------------------

clj-stacktrace.core/trim-redundant

([causer-parsed-elems caused-parsed-elems])

  Returns the portion of the tail of causer-elems that is not duplicated in

  the tail of caused-elems. This corresponds to the "...26 more" that you

  see at the bottom of regular trace dumps.

-------------------------

leiningen.core.utils/git-file-contents

([git-dir ref-path])

  Returns the (trimmed) contents by the given git path, or nil if it is

  inacessible or nonexisting. If it exists and is not readable, a warning is

  printed.

-------------------------

clojure.string/trim

([s])

  Removes whitespace from both ends of string.

-------------------------

clojure.string/trim-newline

([s])

  Removes all trailing newline \n or return \r characters from

  string.  Similar to Perl's chomp.

-------------------------

clojure.string/triml

([s])

  Removes whitespace from the left side of string.

-------------------------

clojure.string/trimr

([s])

  Removes whitespace from the right side of string.

-------------------------

clojure.core/read+string

([] [stream] [stream eof-error? eof-value] [stream eof-error? eof-value recursive?] [opts stream])

  Like read, and taking the same args. stream must be a LineNumberingPushbackReader.

  Returns a vector containing the object read and the (whitespace-trimmed) string read.

-------------------------

clojure.core/subvec

([v start] [v start end])

  Returns a persistent vector of the items in vector from

  start (inclusive) to end (exclusive).  If end is not supplied,

  defaults to (count vector). This operation is O(1) and very fast, as

  the resulting vector shares structure with the original and no

  trimming is done.

nil

Si desea ver lla lista completa de las funciones en un espacio de nombres en particular, puede usar la función dir. Aquí podemos usarlo en el espacio de nombres clojure.repl:

user=> (dir clojure.repl)

apropos

demunge

dir

dir-fn

doc

find-doc

pst

root-cause

set-break-handler!

source

source-fn

stack-element-str

thread-stopper

nil

Y finalmente, podemos ver no solo la documentación sino el código fuente subyacente de cualquier función accesible por el tiempo de ejecución:

user=> (source dir)

(defmacro dir

  "Prints a sorted directory of public vars in a namespace"

  [nsname]

  `(doseq [v# (dir-fn '~nsname)]

     (println v#)))

nil

Donde anda Clojure?

Clojure es un lenguaje de programación de propósito general dialecto de Lisp. Hace un énfasis especial en el paradigma funcional, con el objetivo de eliminar la complejidad asociada a la programación concurrente. Clojure puede ser ejecutado sobre la Máquina Virtual de Java. Por si no lo conocían. 

Hace mucho que no escribo sobre Clojure, por lo tanto estuve googleando a ver a donde anda... 

Y me encontré que su ecosistema ha crecido bastante, no muy rápido pero a paso seguro. 

Si no lo sabían, podemos crear nuestras aplicaciones Clojure en Leiningen que sería el maven de Clojure. 

A la vez podemos utilizar Datomic para guardar datos en la base de datos nosql, hecha en Clojure... 

Si les gusta Lisp, les va a encantar Clojure. 

Para empezar podemos utilizar un entorno online. Uno que esta bueno es jdoodle que se encuentra en : https://www.jdoodle.com/execute-clojure-online/

Veamos un pequeño ejemplito : 

(ns clojure.examples.hello

(:gen-class))

(defn sum-of-numbers [x y]

(println (format "x + y = %d" (+ x y))))

(sum-of-numbers 10 25)

Y esto retornará : x + y = 35

Dejo links : https://clojure.org/

https://www.datomic.com/

https://steemit.com/utopian-io/@laxam/programming-in-clojure-part-1-why-clojure

Corre Clojure en .net con ClojureCLR

Supongamos que queremos programar en .net y con Clojure. Y se puede! con ClojureCLR. 

Primero debemos instalarlo, utilizando una terminal con el siguiente comando: 

dotnet tool install --global --version 1.10.0-beta1 Clojure.Main

Hoy estoy en powershell, sería algo así  : 

PS C:\dotnet> dotnet tool install --global --version 1.10.0-beta1 Clojure.Main                                          

You can invoke the tool using the following command: Clojure.Main

Tool 'clojure.main' (version '1.10.0-beta1') was successfully installed.

Y luego, escribimos  Clojure.Main en la terminal y podemos acceder al RELP : 

PS C:\dotnet> Clojure.Main

Clojure 1.10.0-beta1

user=> (defn mayor [L]

  (cond

        (empty? (rest L)) (first L)

        (> (first L) (mayor (rest L))) (first L)

        :else (mayor (rest L))

  )

)

#'user/mayor

user=> (mayor '(1 2 3 50 40))

50

Dejo link :  https://github.com/clojure/clojure-clr

Clojure

Clojure es Lisp en JVM. Es decir entendiendo Clojure entenderemos List, y entendiendo List entenderemos Clojure. Después de Fortran, List es el lenguaje más viejo. List es un lenguaje funcional pero no es un lenguaje puramente funcional.

Una de las más importantes características de Clojure es que corre en la JVM.

Deben bajar la consola para Clojure de http://clojure.org/ y empecemos haciendo un Hola Mundo!

user=> (println "Hola Mundo!")
Hola Mundo!
nil


Veamos llamadas a funciones:

user=> (- 1)
-1
user=> (+ 1 1)
2
user=> (* 10 10)
100
user=> (mod 5 4)
1
user=> (/ (/ 12 2) (/ 6 2))
2
user=> (+ 2 2 2 2)
8
user=> (- 8 1 2)
5
user=> (/ 8 2 2)
2
user=> (+ 3.0 5)
8.0
user=> (+ 3 5.0)
8.0

Clojure maneja los tipos de java:

user=> (class true)
java.lang.Boolean
user=> (class (= 1 1))
java.lang.Boolean

Podemos usar el condicional:

user=> (if true (println "True it is."))
True it is.
nil
user=> (if false (println "true") (println "false"))
false
nil

Veamos las listas:
user=> (list 1 2 3)
(1 2 3)
user=> '(1 2 3)
(1 2 3)

vectores:
user=> [:hutt :wookie :ewok]
[:hutt :wookie :ewok]

Mapas:
user=> {:chewie :wookie :lea :human}
{:chewie :wookie, :lea :human}

Definir funciones:
user=> (defn force-it [] (str "Use the force," "Luke."))
#'user/force-it
y usarla:
user=> (force-it)
"Use the force,Luke."

Este es un pequeño y humilde paseo por Clojure, si deben aplicar programación funcional en una aplicación Java es la herramienta justa.

Dejo links:
http://clojure.org/

MiniKanren

Si hablamos de programación lógica siempre pensamos en Prolog. Pero existen otros lengujes lógicos, como  MiniKanren que es un lenguaje embebido en Clojure.

miniKanren es un DSL (Domain Specific Language) para la programación logica.

miniKanren es muy simple, con sólo tres operadores lógicos y un operador de interfaz.

La primera implementación fue en scheme, pero ahora existen implementaciones en diferentes lenguajes y tecnologías como Racket, Clojure, Haskell, Python, JavaScript, Scala, Ruby, OCaml, PHP y algunos más.

De igual manera que prolog, esta centrado en reglas y constraits.

En este post vamos a utilizar la implementación de Clojure, MiniKanren se encuentra en core.logic, para poder usarlo debemos tener una jdk y Leiningen.

Para crear un proyecto debemos utilizar Leiningen de la siguiente manera:

lein new logical

Con esta instrucción podemos crear un proyecto.

Ahora debemos agregar las dependencias:

(defproject logical "0.1.0-SNAPSHOT"
          :dependencies [[org.clojure/clojure "1.5.1"]
          [org.clojure/core.logic "0.8.5"]])

core.logic es donde se encuentra MiniKanren.

Ahora cuando lancemos el relp se levantará miniKanren:

$ lein repl
nREPL server started on port 48235 on host 127.0.0.1
REPL-y 0.3.0
Clojure 1.5.1
Docs: (doc function-name-here)
(find-doc "part-of-name-here")
Source: (source function-name-here)
Javadoc: (javadoc java-object-or-class-here)
Exit: Control+D or (exit) or (quit)
Results: Stored in vars *1, *2, *3, an exception in *e
user=> (use 'clojure.core.logic)
WARNING: == already refers to: #'clojure.core/== in namespace: user, being
replaced by: #'clojure.core.logic/==
nil
user=>

Ahora podemos empezar con el relp de MiniKanren, veamos un ejemplo :

user=> (run* [q] (== q 1))
(1)

En el ejemplo corremos el programa con run* que permite correr programas logicos y retorna un conjunto de soluciones.  q es una variable logica. Y el programa contiene la siguiente expresión :
 (== q 1)

Dicha expresión es unification, que se puede ver como pattern matching. Este programa devuelve 1 dado que q va valer 1 para que esto sea verdadero.

Le está pidiendo al lenguaje que intente hacer que los lados izquierdo y derecho sean iguales, suponiendo que eso sea posible. Los lados izquierdo y derecho se comparan como en las pruebas de igualdad normales, y cualquier variable lógica no vinculada está vinculada a valores que harían coincidir los dos lados. En este ejemplo, q está vinculado a 1, que es una solución porque no hay otras reglas.

Las expresiones en un programa lógico son objetivos. No devuelven verdadero o falso, pero tienen éxito o fracasan. Es posible que el éxito se logre varias veces de diferentes maneras o en absoluto. Esto nos lleva al último bit de nuestro ejemplo: el resultado.

Nuestro ejemplo devuelto (1). run * devuelve los valores de q que resultan en éxito.

En nuestro ejemplo, unificar q con 1 une q al número 1 y tiene éxito. Nuestro resultado es la lista que contiene el enlace único para q.

Veamos un objetivo fallido:

user=> (run* [q] (== q 1) (== q 2))
()

Este programa tiene dos expresiones, cada una un objetivo. Un programa con múltiples objetivos tendrá éxito solo si todos los objetivos tienen éxito, de manera similar a && u operadores en otros lenguajes. Aquí, la primera unificación unirá q al número 1 como antes y tendrá éxito. La segunda unificación fallará, ya que q está unido a 1 y 1 no se unifica con 2. Debido a que ningún enlace de q puede hacer que ambos objetivos tengan éxito, la lista resultante está vacía. Es decir, no hay solución. 

En proximos post seguiremos con este particular lenguaje,  por ahora dejo link: http://minikanren.org/

Clojure y Android un solo corazón

Clojure nos permite hacer muchas cosas entre otras nos permite programar en Android,con la extensión clojure-android. ¿Pero cuáles son las características que nos ofrece Clojure en comparación con Java para el desarrollo de aplicaciones móviles?

• Un lenguaje Funcional moderno
• Desarrollo orientado a REPL
• La lógica, UI, datos todos en un solo lenguaje.
• Clojure puede utilizar todo la plataforma Android, por su interoperabilidad con Java. 

También Clojure ofrece un plugin para Leiningen para crear, compilar, correr los test de proyectos Android con clojure. Lein-droid.

Dejo link:
http://clojure-android.info
https://github.com/clojure-android/lein-droid/wiki/Tutorial

Concurrencia en Clojure

Clojure proporciona un estilo híbrido de programación funcional y estado mutable para resolver problemas de forma concurrente; el "Clojure Way" aprovecha las fortalezas de ambos para brindar un enfoque particularmente poderoso para la programación concurrente.

Si bien la programación funcional funciona increíblemente bien para algunos problemas, algunos tienen la modificación del estado como un elemento fundamental de la solución. Aunque puede ser posible crear una solución funcional a tales problemas, es más fácil pensar en ellos de una manera más tradicional. 

Un lenguaje funcional puro no proporciona soporte para datos mutables en absoluto. Clojure, por el contrario, es impuro: proporciona varios tipos diferentes de variables mutables conscientes de la concurrencia, cada una de las cuales es adecuada para diferentes casos de uso. Estos, en conjunto con las estructuras de datos persistentes de Clojure (vamos a cubriremos lo que significa persistente en este contexto más adelante) nos permiten evitar muchos de los problemas que tradicionalmente afligen a los programas concurrentes con estado mutable compartido.

La diferencia entre un lenguaje funcional impuro y un lenguaje imperativo es de énfasis. En un lenguaje imperativo, las variables son mutables por defecto y el código idiomático las modifica con frecuencia. En un lenguaje funcional impuro, las variables son inmutables por defecto y el código idiomático modifica aquellas que no lo son solo cuando es absolutamente necesario. Como veremos, las variables mutables de Clojure nos permiten manejar los efectos secundarios del mundo real sin dejar de ser seguros y consistentes.

Veremos cómo las variables mutables de Clojure funcionan en conjunto con las estructuras de datos persistentes para separar la identidad del estado. Esto permite que varios subprocesos accedan a variables mutables simultáneamente sin bloqueos (y el peligro asociado de interbloqueo) y sin ninguno de los problemas de estado mutable escapado u oculto. Comenzaremos por lo que podría decirse que es el más simple de los tipos de variables mutables de Clojure, el átomo.

Un átomo es una variable atómica  (los átomos de Clojure están construidos sobre java.util.concurrent.atomic). A continuación, se muestra un ejemplo de cómo crear y recuperar el valor de un átomo:

user=> (def my-atom (atom 42))

#'user/my-atom

user=> (deref my-atom)

42

user=> @my-atom

42

Un átomo se crea con átomo, que toma un valor inicial. Podemos encontrar el valor actual de un átomo con deref o @.

Si desea actualizar un átomo a un nuevo valor, se usa swap !:

user=> (swap! my-atom inc)

43

user=> @my-atom

43

Esto toma una función y le pasa el valor actual del átomo. El nuevo valor del átomo se convierte en el valor de retorno de la función. También podemos pasar argumentos adicionales a la función, como en este ejemplo:

user=> (swap! my-atom + 2)

45

El primer argumento pasado a la función será el valor actual del átomo, y luego cualquier argumento adicional dado para intercambiar. Entonces, en este caso, el nuevo valor se convierte en el resultado de (+ 43 2).

En raras ocasiones, es posible que desee establecer un átomo en un valor que no dependa de su valor actual, en cuyo caso puede usar reset !:

user=> (reset! my-atom 0)

0

user=> @my-atom

0

Los átomos pueden ser de cualquier tipo; muchas aplicaciones web utilizan un mapa atómico para almacenar datos de sesión, como en este ejemplo:

user=> (def session (atom {}))

#'user/session

user=> (swap! session assoc :username "paul")

{:username "paul"}

user=> (swap! session assoc :session-id 1234)

{:session-id 1234, :username "paul"}

Ya se que no vimos nada de concurrencia aun, pero paciencia, como me queda largo el post seguimos en otro... 

Primeros pasos con Clojure, parte 3

Seguimos con Clojure...

Como funcióna o lee las expresiones Clojure? 

En Java, el código fuente (archivos .java) se lee como caracteres por el compilador (javac), que produce código de bytes (archivos .class) que la JVM puede cargar. Es decir un proceso tipico de compilación, se lee y compila el archivo fuente y produce bytecode que corre sobre la JVM. Sería algo así : 

En Clojure, se lee el código fuente como caracteres y esto se puede de leer desde un archivo  .clj o recibir una serie de expresiones de forma interactiva. El lector produce datos de Clojure. El compilador de Clojure luego produce el código de bytes para la JVM. Sería algo así : 

Hay dos puntos importantes:

• La unidad del código fuente es una expresión Clojure, no un archivo fuente Clojure. Los archivos de origen se leen como una serie de expresiones, como si las hubiera escrito de forma interactiva en el REPL.
• Separar el lector y el compilador es una separación clave que deja espacio para macros. Las macros son funciones especiales que toman código (como datos) y emiten código (como datos). 

Clojure

Clojure es Lisp sobre JVM. Clojure es un dialecto de Lisp por lo tanto si entendemos Lisp entendemos Clojure. Lisp es un lenguaje funcional no puro. Lisp tiene algunas características interesantes:

Lisp es un lenguaje de listas. Una llamada a una función utiliza el elemento de la primera lista como la función y el resto como los argumentos.
Lisp utiliza sus propias estructuras de datos para expresar código

Si mezclamos estas dos ideas obtendremos un lenguaje ideal para metaprogramacion. Podemos organizar nuestro código en un árbol teniendo una base de modelo de objetos, también podemos crear un código basado en prototipos. Dándonos gran flexibilidad.

Los primeros dialectos de Lisp son Common Lisp y Scheme. Scheme y Clojure son de la familia de dialectos llamado lisp-1 y Common Lisp es de la familia llamada lisp-2.

Una de las cosas más importantes de Clojure es que funciona sobre la JVM lo que permite usar todas las librerías y frameworks ya escritos en java.

Clojure es funcional y es dinámicamente tipado, lo que hace que el código sea más fácil de leer y más divertido de escribir.

Esto es solo una introducción en proximos post seguiremos escribiendo de este lenguaje.

Dejo Link:
http://clojure.org/

Que proyectos Open Source están hechos con Clojure?

Este post es a raíz de una pregunta en stackoverflow que publico el amigo Ivan Pierre en google+, pufff cuanta comunicación.

La pregunta es sencilla, conocen algún proyecto open source que este escrito en Clojure, bueno para aprender más sobre Clojure, y la respuesta fue una buena lista:

• Clojure: Clojure esta escrito en Clojure por lo tanto cuenta.
• Compojure: Un Framework web para desarrollo en Clojure.
• Ring: Es una librería web inspirada en Python's WSGI y Ruby's Rack. 
• Enlive: Selector basado en CSS.
• Incanter: Es una plataforma de computación estadística y graficación similar a R. 

Y más!!! 

Como empezamos con Clojure?

La idea es ve como podemos empezar con Clojure, yo también estoy empezando así que "esto puede fallar" veamos una forma fácil de empezar utilizando el zip que se encuentra en la pagina: http://clojure.org/downloads. Deszipiamos este archivo y ejecutamos:

java -cp clojure-1.5.1.jar clojure.main

Como ven van a necesitar java con la JDK 6 o superior funciona de maravillas.

y con esto ya podemos utilizar el RELP:

user=> (+ 1 2 3)
6
user=> (javax.swing.JOptionPane/showMessageDialog nil "Hello World")

Otra formas de generar nuestros proyectos Clojure es con Leiningen que es como el maven de Clojure, pero eso es otro post. Esto es solo una pequeña prueba para el hombre pero un gran paso para un desarrollador.

Clojure el lenguaje funcional para plataforma Java

Clojure nos da una manera rápida y fácil para acceder a la plataforma Java. Se puede llamar a cualquier API directamente con:

(System/getProperties)
-> {java.runtime.name=Java(TM) SE Runtime Enviroment
… etc...

Clojure agrega una cantidad de formas sintácticas de llamar métodos Java. Veamos un ejemplo:

// Java
“hello”.getClass().getProtectionDomain()

;Clojure
(.. “hello” getClass getProtectionDomain)

Clojure provee una forma simple para implementar Java interfaces y subclases de Java. También todas las funciones de clojure implementan Callable y Runnable. Esto se podría utilizar para llamar las funciones desde thread.

(.start (new Thread (fn [] (println “Hello” (Thread/currentThread)))))
->Hello #<Thread Thread[Thread-0,5,main]>

Como podemos ver Clojure es claro y simple y se puede llamar a clases java directamente.

Veamos Pedestal y Clojure

Clojure es un lenguaje de programación funcional y dinámico que se ejecuta en la máquina virtual de Java (JVM). Diseñado para ser simple, eficiente y expresivo, Clojure se basa en los principios de la programación funcional y proporciona herramientas para manejar la concurrencia y la inmutabilidad de manera efectiva. Su sintaxis concisa y su énfasis en la inmutabilidad lo convierten en una excelente elección para construir aplicaciones robustas y escalables.

Pedestal es un framework web desarrollado en Clojure que se enfoca en la construcción de aplicaciones web escalables y de alto rendimiento. A diferencia de algunos otros frameworks web, Pedestal no se basa en el paradigma de controladores y vistas, sino que se centra en la manipulación de datos y el flujo de información. Esto lo convierte en una opción ideal para aplicaciones modernas que requieren manejo eficiente de datos en tiempo real.

Las caracteristicas claves son: 

• Modelo de Manejo de Datos: Pedestal se basa en el modelo de manejo de datos (data-driven) en lugar del enfoque tradicional de controladores y vistas. Esto permite una manipulación más eficiente y coherente de los datos a medida que fluyen a través de la aplicación.
• Componentes Reutilizables: El framework fomenta la creación de componentes reutilizables que pueden ser ensamblados fácilmente para construir aplicaciones complejas. Esto mejora la modularidad y el mantenimiento del código.
• Enfoque Asincrónico: Pedestal está diseñado para manejar concurrencia y operaciones asincrónicas de manera efectiva. Esto es esencial para aplicaciones que necesitan manejar múltiples solicitudes y actualizaciones en tiempo real.
• Rendimiento Optimizado: Gracias a su enfoque asincrónico y a la optimización para el manejo eficiente de datos, Pedestal es capaz de ofrecer un alto rendimiento incluso en situaciones de alta carga.

La integración de Pedestal con Clojure es perfectamente natural, ya que ambos comparten la misma plataforma de ejecución (JVM) y una filosofía similar centrada en la simplicidad y la eficiencia. Al aprovechar las capacidades funcionales de Clojure, Pedestal puede manejar de manera elegante la manipulación de datos y el flujo de información en las aplicaciones web.

Vamos a hacer un hola mundo, para ello vamos a crear el proyecto con Leiningen : 

lein new pedestal-app hello-world

Esto creará una estructura de proyecto básica en el directorio hello-world.

Ejecutamos :

lein run

El servidor Pedestal se ejecutará en el puerto 8080 por defecto. Abre tu navegador web y navega a http://localhost:8080. Deberías ver el mensaje "¡Hola, Mundo desde Pedestal y Clojure!" en la página.

Dejo link: https://github.com/pedestal/pedestal

Primeros pasos con Clojure, parte 4

Seguimos con cloujure...

Si sabes lisp, clojure es casi natural : 

Este diagrama se puede ver la diferencia entre la sintaxis en verde (la estructura de datos de Clojure producida por el Reader) y la semántica en azul (cómo el tiempo de ejecución de Clojure entiende esos datos).

La mayoría de las formas literales de Clojure se evalúan a sí mismas, excepto los símbolos y las listas. Los símbolos se utilizan para referirse a otra cosa y cuando se evalúan, devuelven a qué se refieren. Las listas (como en el diagrama) se evalúan como invocaciones.

En el diagrama, (+ 3 4) se lee como una lista que contiene el símbolo (+) y dos números (3 y 4). El primer elemento (donde se encuentra +) se puede llamar "posición de función", es decir, un lugar para encontrar la cosa a invocar. Si bien las funciones son algo obvio para invocar, también hay algunos operadores especiales conocidos para el tiempo de ejecución, macros y un puñado de otras cosas invocables.

Considerando la evaluación de la expresión anterior:

• 3 y 4 se evalúan a sí mismos 
• + evalúa a una función que implementa +
• evaluar la lista invocará la función + con 3 y 4 como argumentos

Muchos lenguajes tienen tanto declaraciones como expresiones, donde las declaraciones tienen algún efecto con estado pero no devuelven un valor. En Clojure, todo es una expresión que se evalúa como un valor. Algunas expresiones (pero no la mayoría) también tienen efectos secundarios.

Dejo link: https://clojure.org/guides/learn/syntax

Primeros pasos con Clojure, parte 18

Seguimos con Clojure... 

En Clojure, hay cuatro tipos clave de colecciones : vectores, listas, conjuntos y mapas. De esos cuatro
tipos de colecciones, los vectores y las listas están ordenados.

Los vectores son una estructura de datos secuenciales indexados. Los vectores se representan con [] así:

[1 2 3]

"Indexado" significa que los elementos de un vector se pueden recuperar por índice. En Clojure (como en Java), los índices comienzan en 0, no en 1. Usamos la función get para recuperar un elemento en un índice:

user=> (get ["abc" false 99] 0)

"abc"

user=> (get ["abc" false 99] 1)

false

Todas las colecciones de Clojure se pueden contar:

user=> (count [1 2 3])

3

Además de la sintaxis literal [], los vectores Clojure se pueden crear con la función vector:

user=> (vector 1 2 3)

[1 2 3]

Los elementos se agregar a un vector con conj (abreviatura de unir). Los elementos siempre se agregan a un vector al final:

user=> (conj [1 2 3] 4 5 6)

[1 2 3 4 5 6]

Las colecciones de Clojure comparten propiedades importantes de valores simples como cadenas y números, como la inmutabilidad y la comparación de igualdad por valor.

Por ejemplo, creemos un vector y modifiquémoslo con conj.

user=> (def v [1 2 3])

#'user/v

user=> (conj v 4 5 6)

[1 2 3 4 5 6]

Aquí conj devolvió un nuevo vector, pero si examinamos el vector original, vemos que no ha cambiado:

user=> v

[1 2 3]

Cualquier función que "cambie" una colección devuelve una nueva instancia. Su programa deberá recordar o transmitir la instancia modificada para aprovecharla.

Primeros pasos con Clojure parte 2

Seguimos con Clojure. 

Como la mayoría de los lenguajes Clojure tiene literales que son los valores que normalmente usamos. 

Ojo los ; son comentarios al final de la línea.

Tipos numéricos

42   ; entero

-1,5  ; punto flotante

22/7  ; fracción

Los enteros se leen como enteros de 64 bits de precisión fija cuando están dentro del rango y precisión arbitraria en caso contrario. Se puede usar una N al final para forzar una precisión arbitraria. Clojure también admite la sintaxis de Java para enteros octal (prefijo 0), hexadecimal (prefijo 0x) y radix arbitrario (prefijo con base y luego r).

Los valores de coma flotante se leen como flotantes de 64 bits de doble precisión o precisión arbitraria con un sufijo M. También se admite la notación exponencial. Los valores simbólicos especiales ## Inf, ## - Inf y ## NaN representan valores de infinito positivo, infinito negativo y "no es un número", respectivamente.

Tambien tenemos caracteres : 

"Hola"         ; String

\e                 ; caracter

# "[0-9] +"   ; expresión regular

Las cadenas están contenidas entre comillas dobles y pueden abarcar varias líneas. Los caracteres individuales se representan con una barra invertida al principio. Hay algunos caracteres especiales con nombre: \ newline \ spec \ tab, etc. Los caracteres Unicode se pueden representar con \ uNNNN o en octal con \ oNNN.

Las expresiones regulares literales son cadenas con un # al principio. Estos se compilan en objetos java.util.regex.Pattern.

Tambien tenemos símbolos e identifidores :

map                  ; símbolo

+                       ; símbolo 

clojure.core / + ; símbolo con espacio de nombres

nil                      ; valor nulo

true false           ; booleans

: alpha               ; palabra clave

:release/alpha   ; palabra clave con espacio de nombres

Los símbolos se componen de letras, números y otros signos de puntuación y se utilizan para referirse a otra cosa, como una función, valor, espacio de nombres, etc. Los símbolos pueden tener opcionalmente un espacio de nombres, separados por una barra inclinada del nombre.

Hay tres símbolos especiales que se leen como tipos diferentes: nil es el valor nulo y verdadero y falso son los valores booleanos.

Las palabras clave comienzan con dos puntos iniciales y siempre se evalúan por sí mismas. Se utilizan con frecuencia como valores enumerados o nombres de atributos en Clojure.

Otra cosa son las colecciones Clojure también incluye sintaxis literal para cuatro tipos de colección:

'(1 2 3); lista

[1 2 3]; vector

#{1 2 3}; conjunto

{:a 1,:b 2}; mapa

Hablaremos de colecciones más adelante, por ahora estuvo bien este post.

PigPen: Map-Reduce para Clojure

Map-Reduce es una técnica de procesamiento de información que ha explotado, hoy en día casi cualquier lenguaje tiene su extención Map-Reduce. Clojure no es menos y como no puede se de otra manera en la plataforma java utiliza Apache Hadoop.

Apache Pig es una plataforma para analizar grandes almacenes de datos. Pig provee un lenguaje de alto nivel para análisis de datos. Como utiliza Apache Hadoop, permite procesar muchos datos con una alta performance.

Pigpen, es una extensión para clojure que permite utilizar Pig con el lenguaje Clojure. Si sabes Clojure sabes pigpen. Y utilizando Pigpen, no es necesario saber mucho de Apache Pig.

Pigpen es un lenguaje para escribir consulta en grandes almacenes de datos igual que clojure que utiliza la potencia de las técnicas de Map-reduce.

Dejo links:
http://techblog.netflix.com/2014/01/introducing-pigpen-map-reduce-for.html?utm_source=dlvr.it&utm_medium=twitter&m=1
https://github.com/Netflix/PigPen

Usando Clojure para hacer aplicaciones Android

Se puede desarrollar una aplicación Android con Clojure? Claro!

Leyendo InfoQ, llego a un articulo sobre desarrollo de android con Clojure y esta muy bueno.

Básicamente tenemos 2 caminos para construir aplicaciones:

• lein-droide: un plugin Leiningen que funciona como una herramienta de construcción para proyectos Clojure-Android y se ocupa de los procesos de recursos de embalaje, la creación de un archivo APK, firmarlo, etc.
• Neko: un conjunto de herramientas que envuelve algunas partes de Java API de Android para que sean más idiomática para utilizar en Clojure.

Dejo link:
http://www.infoq.com/news/2015/08/clojure-native-android-apps

Primeros pasos en Clojure

Les quiero recomendar esta serie de tutoriales sobre Clojure que están muy buenos:

http://blog.koalite.com/2013/01/primeros-pasos-con-clojure/
http://blog.koalite.com/2013/01/introduccion-a-clojure-en-5-minutos/
http://blog.koalite.com/2013/01/un-caso-practico-con-clojure-i/
http://blog.koalite.com/2013/01/un-caso-practico-con-clojure-y-ii/

Clojure 1.7 intorduce Transducers y mejora el soporte multiplataforma

Deje Transducers porque no encontré una traducción que me convenza. Transducers  son transformaciones algorítmicas componibles. Por lo que estuve leyendo son independientes del contexto y a simple vista se parecen mucho a las monads.

Clojure 1.7 agrega esta nueva funcionalidad no solo porque es útil al programador, sino porque permite dar mejor soporte a la plataforma java y javascript.

Con esta nueva funcionalidad queda claro que clojure no solo nos trae a Lisp a java, javascript y clr sino que viene con nuevos conceptos.

Dejo link:
http://www.infoq.com/news/2015/07/clojure-17-released
http://clojure.org/