=> 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)))