Create a gist now

Instantly share code, notes, and snippets.

What would you like to do?
Notas de Clojure
=> def - Definición de un macro
Ejemplo:
(def nomSimbolo "Texto")
=> ns - Definición de una namespace
Ejemplo:
(ns namespace1)
Variantes:
:use - Importa al namespace otro namespace
Ejemplo:
(ns namespace1 (:use namespace0))
:require - Asegura que el namespace exista
Ejemplo:
(ns namespace1 (:require namespace0 namespace2))
(ns namespace1 (:require [namespace0 :as ns0])) ;Alias ns0
=> fn - Genera funcion
Ejemplo:
((fn [a b] (* a b)) 2 10) ;Rsultado: 20
(#(* %1 %2) 2 10) ;Rsultado: 20
=> defn - Genera una funcion (o multiples según se defina), le asigna documentacion y un simbolo
Nota:
+ El operador & antes del último argumento indica argumentos variables (seq)
Ejemplo:
(defn multiplicador ;Alias
"Permite multiplicar un par de numeros" ;Doc
[a b] ;Parametros
(* a b)) ;Funcion
(defn funcion-polimorfica
"Permite ejecutar diferentes funciones dependiendo de los argumentos"
([] 0)
([x] (* x x))
([x y] (* x y)))
=> doc - Obtiene documentacion
Ejemplo:
(doc multiplicador)
=> if - Condicional
Ejemplo:
(if (= 1 2) "then" "else")
=> if-not - Condicional if negada
=> cond - Equivalente a case
Ejemplo:
(defn calcula-aprobacion
"Permite calcular aprobacion segun calificacion"
[calificacion]
(cond
(< calificacion 50) "Expulsion"
(< calificacion 70) "Reprobado"
:else "Aprobado"
)
)
=> let - Asigna un nombre al resultado de una operación
Ejemplo:
(let [a 2 b 3] (+ a b))
(defn seconds-to-hours
"Segundos a horas"
[segundos]
(let
[
minutos (/ segundos 60)
horas (/ minutos 60)]
horas))
=> recur - Invoca la función recursivamente, haciendo uso de la teoría Tail Recursion
=> loop - Permite inicializar los valores de la función recursiva desde su definición, apoyada de recur para generar la llamada correspondiente
Ejemplo:
(defn loop-sqrt
"Raiz cuadrada usando loop y recur"
[number]
(loop [guess 1.0] ;Parámetro valor predeterminado: [p1 0 p2 1 ...]
(if (good-enough? number guess)
guess
(recur (avg guess (/ number guess))))))
=> do - Permite la ejecución de sentencias con "Efectos colaterales" (side effects), donde la última sentencia es quien regresa el valor de la llamada
Ejemplo:
(do
(println "hello")
(println "from")
(println "side effects")
0)
(defn funcion-side-effects
"Documentacion"
[parametros]
(println "hello")
(println "from")
(println "side effects")
(+ 2 3))
=> list - Genera una lista con los parametros dados
Ejemplo:
(list (/ 2 3) (/ 3 2)) ;Rsultado: (2/3 3/2)
'(1 2 3)
=> partial - Genera una función parcial con parámetros predeterminados esperando a ser invocada con los parámetros adicionales
Ejemplo:
(def part-doble (partial * 2))
(part-doble 3) ;Rsultado: 6
(part-doble 3 4) ;Rsultado: 24
=> comp - Genera pila de funciones que son ejecutadas
Ejemplo:
((comp - *) 2 3) ;Resultado: -(2 * 3) = -6
=> inc - Incrementa número en 1
=> dec - Decrementa número en 1
=> quot - Resultado entero de la división de dos números
=> rem - Residuo de la división de dos números
=> min, max - Mínimo y máximo de los n números
=> zero? - Valida si el número es 0
=> pos?, neg? - Valida si el número es un número positivo o negativo
=> number? - Valida si el parámetro es un número
=> str - Obtiene la representación y concatenación de los parámetros en String
=> subs - Substring, mismo comportamiento a Java
Ejemplo:
(subs "hola" 2) ;Rsultado: la
(subs "hola" 0 2 ) ;Rsultado: ho
=> string? - Valida si el parámetro es String
=> re-pattern - Obtiene un patrón de expresión regular
Ejemplo:
(re-pattern "[a-z]{2}")
#"[a-z]{2}"
=> re-matches - Valida el segundo parámetro cumple con la expresión regular del primer parámetro
=> re-matcher - Obtiene Matcher para uso posterior (ver re-find)
=> re-find - Usando un Matcher busca el patrón en la expresión
Ejemplo:
(re-find (re-matcher #" [a-z]* " "Este es un texto prueba"))
=> re-groups - Usando un Matcher agrupa las diferentes ocurrencias del patrón
=> re-seq - Usando un Matcher regresa un lista de elementos que cumplen con el patrón
Ejemplo:
(re-seq #" [a-z] " "test")
=> char - Obtiene el caracter \X a partir del número dado
Ejemplo:
(char 65) ;Rsultado: \A
=> keyword - Obtiene la llave a partir de los String dados
Ejemplo:
(keyword "keyword") ;Rsultado :keyword
(keyword "namespace" "keyword") ;Rsultado :namespace/keyword
=> keyword? - Valida si el parámetro es una keyword
=> peek - Obtiene el primer elemento en una lista o el último de un vector
Ejemplo:
(peek '(1 2 3)) ;Rsultado: 1
(peek [1 2 3]) ;Rsultado: 3
=> pop - Si se invoca con una lista, se obtiene otra lista sin el primer elemento, en caso de que el parámetro sea un vector se obtiene otro vector sin el último elemento
Ejemplo:
(pop '(1 2 3)) ;Rsultado: (2 3)
(pop [1 2 3]) ;Rsultado: [1 2]
=> vector?, list?, map? - Valida si el parámetro es del tipo Vector, Lista o Mapa
=> vector - Genera un vector con los parámetros dados
Ejemplo:
(vector 1 2 3) ;Rsultado: [1 2 3]
=> vec - Genera a partir de una colección cualquiera un vector
Ejemplo:
(vec '(1 2 3)) ;Rsultado: [1 2 3]
=> get - Obtiene un elemento en un índice especificado de una colección, nil si no se encuentra o el elemento predeterminado (si se define)
Ejemplo:
(get [1 2 3] 1) ;Rsultado: 2
([1 2 3] 1) ;Rsultado: 2
([1 2 3] 10 "Error") ;Rsultado: "Error"
(get {:a 1 :b 2} :b) ;Rsultado: 2
({:a 1 :b 2} :b) ;Rsultado: 2
(get {:a 1 :b 2} :c) ;Rsultado: nil
(get {:a 1 :b 2} :c "Error") ;Rsultado: "Error"
=> conj, merge - Concatena a una colección N elementos regresando una colección nueva del mismo tipo (vectores, mapas, sets) con los elementos agregados
Ejemplo:
(conj [1 2 3] 4) ;Rsultado: [1 2 3 4]
(conj '(1 2 3) 4) ;Rsultado: (4 1 2 3) Notese que esta es una secuencia
(conj (seq [1 2 3]) 4) ;Rsultado: [4 1 2 3] Comportamiento debido a secuencia
(conj {:a 1 :b 2} {:c 3}) ;Rsultado: {:a 1 :b 2 :c 3}
(conj {:a 1 :b 2} {:b 3}) ;Rsultado: {:a 1 :b 3}
=> assoc - Si se usa como parámetro un vector, ésta substituye en la posición indicada por el segundo parámetro regresando un vector nuevo con el tercer parámetro, en caso de que el parámetro sea un mapa se asigna la llave-valor al mapa correspondiente
Ejemplo:
(assoc [1 2 3] 2 5) ;Rsultado: [1 2 5]
(assoc {:a 1} :b 2) ;Rsultado: {:a 1 :b 2}
(assoc {:a 1} :a 2) ;Rsultado: {:a 2}
=> dissoc - De un mapa elimina la llave/llaves indicadas
Ejemplo:
(dissoc {:a 1 :b 2 :c 3} :b :c) ;Rsultado: {:a 1}
=> subvec - Obtiene un nuevo vector con los elementos entre los índices especificados
Ejemplo:
(subvec [1 2 3 4 5] 2) ;Rsultado: [3 4 5]
(subvec [1 2 3 4 5] 2, 4) ;Rsultado: [3 4]
=> hash-map, sorted-map - Obtiene un mapa/diccionario que usa hashtable o un árbol binario según sea el caso
Ejemplo:
(hash-map :a 1, :b 2) ;Rsultado {:a 1 :b 2}
(sorted-map :a 1, :b 2) ;Rsultado {:a 1 :b 2}
=> defstruct - Genera un elemento tipo Estructura
Ejemplo:
(defstruct person :first-name :last-name)
=> struct-map - Genera un mapa/diccionario basado en una estructura definida, permitiendo un rendimiento óptimo
Ejemplo:
(defstruct person :first-name :last-name)
(def person1 (struct-map person :first-name "Luke" :last-name "VanderHeart"))
=> accesor - Permite acceder a un elemento de un structure-map definido en una estructura
Ejemplo:
(def get-first-name (accesor person :first-name))
(get-first-name person1) ;Rsultado identico a: (person1 :first-name)
=> merge-with - Permite realizar la funcionalidad de merge pero resolviendo el conflicto según la función dada como parámetro
Ejemplo:
(merge-with +
{:a 1 :b 2} {:c 3 :b 10}) ;Rsultado: {:a 1, :b 12, :c 3}
(merge-with (fn [a b] a)
{:a 1 :b 2} {:c 3 :b 10}) ;Rsultado: {:a 1, :b 2, :c 3}
=> contains? - Valida si dentro de una colección se encuentra un elemento específico
Ejemplo:
(contains? {:a 1 :b 2} :a) ;Rsultado: true
=> keys - De un mapa obtiene las llaves que contiene como una secuencia
=> vals - De un mapa obtiene los valores que contiene como una secuencia
=> hash-set, sorted-set - Obtiene un Set que usa hashtable o un árbol binario según sea el caso
Ejemplo:
#{:a :b :c} ;Rsultado: #{:a :b :c}
(hash-set :a :b :c) ;Rsultado: #{:a :b :c}
(sorted-set :a :b :c) ;Rsultado: #{:a :b :c}
=> clojure.set/union - Concatena los Set dados como parámetros en un nuevo Set
Ejemplo:
(clojure.set/union #{:a} #{:a :c}) ;Rsultado: #{:a :c}
=> clojure.set/intersection - Obtiene un Set que contiene los elementos que se interceptan de múltiples Sets
Ejemplo:
(clojure.set/intersection #{:a} #{:a :c}) ;Rsultado: #{:a}
=> clojure.set/difference - Obtiene los elementos del primer conjunto que no existen en el segundo Set
Ejemplo:
(clojure.set/difference #{:a :b} #{:b :c}) ;Rsultado: #{:a}
=> first - Obtiene el primer elemento de una colección, para ejemplo ver "empty?"
=> second - Obtiene el segundo elemento de una colección
=> nth - Obtiene el elemento en la posición deseada de una secuencia
Ejemplo:
(nth '(1 2 3) 1) ;Rsultado: 2
=> last - Obtiene el último elemento de un conjunto
=> rest - Obtiene el conjunto de entrada menos el primer elemento, para ejemplo ver "empty?"
=> empty? - Valida si la colección tiene elementos
Ejemplo:
(defn imprime-elementos [coleccion]
(if (not (empty? coleccion))
(do
(println (str "Elemento " (first coleccion)))
(recur (rest coleccion)))))
=> seq - Permite tratar a una colección como secuencia
Ejemplo:
(seq [1 2])
=> rseq - A partir de un vector o sorted-map obtiene la secuencia en orden inverso
Ejemplo:
(rseq [1 2]) ;Rsultado: (2 1)
=> cons - Permite construir una secuencia a partir de los parámetros dados
Ejemplo:
(cons 4 '(3 2 1)) ;Rsultado: (4 3 2 1)
(cons 1 nil) ;Rsultado: (1)
(defn make-int-seq [max] ;Rsultado: (make-int-seq 10) -> (1 2 3 4 5 6 7 8 9 10)
(loop [acc nil n max]
(if (zero? n)
acc
(recur (cons n acc) (dec n)))))
=> take - Obtiene n elementos de una secuencia definida, para ejemplo ver "lazy-seq"
=> lazy-seq - Obtiene una secuencia que es evaluada según se necesita (y el resultado en Caché)
Ejemplo:
(defn f-incremental [valor incremental]
(lazy-seq
(cons valor (f-incremental (+ valor incremental) incremental))))
(take 10 (f-incremental 0 2)) ;Rsultado: (0 2 4 6 8 10 12 14 16 18)
(nth (f-incremental 2 3) 1000000) ;Rsultado: 3000002
=> iterate - Regresa el siguiente valor en una secuencia infinita con evaluación retardada (similar a yield)
Ejemplo:
(defn f-incremental-iterate [valor incremental]
(iterate (fn [x] (+ x incremental)) valor))
(take 10 (f-incremental-iterate 0 2)) ;Rsultado: (0 2 4 6 8 10 12 14 16 18)
(take 10 (iterate inc 5)) ;Rsultado: (5 6 7 8 9 10 11 12 13 14)
=> repeatedly - Obtiene una secuencia con evaluación retardada aplicando la función usada como parámetro
Ejemplo:
(take 10 (repeatedly (fn [] (rand-int 100))))
=> repeat - Repite el primer parámetro n veces (o indifinicas si no se indica)
Ejemplo:
(take 10 (repeat "hola"))
(repeat 5 "hola")
=> range - Obtiene secuencias según los parámetros dados
Ejemplo:
(range 5) ;Rsultado: (0 1 2 3 4)
(range 5 10) ;Rsultado: (5 6 7 8 9)
(range 5 10 2) ;Rsultado: (5 7 9)
=> distinct - De una colección o secuencia dada obtiene los elementos sin sus duplicados
Ejemplo:
(distinct [1 2 2 5 5 7 7 7 8 8 8]) ;Rsultado: (1 2 5 7 8)
=> filter, remove - De una colección dada, regresa una secuencia retardada de elementos que cumplen con la función filtro o no la cumplan para remove
Ejemplo:
(def f-filtro (fn [x] (= (rem x 2) 0)))
(filter
f-filtro
[1 2 3 4 5 6 7 8 9]) ;Rsultado: (2 4 6 8)
(remove
f-filtro
[1 2 3 4 5 6 7 8 9]) ;Rsultado: (1 3 5 7 9)
=> concat, lazy-cat - Concatena los elementos de múltiples secuencias obteniendo una secuencia como resultado
Ejemplo:
(concat '(1 2 3) '(4 5 6)) ;Rsultado: (1 2 3 4 5 6)
(concat {:a 1 :b 2} {:c 3}) ;Rsultado: ([:a 1] [:b 2] [:c 3])
=> mapcat - Aplica una función (que regresa una secuencia o conjunto) a un conjunto de elementos y concatena los resultados
Ejemplo:
(mapcat (fn [x] (repeat 3 x)) [1 2 3]) ;Rsultado: (1 1 1 2 2 2 3 3 3)
=> cycle - Dado una secuencia de entrada se genera una secuencia retardada infinita
Ejemplo:
(take 10 (cycle '(1 2 3))) ;Rsultado: (1 2 3 1 2 3 1 2 3 1)
=> interleave - De un conjunto de secuencias obtiene los elementos según su posición incremental en una secuencia retardada
Ejemplo:
(interleave [:a :b :c] (iterate inc 1)) ;Rsultado: (:a 1 :b 2 :c 3)
=> interpose - Interpone un valor entre cada valor de una colección dada, regresando una secuencia retardada
Ejemplo:
(take 10 (interpose 0 (iterate inc 1))) ;Rsultado: (1 0 2 0 3 0 4 0 5 0)
=> next - De una secuencia obtiene los elementos a partir del segundo
Ejemplo:
(next '(1 2 3)) ;Rsultado: (2 3)
=> drop - De una secuencia y el número de elementos a descartar obtiene el restante
Ejemplo:
(drop 2 '(1 2 3 4 5)) ;Rsultado: (3 4 5)
=> drop-while - De una secuencia elimina los elementos de izquierda a derecha mientras se cumpla la condición
Ejemplo:
(drop-while (fn [x] (= x \a)) "aaabac") ;Rsultado: (\b \a \c)
(drop-while pos? [2 1 5 -3 6 -2 -1]) ;Rsultado: (-3 6 -2 -1)
=> take-nth - De una secuencia obtiene un elemento cada N
Ejemplo:
(take-nth 3 [0 1 2 3 4 5 6 7 8 9]) ;Rsultado: (0 3 6 9)
=> take-while - De una secuencia obtiene a los elementos de ésta mientras cumplan con la condición dada
Ejemplo:
(take-while pos? [2 3 4 -1 -2 0]) ;Rsultado: (2 3 4)
=> drop-last - De una secuencia regresa otra secuencia menos N elementos indicados (default 1)
Ejemplo:
(drop-last '(1 2 3 4 5)) ;Rsultado: (1 2 3 4)
(drop-last 2 '(1 2 3 4 5)) ;Rsultado: (1 2 3)
=> reverse - De una secuencia obtiene otra con los elementos inversos
Ejemplo:
(reverse '( 1 2 3 )) ;Rsultado: (3 2 1)
=> sort - Dada una secuencia se obtiene otra ordenada
Ejemplo:
(sort '(2 3 1)) ;Rsultado: (1 2 3)
=> sort-by - Dada una secuencia y una función de comparación se obtiene una secuencia ordenada
Ejemplo:
(sort-by (fn [x] (/ 1 x)) [1 2 3 4 5]) ;Rsultado: (5 4 3 2 1)
=> split-at - Se obtiene un vector con los conjuntos divididos en un índice dado
Ejemplo:
(split-at 2 [1 2 3 4 5 6]) ;Rsultado: [(1 2) (3 4 5 6)]
=> split-with - De un conjunto se obtienen divide al no cumplir con una condición dada
Ejemplo:
(split-with (fn [x] (> 10 x)) [5 10 7 15]) ;Rsultado: [(5) (10 7 15)]
=> partition - De un conjunto de elementos se divide en conjuntos y con un offset si se especifica
Nota:
+ Ciclo infinito si offset es 0
Ejemplo:
(partition 2 [:a :b :c :d :e :f]) ;Rsultado: ((:a :b) (:c :d) (:e :f))
(partition 2 3 [:a :b :c :d :e :f]) ;Rsultado: ((:a :b) (:d :e))
(partition 2 3 [:a :b :c :d :e :f :g :h :i :j]) ;Rsultado: ((:a :b) (:d :e) (:g :h))
(partition 3 [:a :b :c :d :e :f :g :h :i :j]) ;Rsultado: ((:a :b :c) (:d :e :f) (:g :h :i))
(partition 3 3 [:a :b :c :d :e :f :g :h :i :j]) ;Rsultado: ((:a :b :c) (:d :e :f) (:g :h :i))
=> map - Se aplica una función F a un conjunto dado haciendo uso de los elementos en esa posición de los conjuntos N como parámetros para F
Ejemplo:
(map pos? [2 1 5 -3 6 -2 -1]) ;Rsultado: (true true true false true false false)
(map + [2 4 8] [1 3 5]) ;Rsultado: (3 7 13)
(map + [2 4 8] [1 3 5] [10 10 10]) ;Rsultado: (13 17 23)
(map
(fn [a b c] (/ (+ a b) c))
[2 4 8] [1 3 5] [10 20 30]) ;Rsultado: (3/10 7/20 13/30)
=> apply - Ejecuta una función en el conjunto definido
Ejemplo:
(apply + [1 2 3]) ;Rsultado: 6
(apply + 10 [1 2 3]) ;Rsultado: 16
(apply str [\y " " \o]) ;Rsultado: "y o"
=> reduce - Dada una secuencia de elementos se aplica consecutivamente una función entre cada uno de ellos, obteniendose al final un único elemento
Ejemplo:
(defn concat-str [x y] (apply str [x " " y]))
(reduce concat-str "Luis") ;Rsultado: "L u i s"
(reduce concat-str "I'm " "Luis") ;Rsultado: "I'm L u i s"
=> some - Valida si una función al ser aplicada a cada elemento de un conjunto se obtiene verdadero
Ejemplo:
(some (fn [x] (> x 5)) [1 2 3 4 5]) ;Rsultado nil
(some (fn [x] (> x 3)) [1 2 3 4 5]) ;Rsultado true
=> every? - Valida si cada uno de los elementos de un conjunto cumplen con la condición expuesta en la función
Ejemplo:
(every? (fn [x] (> x 0)) [1 2 3 4 5]) ;Rsultado: true
(every? (fn [x] (< x 4)) [1 2 3 4 5]) ;Rsultado: false
=> dorun - Ejecuta código con efectos secundarios que se encuentra de una ejecucición retardada
Ejemplo:
(def funcionalidad
(map println (range 1 10)))
(dorun funcionalidad) ;Rsultado: ... Impresión de elementos 1 a 9
(dorun 2 funcionalidad) ;Rsultado: ... Impresión de elementos 1 a 3
=> doall - Ejecuta la función retardada obteniendose como resultado los elementos ejecutados, con probabilidad de en ciclos infinitos generar OutOfMemory
=> ref - Establece una referencia a una variable que cambia de manera síncrona y transaccional
=> deref - Obtiene el valor al que apuntala la referencia
Ejemplo:
(def my-ref (ref 5))
(deref my-ref) ;Rsultado 5
@my-ref ;Rsultado 5
=> ref-set - Establece un nuevo valor a una referencia dada, es indispensable que se encuentre en una transacción
=> dosync - Genera una transacción y cambia el valor de las referencias contenidas dentro de esta
Ejemplo:
(def my-ref1 (ref 5))
(def my-ref2 (ref 2))
(dosync
(ref-set my-ref1 10)
(ref-set my-ref2 15))
=> alter, commute - Permite modificar el valor de una referencia haciendo uso de una función y N parámetros de la función
Nota:
+ Hacer uso de commute en caso de que el orden de las modificaciones no afecte el resultado
Ejemplo:
(def my-ref1 (ref 5))
(def my-ref2 (ref 10))
(dosync
(alter my-ref1 + 10) ;Rsultado 15
(alter my-ref2 (fn [x y z] (* (+ x z) y)) 10 2)) ;Rsultado 120
=> doseq - Permite iterar sobre una secuencia para la ejecución de código con efectos colaterales
Ejemplo:
(def my-contacts (ref []))
(defn add-contact [contacts contact]
(dosync
(alter contacts conj (ref contact))))
(defn print-contacs [contacts]
(doseq [c @contacts]
(println (str (@c :fname) " " (@c :lname)))))
(add-contact my-contacts {:fname "x1" :lname "y1"})
(add-contact my-contacts {:fname "x2" :lname "y2"})
(print-contacs my-contacts)
=> atom - Permite obtener una referencia síncrona y no transaccional
=> swap! - Cambia una referencia de tipo atom haciendo uso de una función de cambio y parámetros de la misma función (similar a alter para ref)
Ejemplo:
(def my-atom (atom 5))
(swap! my-atom + 3) ;Resultado: 8
=> reset! - Cambia una referencia de tipo atom a un valor definido
Ejemplo:
(def my-atom (atom 5))
(reset! my-atom 8) ;Resultado: 8
=> agent - Genera una referencia asíncrona
=> send, send-off - Solicita un cambio al valor que apuntala la referencia agent, aunque asíncronamente
Nota:
+ Usar send para funciones de uso intensivo del CPU y send-off para procesos de tiempo prolongado
Ejemplo:
(def my-agent (agent 5))
(send my-agent + 3) ;Resultado asíncrono: 8
=> set-error-mode! - Permite establecer el comportamiento a tomar si se genera una excepción en la función a evaluar para cambiar un agente
Nota:
+ Posibles valores: ":continue" ":fail"
=> set-error-handler! - Permite establecer una función a llamar si existe una excepción en la función de modificación de un Agente
Nota:
+ Sólo se ejecutará si error-mode es :fail
Ejemplo:
(def my-agent (agent 5))
(set-error-handler! my-agent (fn [agt ex] ( ... )))
(send funcion-excepcion)
=> error-handler - Permite obtener la función de control en caso de excepción para un agente
=> agent-error - Permite obtener la excepción generada al actualizar un agente
Ejemplo:
(agent-error my-agent)
=> restart-agent - Permite indicar al agente que puede continuar cambiando sus valores
Ejemplo:
(restart-agent my-agent
5 ;Nuevo valor
:clear-actions true) ;Limpiar pila de funciones para actualizar
=> await, await-for - Permite esperar a N agentes que terminen de efectuar los cambios de sus valores
Nota:
+ await-for indica un tiempo límite de espera, si no terminan regresa nil
=> shutdown-agents - Bloquea de manera definitiva las llamadas a send y send-off para los agentes del sistema y finaliza los hilos al terminar de efectuar los cambios
=> binding - Permite ejecutar funciones con valores de símbolos previamente establecidas pero con valores diferentes
Ejemplo:
(def x 1)
(def y 1)
(+ x y) ;Resultado 2
(binding [x 2 y 3] (+ x y)) ;Resultado 5
(+ x y) ;Resultado 2
=> set-validator! - Permite establecer a las referencias una función de validación antes de cambiar el valor al que apuntala la referencia (agent, atom, var)
(def my-ref (ref 5))
(set-validator! my-ref (fn [x] (> x 10)))
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment