clojure
functies

Functies definiëren

Functies worden gedefinieerd met vijf componenten:

De koptekst, inclusief het trefwoord defn , de naam van de functie.

(defn welcome ....)

Een optionele Docstring die uitlegt en documenteert wat de functie doet.

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

Parameters tussen haakjes.

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

Het lichaam, dat de procedures beschrijft die de functie uitvoert.

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

Noemen het:

=> (welcome "World")

"Hello, World!"

Parameters en Arity

Clojure-functies kunnen worden gedefinieerd met nul of meer parameters.

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

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

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

ariteit

Het aantal argumenten dat een functie aanneemt. Functies ondersteunen arity-overbelasting , wat betekent dat functies in Clojure meer dan één "set" argumenten toestaan.

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

De arities hoeven niet hetzelfde werk te doen, elke arity kan iets niet-verwant doen:

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

Variadische functies definiëren

Een Clojure-functie kan worden gedefinieerd om een willekeurig aantal argumenten aan te nemen, met behulp van het symbool & in de lijst met argumenten. Alle overige argumenten worden als een reeks verzameld.

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

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

Roeping:

=> (sum 1 11 23 42)
77

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

Anonieme functies definiëren

Er zijn twee manieren om een anonieme functie te definiëren: de volledige syntaxis en een steno.

Volledige anonieme functiesyntaxis

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

Deze uitdrukking resulteert in een functie. Elke syntaxis die u kunt gebruiken met een functie die is gedefinieerd met defn ( & , argumentvernietiging, enz.), Kunt u ook doen met het fn formulier. defn is eigenlijk een macro die het gewoon doet (def (fn ...)) .

Steno anonieme functie syntaxis

#(+ %1 %2)

Dit is de afkorting. Met de steno-notatie hoeft u argumenten niet expliciet te noemen; ze krijgen de namen %1 , %2 , %3 enzovoort in de volgorde waarin ze worden doorgegeven. Als de functie slechts één argument heeft, wordt het argument alleen % .

Wanneer elk gebruiken

De steno-notatie heeft enkele beperkingen. U kunt een argument niet vernietigen en u kunt steno en anonieme functies niet nestelen. De volgende code geeft een foutmelding:

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

Ondersteunde syntaxis

U kunt varargs gebruiken met steno anonieme functies. Dit is volledig legaal:

#(every? even? %&)

Er is een variabel aantal argumenten voor nodig en het resultaat is waar als alle argumenten even zijn:

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

Ondanks de schijnbare tegenstrijdigheid is het mogelijk om een anonieme functie met een naam te schrijven door een naam op te nemen, zoals in het volgende voorbeeld. Dit is vooral handig als de functie zichzelf moet aanroepen, maar ook in stacktraces.

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