Clojure - Sintaxis básica

Para comprender la sintaxis básica de Clojure, primero veamos un programa simple de Hello World.

Hola mundo como programa completo

Escribe 'Hola mundo' en un programa Clojure completo. A continuación se muestra un ejemplo.

Ejemplo

(ns clojure.examples.hello
   (:gen-class))
(defn hello-world []
   (println "Hello World"))
(hello-world)

Se deben tener en cuenta las siguientes cosas sobre el programa anterior.

  • El programa se escribirá en un archivo llamado main.clj. La extensión 'clj' es el nombre de la extensión para un archivo de código clojure. En el ejemplo anterior, el nombre del archivo se llama main.clj.

  • La palabra clave 'defn' se usa para definir una función. Veremos las funciones en detalle en otro capítulo. Pero por ahora, sepa que estamos creando una función llamada helloworld, que tendrá nuestro código principal de Clojure.

  • En nuestro código de Clojure, estamos usando la declaración 'println' para imprimir "Hello World" en la salida de la consola.

  • Luego llamamos a la función hello-world que a su vez ejecuta la declaración 'println'.

El programa anterior produce la siguiente salida.

Salida

Hello World

Forma general de una declaración

La forma general de cualquier declaración debe evaluarse entre llaves, como se muestra en el siguiente ejemplo.

(+ 1 2)

En el ejemplo anterior, toda la expresión está entre llaves. La salida de la declaración anterior es 3. El operador + actúa como una función en Clojure, que se usa para la suma de números. Los valores de 1 y 2 se conocen como parameters to the function.

Consideremos otro ejemplo. En este ejemplo, 'str' es el operador que se usa para concatenar dos cadenas. Las cadenas "Hola" y "Mundo" se utilizan como parámetros.

(str "Hello" "World")

Ejemplo

Si combinamos las dos declaraciones anteriores y escribimos un programa, se verá así.

(ns clojure.examples.hello
   (:gen-class))
(defn Example []
   (println (str "Hello World"))
   (println (+ 1 2)))
(Example)

Salida

El programa anterior produce la siguiente salida.

Hello World
3

Espacios de nombres

Un espacio de nombres se utiliza para definir un límite lógico entre los módulos definidos en Clojure.

Espacio de nombres actual

Esto define el espacio de nombres actual en el que reside el código Clojure actual.

Sintaxis

*ns*

Ejemplo

En la ventana de comandos REPL, ejecute el siguiente comando.

*ns*

Salida

Cuando ejecutamos el comando anterior, la salida diferirá dependiendo de cuál sea el espacio de nombres actual. A continuación se muestra un ejemplo de una salida. El espacio de nombres del código Clojure es -

clojure.examples.hello

(ns clojure.examples.hello
   (:gen-class))
(defn Example []
   (println (str "Hello World"))
   (println (+ 1 2)))
(Example)

Requerir declaración en Clojure

El código de Clojure está empaquetado en bibliotecas. Cada biblioteca de Clojure pertenece a un espacio de nombres, que es análogo a un paquete de Java. Puede cargar una biblioteca Clojure con la declaración 'Requerir'.

Sintaxis

(require quoted-namespace-symbol)

Ejemplo

A continuación se muestra un ejemplo del uso de esta declaración.

(ns clojure.examples.hello
   (:gen-class))
(require ‘clojure.java.io’)
(defn Example []
   (.exists (file "Example.txt")))
(Example)

En el código anterior, estamos usando la palabra clave 'require' para importar el espacio de nombres clojure.java.io que tiene todas las funciones requeridas para la funcionalidad de entrada / salida. Dado que no tenemos la biblioteca requerida, podemos usar la función 'archivo' en el código anterior.

Comentarios en Clojure

Los comentarios se utilizan para documentar su código. Los comentarios de una sola línea se identifican mediante ;; en cualquier posición de la línea. A continuación se muestra un ejemplo.

Ejemplo

(ns clojure.examples.hello
   (:gen-class))

;; This program displays Hello World
(defn Example []
   (println "Hello World"))
(Example)

Delimitadores

En Clojure, las declaraciones se pueden dividir o delimitar mediante el uso de llaves curvas o corchetes.

Ejemplo

A continuación se muestran dos ejemplos.

(ns clojure.examples.hello
   (:gen-class))

;; This program displays Hello World
(defn Example []
   (println (+ 1 2 3)))
(Example)

Salida

El programa anterior produce la siguiente salida.

6

Ejemplo

A continuación se muestra otro ejemplo.

(ns clojure.examples.hello
   (:gen-class))

;; This program displays Hello World
(defn Example []
   (println [+ 1 2 3]))
(Example)

Salida

El programa anterior produce la siguiente salida.

[#object[clojure.core$_PLUS_ 0x10f163b "[email protected]"] 1 2 3]

Espacios en blanco

Los espacios en blanco se pueden usar en Clojure para dividir diferentes componentes de una declaración para mayor claridad. Esto se puede hacer con la ayuda del operador coma (,).

Por ejemplo, las siguientes dos declaraciones son equivalentes y la salida de ambas declaraciones será 15.

(+ 1 2 3 4 5)
(+ 1, 2, 3, 4, 5)

Aunque Clojure ignora las comas, a veces las usa para facilitar la lectura al programador.

Por ejemplo, si tiene un mapa hash como el siguiente (def a-map {: a 1: b 2: c 3}) y solicita su valor en la ventana REPL, Clojure imprimirá la salida como {: a 1, : b 2,: c 3}.

Los resultados son más fáciles de leer, especialmente si está mirando una gran cantidad de datos.

Simbolos

En Clojure, los símbolos son equivalentes a identificadores en otros lenguajes de programación. Pero a diferencia de otros lenguajes de programación, el compilador ve los símbolos como valores de cadena reales. Como un símbolo es un valor, un símbolo se puede almacenar en una colección, pasar como argumento a una función, etc., como cualquier otro objeto.

Un símbolo solo puede contener caracteres alfanuméricos y '* +! /. : - _? ' pero no debe comenzar con un número o dos puntos.

A continuación se muestran ejemplos válidos de símbolos.

tutorial-point!
TUTORIAL
+tutorial+

Estructura del proyecto Clojure

Finalmente, hablemos de una estructura de proyecto típica para un proyecto de Clojure. Dado que el código de Clojure se ejecuta en una máquina virtual Java, la mayor parte de la estructura del proyecto dentro de Clojure es similar a la que encontraría en un proyecto Java. A continuación se muestra la instantánea de una estructura de proyecto de muestra en Eclipse para un proyecto de Clojure.

Se deben tener en cuenta las siguientes cuestiones clave sobre la estructura del programa anterior.

  • demo_1: este es el paquete en el que se coloca el archivo de código Clojure.

  • core.clj: este es el archivo de código principal de Clojure, que contendrá el código para la aplicación Clojure.

  • La carpeta Leiningen contiene archivos como clojure-1.6.0.jar que son necesarios para ejecutar cualquier aplicación basada en Clojure.

  • El archivo pom.properties contendrá información como groupId, artifactId y la versión del proyecto Clojure.

  • El archivo project.clj contiene información sobre la propia aplicación Clojure. A continuación se muestra una muestra del contenido del archivo del proyecto.

(defproject demo-1 "0.1.0-SNAPSHOT"
   :description "FIXME: write description"
   :url "http://example.com/FIXME"
   :license {
      :name "Eclipse Public License"
      :url "http://www.eclipse.org/legal/epl-v10.html"
   }
   :dependencies [[org.clojure/clojure "1.6.0"]])