Retarde llegue con la noticia pero bueno, nobleza obliga, llego java 16. Ya a esta altura, de casualidad estoy usando java 11. Paren el tren!!! }
Más allá de mi experiencia personal de estos cambios de versiones, vamos a ver que nos trae Java 16.
A nivel de lenguaje lo más importante son Pattern Matching para instanceof y records (a mi entender).
Sin más dejo link: https://jdk.java.net/16/
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
En dicha pagina podemos comenzar de 0 a programar software sencillo. Esta muy bueno, para empezar.
Dejo link: https://dotnet.microsoft.com/learn/dotnet/hello-world-tutorial/intro
Ya se encuentra disponible el formulario de inscripción a los cursos de extensión que dicta el Laboratorio de Investigación Gugler en modalidad semipresencial y a distancia.
Dejo el link para inscribirse : https://www.gugler.com.ar/
Esta pequeña expresión nos permite saber el mayor de una lista. Su funcionamiento es fácil, si la lista tiene un solo elemento, ese es el mayor y si la lista tiene varios elementos, bueno compara el primero con el mayor del resto de la lista, si es mayor, entonces es el mayor, sino retorna el mayor del resto de la lista.
Puff espero que se haya entendido...
Clojure provee manejo de excepciones como Java (try/catch/finally), veamos un ejemplo :
(try
(/ 2 1)
(catch ArithmeticException e
"divide by zero")
(finally
(println "cleanup")))
Tambien podemos lanzar excepciones:
(try
(throw (Exception. "something went wrong"))
(catch Exception e (.getMessage e)))
Clojure provee información extra con :
Veamos un ejemplo :
(try
(throw (ex-info "There was a problem" {:detail 42}))
(catch Exception e
(prn (:detail (ex-data e)))))
Clojure no es un lenguaje funcional puro, por lo tanto tiene funciones con efecto secundario. Vamos a ver algunas :
dotimes :
user=> (dotimes [i 3]
(println i))
0
1
2
nil
Muy parecido a un for, empieza de 0 y sigue hasta 3 - 1.
doseq :
user=> (doseq [n (range 3)]
(println n))
0
1
2
nil
Itera sobre una secuencia (evaluandola si es lazy). Tambien existe la variante que procesa todas las permutaciones del contenido de la secuencia, veamos un ejemplo :
user=> (doseq [letter [:a :b]
number (range 3)] ; list of 0, 1, 2
(prn [letter number]))
[:a 0]
[:a 1]
[:a 2]
[:b 0]
[:b 1]
[:b 2]
nil
for :
user=> (for [letter [:a :b]
number (range 3)] ; list of 0, 1, 2
[letter number])
([:a 0] [:a 1] [:a 2] [:b 0] [:b 1] [:b 2])
La función for se utiliza para generar listas, como listas por comprensión.
cond es una serie de condiciones y expresiones. Cada condición se evalúa en orden y la expresión se evalúa y devuelve el resultado de la primera expresión en que condición fue verdadera.
(let [x 5]
(cond
(< x 2) "x is less than 2"
(< x 10) "x is less than 10"))
Si no se cumple ninguna condición, se devuelve nil. Un modismo común es usar una condición final de :else. Las palabras clave (como :else) siempre se evalúan como verdaderas, por lo que siempre se seleccionará de forma predeterminada.
(let [x 11]
(cond
(< x 2) "x is less than 2"
(< x 10) "x is less than 10"
:else "x is greater than or equal to 10"))
case compara un argumento con una serie de valores para encontrar una coincidencia. ¡Esto se hace en tiempo constante (no lineal)! Sin embargo, cada valor debe ser un literal en tiempo de compilación (números, cadenas, palabras clave, etc.).
A diferencia de cond, case arrojará una excepción si ningún valor coincide.
user=> (defn foo [x]
(case x
5 "x is 5"
10 "x is 10"))
#'user/foo
user=> (foo 10)
x is 10
user=> (foo 11)
IllegalArgumentException No matching clause: 11
case puede tener una expresión final que se evaluará si ninguna prueba coincide.
user=> (defn foo [x]
(case x
5 "x is 5"
10 "x is 10"
"x isn't 5 or 10"))
#'user/foo
user=> (foo 11)
x isn't 5 or 10
|
|
| |||||
El PEP 634 nos muestra como va a ser el pattern matching en Python 3.10. Veamos el ejemplo que es super claro :
match subject:
case <pattern_1>:
<action_1>
case <pattern_2>:
<action_2>
case <pattern_3>:
<action_3>
case _:
<action_wildcard>
Muy parecido a scala pero en vez de => usa los 2 puntos.
Para que quede aun más claro veamos un ejemplo de uso:
def http_error(status):
match status:
case 400:
return "Bad request"
case 404:
return "Not found"
case 418:
return "I'm a teapot"
case _:
return "Something's wrong with the Internet"
y también se va a poder enumerar opciones con el | :
case 401 | 403 | 404:
return "Not allowed"
A la vez, igual que en scala se va poder hacer matching con el valor y estructura de los objetos :
# point is an (x, y) tuple
match point:
case (0, 0):
print("Origin")
case (0, y):
print(f"Y={y}")
case (x, 0):
print(f"X={x}")
case (x, y):
print(f"X={x}, Y={y}")
case _:
raise ValueError("Not a point")
Y como este matching más complejo podemos utilizar mejor el wildcard, etc... pero este post no trata de hablar de toda la potencia de esta nueva característica sino de trasnmitir la noticia.
Dejo link :
https://docs.python.org/3.10/whatsnew/3.10.html#pep-634-structural-pattern-matching
En Clojure, todos los valores son lógicamente verdaderos o falsos. Los únicos valores "falsos" son falsos y nulos; todos los demás valores son lógicamente verdaderos.
user=> (if true :truthy :falsey)
:truthy
user=> (if (Object.) :truthy :falsey) ; objects are true
:truthy
user=> (if [] :truthy :falsey) ; empty collections are true
:truthy
user=> (if 0 :truthy :falsey) ; zero is true
:truthy
user=> (if false :truthy :falsey)
:falsey
user=> (if nil :truthy :falsey)
:falsey
El if solo toma una sola expresión para el "entonces" y "si no". Si necesitamos más devemos utilizar el do para crear bloques más grandes que sean una sola expresión.
(if (even? 5)
(do (println "even")
true)
(do (println "odd")
false))
when es un if con solo una rama then. Verifica una condición y luego evalúa cualquier número de declaraciones como un cuerpo (por lo que no se requiere do). Y devuelve el valor de la última expresión. Si la condición es falsa, se devuelve nil.
(when (neg? x)
(throw (RuntimeException. (str "x must be positive: " x))))
Dejo link: https://assets.softwareag.com/spanish-ebooks
En Clojure, ¡todo es una expresión! Todo devuelve un valor y un bloque de varias expresiones devuelve el último valor. Las expresiones que realizan exclusivamente efectos secundarios devuelven cero.
Los operadores de control de flujo también se pueden ampliar a través de macros, que permiten ampliar el compilador mediante el código de usuario.
if es la expresión condicional más importante: consta de una condición, un "entonces" y un "más". if solo evaluará la rama seleccionada por el condicional.
user=> (str "2 is " (if (even? 2) "even" "odd"))
2 is even
user=> (if (true? false) "impossible!") ;; else is optional
nil
