Funciones

Listado y ejemplos

• Números:

  • +: suma.
  • -: resta.
  • *: múltiplicación.

  • /: división.

    => (let [a 1000
             b  200
             c    5
             d    1]
         [(+ a b c d) (- a b c d) (* a b c d) (/ a b c d)])
    [1206 794 1000000 1]
    
    => (let [a 0.1
             b 0.2
             c 100]
         [(+ a b) (/ (+ (* a c) (* b c)) c)])
    [0.30000000000000004 0.3]
    
    => (let [a 10/4
             b  1/3]
         [(+ a b) (- a b) (* a b) (/ a b)])
    [17/6 13/6 5/6 15/2]
    

  • quot: el cociente de la división.

  • rem: el resto de la división.

    => (let [a 100
             b 30
             c 2]
         [[(quot a b) (rem a b)] [(quot a c) (rem a c)]])
    [[3 10] [50 0]]
    

  • inc: incremento en uno.

  • dec: decremento en uno.
  • max: el número mayor.

  • min: el número menor.

    => (let [a  5
             b 10
             c 15]
         [[(dec (min a b c)) (inc (min c b a))] [(dec (max a b c)) (inc (max c b a))]])
    [[4 6] [14 16]]
    

  • Relación:

    • ==: igualdad.
    • <: menor a.
    • >: mayor a.
    • <=: menor o igual a.

    • >=: mayor o igual a.

      => (let [a   10
               b 50/5
               c 10.0
               d   20
               e   30]
           [(== a b c) (< a d e) (> e d a) (<= a b c d e) (>= e d c b a)])
      [true true true true true]
      

  • Predicado:

    • zero?: ¿es igual a cero?.
    • pos?: ¿es positivo?.
    • neg?: ¿es negativo?.
    • even?: ¿es par?.
    • odd?: ¿es impar?.
    • number?: ¿es un número (entero, racional, fraccionario, de coma/punto flotante o decimal)?.
    • integer?: ¿es un número entero?.
    • rational?: ¿es un número racional?.
    • ratio?: ¿es un número fraccionario (fracción)?.

    • float?: ¿es un número de coma/punto flotante o decimal?.

      => (let [a  0
               b  0.0
               c -5
               d  5
               e  6
               f  2/3
               g  9/3]
           [[(zero? a) (zero? b)]
            [(neg? c) (pos? d)]
            [(odd? d) (even? e)]
            [(number? b) (number? d) (number? f) (number? g)]
            [(integer? b) (integer? d) (integer? f) (integer? g)]
            [(rational? b) (rational? d) (rational? f) (rational? g)]
            [(ratio? b) (ratio? d) (ratio? f) (ratio? g)]
            [(float? b) (float? d) (float? f) (float? g)]])
      [[true true]
       [true true]
       [true true]
       [true true true true]
       [false true false true]
       [false true true true]
       [false false true false]
       [true false false false]]
      

  • Generación:

    • rand: regresa un número de coma/punto flotante aleatorio entre 0.0 y n (1.0, por default).

    • rand-int: regresa un número entero aleatorio entre 0 y n.

      => (let [a 100
               b 200]
           [[(rand) (rand a)] [(rand-int a) (rand-int b)]])
      [[0.31931038559080016 44.938044601329985] [32 184]]
      

  • char: convierte un número entero positivo en su representación de carácter en base a los caracteres de Unicode.

    => (let [a    32
             b    65
             c    97
             d   955
             e  9733
             f  9775
             g  9829
             h 11035
             i 11044
             j 12196]
         [(char a) (char b) (char c) (char d) (char e) (char f) (char g) (char h) (char i) (char j)])
    [\space \A \a \λ \★ \☯ \♥ \⬛ \⬤ \⾤]
    

• Booleanos:

  • not: negación.
  • and: conjunción.

  • or: disyunción.

    => (let [a true
             b false
             c true
             d false
             e true
             f false]
         [[(not a) (not b)]
          [(and a c e) (and a b c e)]
          [(or b d f) (or b c d f)]])
    [[false true] [true false] [false true]]
    

  • Predicado:

    • true?: ¿es igual a true?.

    • false?: ¿es igual a false?.

      => (let [a true
               b false]
           [[(true? a) (true? b)]
            [(false? a) (false? b)]])
      [[true false] [false true]]
      

