Clojure para programadores Java(2)

Siguiendo la serie de post sobre Clojure veremos los tipos de datos en este lenguaje de programación. Como cualquier otro lenguaje dependiente de la JVM posee tipos de datos.

Ejemplos de tipos de datos en Clojure

"Esto es una cadena de texto. "	String
'W'	Character
34500	Long
7.54	Double
nil	null
bar	símbolo en Clojure
:bar	llave en Clojure
(1 2 3)	lista en Clojure
[1 2 3]	vector en Clojure
{"Alef" 1 "Bet" 2 }	mapa en Clojure

REPL de Clojure

Abrimos una terminal y tecleamos clj. Esto abrirá un REPL:

Clojure 1.10.2
user=>  1 +2 +3 +4
1
2
3
4
user=> + 3 4 5 6
#object[clojure.core$_PLUS_ 0x1d572e62 "clojure.core$_PLUS_@1d572e62"]
3
4
5
6
user=> (+ 3 4 5 6)
18
user=> ( * 4 5 6 7)
840
user=> "Esto es una cadena en Clojure."
"Esto es una cadena en Clojure."
user=> (def texto "Esto es un texto en una variable.")
#'user/texto
user=> (texto)
Execution error (ClassCastException) at user/eval5 (REPL:1).
class java.lang.String cannot be cast to class clojure.lang.IFn (java.lang.String is in module java.base of loader 'bootstrap'; clojure.lang.IFn is in unnamed module of loader 'app')
user=> (println texto)
Esto es un texto en una variable.
nil
user=> (def numero 32)
#'user/numero
user=> (println "Numero = "numero)
Numero =  32
nil
user=> (defn hola-mundo [] (println "Hola, mundo en Clojure"))
#'user/hola-mundo
user=> (hola-mundo)
Hola, mundo en Clojure
nil
user=> (defn sumar [x y] (+ x y))
#'user/sumar
user=> (println "Suma : "(sumar 45 33))
Suma :  78
nil
user=>

Es importante notar algunas cosas:

Hacer uso de los paréntesis, tanto para definir variables y asignar un valor, como para imprimir en pantalla o realizar alguna operación. Abajo podemos ver la sintaxis para definir una variable y asignar un valor. El valor puede ser de tipo String, Long, Double, Character, etc. o hasta uno definido por nosotros (clase/tipo).

(comment
   sintaxis:
   (def ref valor)
)
;; Definimos una variable y asignamos un valor 
(def variable "Valor de la variable")

Ejemplos de declaración de variables

; Definimos variable(s) y su valor(es)
(def ID 123455)
(def nombre "Fernando")
(def edad (- 2022 1981))
(def puede-votar (> edad 18))

Al definir una variable también podemos agregar un comentario.

(def valor "comentario" "Fernando")
(println valor);; Fernando

(def numero "Esto es un  numero Long" 324555)
(println numero);; 324555

(def caracter "Esto es un Character" "@")
(println caracter);; @

Operadores

Operador	Significado
+	suma
-	resta
*	multiplicación
/	división
=	igualdad
<	menor que
>	mayor que
inc	incremento
dec	decremento

Abrimos una terminal para hacer algunas pruebas:

$ clj
Clojure 1.10.2
user=> (/ 45 3)
15
user=> (inc 4)
5
user=> (dec 10)
9
user=> (mod 220 200)
20
user=> (< 3 2)
false
user=> (> 220 200)
true
user=> (= 11 11)
true
user=> (+ 1 2 3 4 5)
15
user=> (- 99 88 11)
0
user=> (* 5 4 3 2 1)
120
user=>

Condicionales y operadores booleanos o lógicos

El usor de operadores lógicos no puede faltar en cualquier lenguaje de programación.

Operador	Significado
and	operador AND
or	operador OR
not	operador NOT

Abrimos una terminal y probamos:

clj
Clojure 1.10.2
user=> (not (< 200 220))
false
user=> (and true true)
true
user=> (or true false)
true
user=> (or false false)
false
user=> (and true false)
false
user=> (and false false)
false
(println "3 >= 3  and 7 != 8 :"
    (and (>= 3 3) (not= 7 8) )
)
3 >= 3  and 7 != 8 : true
nil

El clásico if y su sintaxis en Clojure:

(if (condicion)
   cuerpo
)

Abrimos una terminal y probamos:

$ clj
Clojure 1.10.2
user=> (if (< 200 220) (println "Es verdadero"))
Es verdadero
nil
user=> (if (= 20 20) (println "Correcto"))
Correcto
nil
user=> (if (> 100 99) (println "Es verdadero"))
Es verdadero
nil
user=> (if (not (< 100 99)) (println "True"))
True
nil

