clojure
Les fonctions

Définition des fonctions

Les fonctions sont définies avec cinq composants:

L'en-tête, qui inclut le mot-clé defn , le nom de la fonction.

(defn welcome ....)

Un Docstring facultatif qui explique et documente ce que fait la fonction.

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

Paramètres listés entre parenthèses.

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

Le corps, qui décrit les procédures exécutées par la fonction.

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

En l'appelant:

=> (welcome "World")

"Hello, World!"

Paramètres et Arity

Les fonctions de clojure peuvent être définies avec zéro ou plusieurs paramètres.

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

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

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

Arity

Le nombre d'arguments pris par une fonction Les fonctions prennent en charge la surcharge d'arity , ce qui signifie que les fonctions de Clojure permettent plusieurs "ensembles" d'arguments.

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

Les arités n'ont pas à faire le même travail, chaque arité peut faire quelque chose sans rapport:

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

Définition des fonctions variadiques

Une fonction Clojure peut être définie pour prendre un nombre arbitraire d'arguments, en utilisant le symbole & dans sa liste d'arguments. Tous les arguments restants sont collectés sous forme de séquence.

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

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

Appel:

=> (sum 1 11 23 42)
77

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

Définir des fonctions anonymes

Il existe deux manières de définir une fonction anonyme: la syntaxe complète et un raccourci.

Syntaxe complète de la fonction anonyme

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

Cette expression évalue une fonction. Toute syntaxe que vous pouvez utiliser avec une fonction définie avec defn ( & , argument de déstructuration, etc.), vous pouvez également faire avec le formulaire fn . defn est en fait une macro qui ne fait que (def (fn ...)) .

Abréviation de la fonction anonyme

#(+ %1 %2)

C'est la notation abrégée. En utilisant la notation abrégée, vous n'avez pas à nommer explicitement les arguments; ils se verront attribuer les noms %1 , %2 , %3 et ainsi de suite en fonction de l'ordre dans lequel ils sont passés. Si la fonction n'a qu'un seul argument, son argument s'appelle simplement % .

Quand utiliser chaque

La notation abrégée comporte certaines limites. Vous ne pouvez pas déstructurer un argument et vous ne pouvez pas imbriquer des fonctions anonymes abrégées. Le code suivant déclenche une erreur:

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

Syntaxe prise en charge

Vous pouvez utiliser varargs avec des fonctions anonymes abrégées. Ceci est tout à fait légal:

#(every? even? %&)

Il prend un nombre variable d'arguments et renvoie true si chacun d'entre eux est pair:

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

Malgré l'apparente contradiction, il est possible d'écrire une fonction anonyme nommée en incluant un nom, comme dans l'exemple suivant. Ceci est particulièrement utile si la fonction doit s'appeler elle-même mais aussi dans les traces de pile.

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