Fonctions first class

En Clojure, vous pouvez stocker des fonctions dans des variables, des structures de données, les passer en paramètre de fonctions, créer des fonctions retournant des fonctions... Bref, les fonctions sont des variables comme les autres.

Ces exemples simples montrent quelques façons de manipuler des fonctions. Des techniques plus puissantes seront présentées dans la suite de ce tutoriel.

Fonctions dans une structure de données

(def a-map {:foo (fn [a] (+ a 5))
            :bar *})

((:foo a-map) 10)
((:bar a-map) 9 5)

Dans cet exemple, a-map contient une map avec deux clés, chacune contenant une fonction. Je peux ensuite récupérer la valeur associée à ces clés, et l'utiliser comme une fonction en lui passant des paramètres.

Fonction retournant une fonction

Les fonctions retournant des fonctions sont extrêmement courantes en Clojure. Voici un exemple:

(defn add-n
  [n]
  (fn [m]
    (+ n m)))

(def add-5 (add-n 5))
(add-5 30)

Ici, la fonction add-n prend un paramètre n et retourne une autre fonction prenant également un paramètre m qui réalisera la somme de n et de m.

Par exemple, si add-n est appelé avec 5 comme paramètre, la fonction retournée ajoutera 5 à son paramètre variable.

Passer une fonction en paramètre d'une fonction

Les fonctions peuvent être passées en paramètre d'autres fonctions:

(defn call-f
  [f arg1 arg2]
  (f arg1 arg2))

(call-f * 10 10)

Dans cet exemple, la fonction call-f prend en paramètre une fonction et deux autres arguments. (call-f * 10 10) exécutera donc (* 10 10), ce qui donnera 100.

Précédent - Suivant -

;; a map containing functions
(def a-map {:foo (fn [a] (+ a 5))
            :bar *})

;; get and call the functions with parameters
(println ((:foo a-map) 10))
(println ((:bar a-map) 9 5) "\n")

;; a function returning a function
(defn add-n
  [n]
  (fn [m]
    (+ n m)))

;; add-five will contains (fn [m] (+ 5 m))
(def add-5 (add-n 5))
(println (add-5 30) "\n")

;; takes a function and 2 parameters, call (f arg1 arg2)
(defn call-f
  [f arg1 arg2]
  (f arg1 arg2))

(defn multiply
  "multiply 2 numbers"
  [n m]
  (* n m))

(println (call-f multiply 10 5))

Powered by mcorbin - Available on Github