clojure
Funciones

Definiendo funciones

Las funciones se definen con cinco componentes:

El encabezado, que incluye la palabra clave defn , el nombre de la función.

(defn welcome ....)

Una Docstring opcional que explica y documenta lo que hace la función.

(defn welcome 
    "Return a welcome message to the world"
     ...)

Parámetros listados entre paréntesis.

(defn welcome 
    "Return a welcome message"
    [name]
    ...)

El cuerpo, que describe los procedimientos que realiza la función.

(defn welcome 
    "Return a welcome message"
    [name]
    (str "Hello, " name "!"))

Llamándolo:

=> (welcome "World")

"Hello, World!"

Parámetros y Arity

Las funciones de Clojure se pueden definir con cero o más parámetros.

(defn welcome
    "Without parameters"
    []
    "Hello!")

(defn square
    "Take one parameter"
    [x]
    (* x x))

(defn multiplier
    "Two parameters"
    [x y]
    (* x y))

Aridad

El número de argumentos que toma una función. Las funciones admiten la sobrecarga de arity , lo que significa que las funciones en Clojure permiten más de un "conjunto" de argumentos.

(defn sum-args
  ;; 3 arguments
  ([x y z]
     (+ x y z))
  ;; 2 arguments
  ([x y]
     (+ x y))
  ;; 1 argument 
  ([x]
     (+ x 1)))

Las aridades no tienen que hacer el mismo trabajo, cada aridad puede hacer algo sin relación:

(defn do-something
  ;; 2 arguments
  ([first second]
     (str first " " second))
  ;; 1 argument 
  ([x]
     (* x x x)))

Definiendo funciones variables

Se puede definir una función de Clojure para tomar un número arbitrario de argumentos, usando el símbolo y en su lista de argumentos. Todos los argumentos restantes se recogen como una secuencia.

(defn sum [& args]
  (apply + args))

(defn sum-and-multiply [x & args]
  (* x (apply + args)))

Vocación:

=> (sum 1 11 23 42)
77

=> (sum-and-multiply 2 1 2 3)  ;; 2*(1+2+3)
12

Definiendo funciones anónimas.

Hay dos formas de definir una función anónima: la sintaxis completa y una taquigrafía.

Sintaxis completa de funciones anónimas

(fn [x y] (+ x y))

Esta expresión se evalúa como una función. Cualquier sintaxis que pueda usar con una función definida con defn ( & , desestructuración de argumentos, etc.), también puede hacer con la forma fn . defn es en realidad una macro que solo hace (def (fn ...)) .

Sintaxis de funciones anónimas

#(+ %1 %2)

Esta es la notación taquigráfica. Usando la notación abreviada, no tiene que nombrar argumentos explícitamente; se les asignarán los nombres %1 , %2 , %3 y así sucesivamente de acuerdo con el orden en que se pasaron. Si la función solo tiene un argumento, su argumento se llama solo % .

Cuándo usar cada

La notación abreviada tiene algunas limitaciones. No puede desestructurar un argumento y no puede anidar funciones anónimas abreviadas. El siguiente código arroja un error:

(def f #(map #(+ %1 2) %1))

Sintaxis soportada

Puede utilizar varargs con funciones anónimas de la taquigrafía. Esto es completamente legal:

#(every? even? %&)

Toma un número variable de argumentos y devuelve verdadero si cada uno de ellos es par:

(#(every? even? %&) 2 4 6 8)
;; true
(#(every? even? %&) 1 2 4 6)
;; false

A pesar de la aparente contradicción, es posible escribir una función anónima con nombre incluyendo un nombre, como en el siguiente ejemplo. Esto es especialmente útil si la función necesita llamarse a sí misma pero también en los seguimientos de pila.

(fn addition [& addends] (apply + addends))