• Caracteres:

  • int: convierte un carácter en su representación de número entero positivo en base a los caracteres de Unicode.

    => (let [a \space
             b \A
             c \a
             d \λ
             e \★
             f \☯
             g \♥
             h \⬛
             i \⬤
             j \⾤]
         [(int a) (int b) (int c) (int d) (int e) (int f) (int g) (int h) (int i) (int j)])
    [32 65 97 955 9733 9775 9829 11035 11044 12196]
    

  • Predicado: char?.

    => (let [a 5
             b \5
             c "5"]
         [(char? a) (char? b) (char? c)])
    [false true false]
    

• Nil:

  • Predicado: nil?.

    => (let [a nil
             b 0
             c false
             d ""
             e '()]
         [(nil? a) (nil? b) (nil? c) (nil? d) (nil? e)])
    [true false false false false]
    

• Colecciones:

  • Listas:

    • list: regresa una lista a partir de sus argumentos dados.
    • nth: regresa el n-avo elemento de la lista. 0 es el primero, 1 es el segundo, etc.

    • list?: ¿es una lista?.

      => (let [a  10
               xs (list a (* 2 a) (* 3 a) (* 4 a) (* 5 a))]
           [xs (nth xs 2) (nth xs 7 80) (list? xs)])
      [(10 20 30 40 50) 30 80 true]
      

  • Vectores:

    • vector: regresa un vector a partir de sus argumentos dados.
    • nth: regresa el n-avo elemento del vector. 0 es el primero, 1 es el segundo, etc.
    • subvec: regresa un vector con los elementos encontrados entre los índices dados, exceptuando el índice final dado.
    • vector?: ¿es un vector?.
    • mapv: aplica una función sobre cada uno de los elementos encontrados en la colección dada, regresando un vector con los resultados obtenidos.
    • filterv: aplica un predicado sobre cada uno de los elementos encontrados en la colección dada, regresando un vector con los elementos que cumplan el predicado.

    • vec: regresa un vector a partir de los elementos de la colección dada.

      => (let [a  10
               xs (vector a (* 2 a) (* 3 a) (* 4 a) (* 5 a))]
           [xs (nth xs 2) (nth xs 7 80) (subvec xs 1 3) (vector? xs)])
      [[10 20 30 40 50] 30 80 [20 30] true]
      
      => (let [a  10
               xs (vector a (* 2 a) (* 3 a) (* 4 a) (* 5 a))]
           [xs
            (mapv (fn [x] (* 2 x)) xs)
            (filterv (fn [x] (and (>= x 20) (<= x 40))) xs)])
      [[10 20 30 40 50] [20 40 60 80 100] [20 30 40]]
      
      => (let [xs [10 20 30 40]
               ys [60 70 80 90]]
           [(mapv (fn [x] (+ x 500)) xs)
            (mapv (fn [x y] (+ x y)) xs ys)
            (filterv (fn [x] (and (>= x 20) (<= x 40))) xs)
            (filterv (fn [x] (and (>= x 60) (<= x 80))) ys)])
      [[510 520 530 540] [70 90 110 130] [20 30 40] [60 70 80]]
      
      => (let [xs #{10 20 30 40 50}
               ys {:a 10 :b 20 :c 30 :d 40 :e 50}
               zs "¡Hola mundo!"]
           [(vec xs) (vec ys) (vec zs)])
      [[20 50 40 30 10]
       [[:a 10] [:b 20] [:c 30] [:d 40] [:e 50]]
       [\¡ \H \o \l \a \space \m \u \n \d \o \!]]
      

    • Vector como función: (un-vector índice)

      => (let [xs [10 20 30 40 50]]
           [(xs 0) (xs 2) (xs 4)])
      [10 30 50]
      

  • Conjuntos:

    • hash-set: regresa un conjunto a partir de sus argumentos dados, sin mantener su orden internamente.

      • sorted-set: regresa un conjunto a partir de sus argumentos dados, manteniendo su orden internamente.

        => (let [x  10
                 xs (sorted-set (* 3 x) (* 5 x) x (* 4 x) (* 2 x))]
             xs)
        #{10 20 30 40 50}
        

    • set: regresa un conjunto a partir de los elementos de la colección dada. Los elementos repetidos en la colección dada son descartados en el conjunto regresado.

      => (let [a  10
               xs (hash-set a (* 2 a) (* 3 a) (* 4 a) (* 5 a))
               ys (set [50 40 40 30 20 20 50 30 20 10])]
           [xs ys])
      [#{20 50 40 30 10} #{20 50 40 30 10}]
      

    • disj: regresa un conjunto a partir de un conjunto dado (como primer argumento), sin incluir el resto de argumentos dados.

      => (let [a  10
               xs (hash-set a (* 2 a) (* 3 a) (* 4 a) (* 5 a))
               ys (disj xs 20 40)]
            [xs ys])
      [#{20 50 40 30 10} #{50 30 10}]
      

    • clojure.set/union: regresa un conjunto a partir de la unificación de los conjuntos dados:

      => (let [as #{10 20 30 40 50}
               bs #{10 20 30 40 50}
               cs #{10 20 30}
               ds #{10 20 30 60 70}
               es #{60 70 80 90 100}]
           [(clojure.set/union as bs)
            (clojure.set/union as cs)
            (clojure.set/union as ds)
            (clojure.set/union as es)])
      [#{20 50 40 30 10}
       #{20 50 40 30 10}
       #{70 20 60 50 40 30 10}
       #{70 20 60 50 40 90 100 30 10 80}]
      
      => (let [as #{10 20 30 40 50 60 70 80 90}
               bs #{80 40 60 20}
               cs #{100 110 120 130 140 150}
               ds #{90 20 10 40 100}]
           (clojure.set/union as bs cs ds))
      #{70 110 130 20 60 50 40 90 150 100 140 120 30 10 80}
      

    • clojure.set/difference: regresa un conjunto a partir del primer conjunto dado eliminando sus elementos que se encuentren en el resto de conjuntos dados.

      => (let [as #{10 20 30 40 50}
               bs #{10 20 30 40 50}
               cs #{10 20 30}
               ds #{10 20 30 60 70}
               es #{60 70 80 90 100}]
           [(clojure.set/difference as bs)
            (clojure.set/difference as cs)
            (clojure.set/difference as ds)
            (clojure.set/difference as es)])
      [#{} #{50 40} #{50 40} #{20 50 40 30 10}]
      
      => (let [as #{10 20 30 40 50 60 70 80 90}
               bs #{80 40 60 20}
               cs #{100 110 120 130 140 150}
               ds #{90 20 10 40 100}]
           (clojure.set/difference as bs cs ds))
      #{70 50 30}
      

    • clojure.set/intersection: regresa un conjunto con todos los elementos a partir del primer conjunto dado que también se encuentren en el resto de conjuntos dados.

      => (let [as #{10 20 30 40 50}
               bs #{10 20 30 40 50}
               cs #{10 20 30}
               ds #{10 20 30 60 70}
               es #{60 70 80 90 100}]
           [(clojure.set/intersection as bs)
            (clojure.set/intersection as cs)
            (clojure.set/intersection as ds)
            (clojure.set/intersection as es)])
      [#{20 50 40 30 10} #{20 30 10} #{20 30 10} #{}]
      
      => (let [as #{10 20 30 40 50 60 70 80 90}
               bs #{80 40 60 20}
               cs #{100 110 120 130 140 150}
               ds #{90 20 10 40 100}]
           [(clojure.set/intersection as bs)
            (clojure.set/intersection as bs cs)
            (clojure.set/intersection as ds bs)])
      [#{20 60 40 80} #{} #{20 40}]
      

    • clojure.set/subset?: ¿el primer conjunto dado es subconjunto del segundo conjunto dado?

      => (let [as #{10 20 30 40 50}
               bs #{10 20 30 40 50}
               cs #{10 20 30}
               ds #{10 20 30 60 70}
               es #{60 70 80 90 100}]
           [(clojure.set/subset? as bs)
            (clojure.set/subset? as cs)
            (clojure.set/subset? as ds)
            (clojure.set/subset? as es)])
      [true false false false]
      

    • clojure.set/superset?: ¿el primer conjunto dado es superconjunto del segundo conjunto dado?

      => (let [as #{10 20 30 40 50}
               bs #{10 20 30 40 50}
               cs #{10 20 30}
               ds #{10 20 30 60 70}
               es #{60 70 80 90 100}]
           [(clojure.set/superset? as bs)
            (clojure.set/superset? as cs)
            (clojure.set/superset? as ds)
            (clojure.set/superset? as es)])
      [true true false false]
      

    • clojure.set/select: dado un predicado y un conjunto regresa un conjunto con los elementos del conjunto dado que cumplan el predicado dado.

      => (let [xs #{10 20 30 40 50}]
           (clojure.set/select (fn [x] (and (>= x 20) (<= x 40))) xs))
      #{20 40 30}
      

    • clojure.set/map-invert: dado un mapa regresa un mapa donde invierte los valores en llaves y las llaves en valores del mapa dado.

      => (let [xs {:a 10 :b 20 :c 30}]
           (clojure.set/map-invert xs))
      {10 :a, 20 :b, 30 :c}
      

    • Conjunto como función: (un-conjunto elemento)

      => (let [xs #{10 20 30 40 50}]
           [(xs 10) (xs 30) (xs 50) (xs 60) (xs 80) (xs 100)])
      [10 30 50 nil nil nil]
      

  • Mapas:

    • hash-map: regresa un mapa a partir de los argumentos dados, los cuales son tomados como pares: primero la llave y luego el valor asociado a la llave.

      => (let [x  10
               xs (hash-map x       (inc x)
                            (* 2 x) (inc (* 2 x))
                            (* 3 x) (inc (* 3 x))
                            (* 4 x) (inc (* 4 x))
                            (* 5 x) (inc (* 5 x)))]
           xs)
      {20 21, 50 51, 40 41, 30 31, 10 11}
      

    • zipmap: regresa un mapa a partir de dos colecciones, la primera siendo las llaves y la segunda siendo los valores asociados a las llaves.

      => (let [as [10 20 30]
               bs [40 80 120]
               cs #{40 80 120}
               ds {:a 40 :b 80 :c 120}]
           [(zipmap as bs) (zipmap as cs) (zipmap as ds)])
      [{10 40, 20 80, 30 120}
       {10 40, 20 120, 30 80}
       {10 [:a 40], 20 [:b 80], 30 [:c 120]}]
      

    • Mapa como función: (un-mapa llave)

      => (let [xs {:a 10 :b 20 :c 30 :d 40 :e 50}]
           [(xs :a) (xs :c) (xs :e) (xs :f) (xs :g) (xs :h)])
      [10 30 50 nil nil nil]
      

  • Secuencias: map, filter, reduce.

  • Asociaciones: get, assoc, assoc-in, replace, update, update-in, reduce-kv, contains?.

    • get:

      => (let [xs {:a 10 :b 20 :c 30}]
           [(get xs :a) (get xs :b) (get xs :c) (get xs :d) (get xs :e) (get xs :f 40) (get xs :g 50)])
      [10 20 30 nil nil 40 50]
      

    • frequencies:

      => (let [xs [10 20 10 30 20 10 40 50 10 50]
               ys #{10 20 30 40 50}
               zs {:a 10 :b 20 :c 30 :d 20 :e 10}]
           [(frequencies xs)
            (frequencies ys)
            (frequencies zs)])
      [{10 4, 20 2, 30 1, 40 1, 50 2}
       {20 1, 50 1, 40 1, 30 1, 10 1}
       {[:a 10] 1, [:b 20] 1, [:c 30] 1, [:d 20] 1, [:e 10] 1}]
      

• Cadenas de caracteres:

  • str: regresa una cadena de caracteres conformada por la concatenación de la representación como cadena de caracteres de cada uno de sus argumentos dados, respetando el orden en que fueron dados.

    => (let [a 123
             b 4.5
             c true
             d \@
             e "HOLA MUNDO"
             f [10 20 30]
             g #{10 20 30}
             h {:a 10 :b 20 :c 30}
             i '(10 20 30)]
         [(str)
          (str a b)
          (str c d e)
          (str f g h i)])
    [""
     "1234.5"
     "true@HOLA MUNDO"
     "[10 20 30]#{20 30 10}{:a 10, :b 20, :c 30}(10 20 30)"]
    

  • count: regresa la cantidad de caracteres que conforman la cadena de caracteres.

  • get: regresa el n-avo carácter de la cadena de caracteres.

    => (let [x "¡Hola mundo!"]
         [(count x)
          [(get x 1) (get x 3) (get x 5) (get x 15 \@)]])
    [12 [\H \l \space \@]]
    

  • subs (subcadena): dada una cadena de caracteres, un inicio y un fin, regresa una cadena de caracteres conformada por los caracteres encontrados entre inicio y fin (excluido).

    => (let [x "¡Hola mundo!"]
         [(subs x 0) (subs x 3 9) (subs x 6 12) (subs x 9)])
    ["¡Hola mundo!" "la mun" "mundo!" "do!"]
    

  • string?: ¿es una cadena de caracteres?.

    => (let [a 5
             b \5
             c "5"
             d [5]
             e #{5}]
         [(string? a) (string? b) (string? c) (string? d) (string? e)])
    [false false true false false]
    

  • clojure.string/blank?: ¿es una cadena de caracteres vácia o contiene solo espacios en blanco (caracteres no imprimibles)?

    => (let [x "¡Hola mundo!"
             y ""
             z "   \t  \r  \n    \t"]
         [(clojure.string/blank? x)
          (clojure.string/blank? y)
          (clojure.string/blank? z)])
    [false true true]
    

  • clojure.string/join: dado un separador (opcionalmente) y una colección, regresa una cadena de caracteres conformada por la representación de los elementos de la colección intercalando el separador entre ellos.

    => (let [a  \|
             xs [10 20 30]
             ys #{10 20 30}
             zs {:a 10 :b 20 :c 30}]
         [(clojure.string/join a xs)
          (clojure.string/join a ys)
          (clojure.string/join a zs)])
    ["10|20|30"
     "20|30|10"
     "[:a 10]|[:b 20]|[:c 30]"]
    

  • clojure.string/escape: dada una cadena de caracteres y una función o un mapa, usa la función o el mapa dado para sustituir cada carácter en la cadena de caracteres dada, regresando una cadena de caracteres.

    => (let [x "¡Hola mundo!"
             y "ACEGIKMÑPRTV"
             z "abcdefghijkl"]
         [(clojure.string/escape x (fn [x] nil))
          (clojure.string/escape y (fn [x] (char (inc (int x)))))
          (clojure.string/escape z (fn [x] (char (+ 13 (int x)))))
          (clojure.string/escape x {\H \h \space \| \¡ \! \! \¡})
          (clojure.string/escape y {\A \4 \I 1 \T \7})
          (clojure.string/escape z {\a \4 \b \8 \e \3 \i \1 \l \1})
          (clojure.string/escape x {\¡ "¡¡¡" \! "!!!"})])
    ["¡Hola mundo!"
     "BDFHJLNÒQSUW"
     "nopqrstuvwxy"
     "!hola|mundo¡"
     "4CEG1KMÑPR7V"
     "48cd3fgh1jk1"
     "¡¡¡Hola mundo!!!"]
    

  • clojure.string/reverse: dada una cadena de caracteres regresa una cadena de caracteres con los caracteres invertidos en su orden dentro de la cadena de caracteres dada.

    => (let [x "¡Hola mundo!"
             y "ABCDEfghijkl"
             z "001122334455"]
         [(clojure.string/reverse x)
          (clojure.string/reverse y)
          (clojure.string/reverse z)])
    ["!odnum aloH¡" "lkjihgfEDCBA" "554433221100"]
    

  • clojure.string/index-of: dada una cadena de caracteres y un carácter u otra cadena de caracteres, regresa la posición a partir de la cual se encuentra, por primera vez, el carácter o la otra cadena de caracteres dada. Regresa nil en caso de no encontrarse.

    => (let [x "¡Hola mundo!"]
         [(clojure.string/index-of x \a)
          (clojure.string/index-of x \space)
          (clojure.string/index-of x \o)
          (clojure.string/index-of x "mun")
          (clojure.string/index-of x " ")
          (clojure.string/index-of x "!")
          (clojure.string/index-of x \@)
          (clojure.string/index-of x "ñ")])
    [4 5 2 6 5 11 nil nil]
    

  • clojure.string/index-of: similar a clojure.string/index-of pero regresa la posición a partir de la cual se encuentra por última vez el carácter o la otra cadena de caracteres dada.

    => (let [x "¡Holaaaaa mundooooo!"]
         [(clojure.string/last-index-of x \a)
          (clojure.string/last-index-of x \space)
          (clojure.string/last-index-of x \o)
          (clojure.string/last-index-of x "mun")
          (clojure.string/last-index-of x " ")
          (clojure.string/last-index-of x "!")
          (clojure.string/last-index-of x \@)
          (clojure.string/last-index-of x "ñ")])
    [8 9 18 10 9 19 nil nil]
    

  • clojure.string/capitalize:

    => (let [x "hola mundo"
             y "¡hola mundo!"
             z "¡HOLA MUNDO!"]
         [[(clojure.string/capitalize x) (clojure.string/capitalize y) (clojure.string/capitalize z)]
          [(clojure.string/lower-case x) (clojure.string/lower-case y) (clojure.string/lower-case z)]
          [(clojure.string/upper-case x) (clojure.string/upper-case y) (clojure.string/upper-case z)]])
    [["Hola mundo" "¡hola mundo!" "¡hola mundo!"]
     ["hola mundo" "¡hola mundo!" "¡hola mundo!"]
     ["HOLA MUNDO" "¡HOLA MUNDO!" "¡HOLA MUNDO!"]]
    
    => (let [a \o
             b \O
             c \ó
             d \Ó
             e \ö
             f \Ö
             g \ô
             h \Ô
             i \õ]
         [[(clojure.string/capitalize a) (clojure.string/capitalize b) (clojure.string/capitalize c)]
          [(clojure.string/lower-case d) (clojure.string/lower-case e) (clojure.string/lower-case f)]
          [(clojure.string/upper-case g) (clojure.string/upper-case h) (clojure.string/upper-case i)]])
    [["O" "O" "Ó"] ["ó" "ö" "ö"] ["Ô" "Ô" "Õ"]]
    

  • clojure.string/triml: dada una cadena de caracteres regresa una cadena de caracteres con los espacios en blanco encontrados a la derecha (inicio) de la cadena de caracteres dada.

  • clojure.string/trimr: dada una cadena de caracteres regresa una cadena de caracteres con los espacios en blanco encontrados a la izquierda (fin) de la cadena de caracteres dada.

  • clojure.string/triml: dada una cadena de caracteres regresa una cadena de caracteres con los espacios en blanco encontrados tanto a la derecha (inicio) como a la izquierda (fin) de la cadena de caracteres dada.

    => (let [x "     ¡Hola     mundo!     "]
         [(clojure.string/triml x)
          (clojure.string/trimr x)
          (clojure.string/trim x)])
    ["¡Hola     mundo!     "
     "     ¡Hola     mundo!"
     "¡Hola     mundo!"]
    

  • clojure.string/starts-with?: dadas dos cadenas de caracteres regresa true si la primera contiene a la segunda en su inicio (derecha).

  • clojure.string/ends-with?: dadas dos cadenas de caracteres regresa true si la primera contiene a la segunda en su fin (izquierda).

  • clojure.string/includes?: dadas dos cadenas de caracteres regresa true si la primera contiene a la segunda en cualquier parte.

    => (let [x "¡Hola mundo!"
             y "¡Hola"
             z "mundo!"]
         [[(clojure.string/starts-with? x y) (clojure.string/starts-with? x z)]
          [(clojure.string/ends-with? x y) (clojure.string/ends-with? x z)]
          [(clojure.string/includes? x y) (clojure.string/includes? x z)]])
    [[true false] [false true] [true true]]
    

• Funciones:

  • identity (Función identidad): dado un argumento regresa el mismo argumento.

    => (let [x 5
             y \5
             z "5"
             xs [4 5 6]
             ys #{\a \b \c}
             zs {:a 10 :b 20 :c 30}]
         [(identity x)
          (identity y)
          (identity z)
          (map identity xs)
          (map identity ys)
          (map identity zs)])
    [5
     \5
     "5"
     (4 5 6)
     (\a \b \c)
     ([:a 10] [:b 20] [:c 30])]
    

  • constantly: dado un argumento regresa una función de aridad variable la cual al ser aplicada regresa siempre el argumento dado a constantly.

  • comp (Función compuesta): dada cierta cantidad de funciones como argumentos (izq. a der.) regresa una función que al ser aplicada lleva a cabo la aplicación de las funciones dadas a comp (der. a izq.). La función regresada es de aridad variable.

    => (let [a (fn [x] (* 2 x))
             b (fn [x] (max 0 x))]
         [[((comp a b) 5) ((comp a b) -5)]
          [((comp b a) 5) ((comp b a) -5)]])
    [[10 0] [10 0]]
    
    => (let [a (fn [xs] (filter even? xs))
             b (fn [xs] (filter (fn [x] (and (>= x 10) (<= x 50))) xs))
             c (fn [xs] (filter (fn [x] (== 0 (rem x 3))) xs))]
         [((comp a b c) (range -100 101))
          ((comp b c a) (range -100 101))
          ((comp c b a) (range -100 101))])
    [(12 18 24 30 36 42 48) (12 18 24 30 36 42 48) (12 18 24 30 36 42 48)]
    

  • complement

  • partial
  • juxt
  • memoize
  • fnil
  • every-pred
  • some-fn
  • some-fn
  • apply
  • ->
  • ->>
  • trampoline
  • as->
  • cond->
  • cond->>
  • some->
  • some->>
  • fn?: ¿es una función?