Ejemplo. Crear una función que valide si un número es mayor a 100.

;; Función 
(defn mayor-a-100? "Si es mayor a 100 devolvera un true" [num]
    (if (> num 100)
       true
    )    
)

;; Prueba de la función
(println (str "¿100 es mayor a 100?: " (if (mayor-a-100? 100) "Si, es mayor." "No, no lo es.")))
(println (str "¿110 es mayor a 100?: " (if (mayor-a-100? 110) "Si, es mayor." "No, no lo es.")))
(println (str "¿1000 es mayor a 100?: " (if (mayor-a-100? 1000) "Si, es mayor." "No, no lo es.")))

Funciones

Básicamente, una función es un bloque de código que hace alguna operación y devuelve un valor. Es similar a un procedimiento, pero el procedimiento no devuelve nada.

Sintaxis

;; Definimos la función
(defn nombreFunc [arg1 arg2 argN]
   cuerpo-de-la-función
)

Ejemplo. Función para comprobar si un número es mayor a 10.

;; Definimos la función
(defn esmayor10? [num]
   (if (> num 10) "Si" "No")
)

;; Pruebas de la función
(println "300 es mayor a 10? "(esmayor10? 300))
(println "30 es mayor a 10? "(esmayor10? 30))
(println "0 es mayor a 10? "(esmayor10? 0))
(println "-1 es mayor a 10? "(esmayor10? -1))

Es importante notar que al definir una fucnión se le puede agregar un comentario sobre qué es lo que hace.

; Función cuadrado
(defn cuadrado "Multiplica un numero ṕor si mismo"[n]
 (* n n)
)
; Función sumar
(def sumar "Suma dos numeros" [x y]
   (+ x y)
)
;; Función para resolver una ecuación
(defn calcular "Devuelve una operacion" [ a b c d e f denominador]
	(def x (/ (- (* c e) (* b f) ) denominador));;x
	(def y (/ (- (* a f) (* c d) ) denominador));;y
	(println "Solucion:\nx="x" , y="y)
  )

; Procedimiento (no devuelve valor)
(defn my-func-hola "Este solo es un clásico Hola, Mundo!!" []
    (println "Este solo es un clásico Hola, Mundo!!")    
)

;; Esta función tiene parametros
(defn my-func-hola-two "Devuelve un saludo. Verifica si el nombre esta en blanco o es null" [nombre]
    (if (clojure.string/blank? nombre)
        (println "Hola, Extraño")
        (println "Hola,"nombre)
    )    
)

;; Para verificar si una cadena termina en xml
(defn es-xml? "Verifica si una cadena termina en xml" [documento]
    (if (clojure.string/ends-with? documento "xml")
        (println "Se consume el archivo "documento".")
        (println "El archivo ["documento"] no puede ser procesado.")
    )    
)

;; Verifica si una cadena inicia con la letra a
(defn inicia-con-a? "Verifica si una cadena empieza con la letra a" [documento]
    (if (clojure.string/starts-with? documento "a")
        (println "Inicia con a: "documento".")
        (println " ["documento"] no puede ser procesado.")
    )    
)

;; Convertir, por ejemplo, -1 a 1
(defn my-abs "Esta funcion devuelve un valor absoluto de otro numero" [x]
    (if (> x 0)
       x 
       (- x)
    )
)

;; Si un numero es mayor a 100
(defn mayor-a-100? "Si es mayor a 100 devolvera un true" [num]
    (if (> num 100)
       true
    )    
)

Para terminar dejamps un vídeo sobre un tutoria sobre Clojure.

Clojure language tutorial

Enlaces:

https://learnxinyminutes.com/docs/es-es/clojure-es/

Clojure para programadores Java (1)

Clojure es un lenguaje de programación similar a Lisp. Corre bajo la JVM (Java Virtual Machine) y emplea la programación funcional y orientada a objetos. El sitio oficial dice: Clojure es un lenguaje de programación robusto, práctico y rápido con un conjunto de características útiles que juntas forman una herramienta simple, coherente y poderosa. Creando el Hola,mundo en Clojure. holamundo.clj (println "Hola, mundo en Clojure!!" ) La extensión de un programa en este lenguaje es .clj Como se puede notar la base es colocar las sentencias entre parentesis. ( operador/funcion var1 var2 varN) Deberás descargar Clojure, tener instalado Maven y Java. A continuación se muestra una forma de obtener el JAR de Clojure para ejecutar nuestros programas. En la Línea final podemos acceder al shel o REPL del lenguaje. $ git clone https ://github.com/clojure/clojure.git $ cd clojure $ mvn -Plocal -Dmaven.test.skip=true package $ java -jar clojure.jar E

Comunidad City Java

Buscar este blog