clojure
funzioni

Definizione di funzioni

Le funzioni sono definite con cinque componenti:

L'intestazione, che include la parola chiave defn , il nome della funzione.

(defn welcome ....)

Una docstring facoltativa che spiega e documenta cosa fa la funzione.

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

Parametri elencati tra parentesi.

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

Il corpo, che descrive le procedure eseguite dalla funzione.

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

Chiamandolo:

=> (welcome "World")

"Hello, World!"

Parametri e Arità

Le funzioni del clojure possono essere definite con zero o più parametri.

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

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

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

arity

Il numero di argomenti di una funzione. Le funzioni supportano l'overloading delle funzioni, il che significa che le funzioni in Clojure consentono più di un "set" di argomenti.

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

Le unità non devono fare lo stesso lavoro, ciascuna delle quali può fare qualcosa di non correlato:

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

Definizione delle funzioni variabili

Una funzione Clojure può essere definita per prendere un numero arbitrario di argomenti, usando il simbolo e nella sua lista di argomenti. Tutti gli argomenti rimanenti sono raccolti come una sequenza.

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

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

Calling:

=> (sum 1 11 23 42)
77

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

Definire funzioni anonime

Esistono due modi per definire una funzione anonima: la sintassi completa e una stenografia.

Sintassi della funzione anonima completa

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

Questa espressione valuta una funzione. Qualsiasi sintassi che è possibile utilizzare con una funzione definita con defn ( & , argomento destructuring, ecc.), Si può fare anche con il modulo fn . defn è in realtà una macro che fa solo (def (fn ...)) .

Sintassi della funzione anonima stenografia

#(+ %1 %2)

Questa è la notazione abbreviata. Usando la notazione abbreviata, non è necessario nominare esplicitamente gli argomenti; verranno assegnati i nomi %1 , %2 , %3 e così via in base all'ordine in cui sono passati. Se la funzione ha solo un argomento, il suo argomento è chiamato solo % .

Quando utilizzare ciascuno

La notazione abbreviata ha alcune limitazioni. Non è possibile destrutturare un argomento e non è possibile nidificare funzioni anonime stenografiche. Il seguente codice genera un errore:

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

Sintassi supportata

È possibile utilizzare vararg con funzioni anonime stenografiche. Questo è completamente legale:

#(every? even? %&)

Richiede un numero variabile di argomenti e restituisce true se ognuno di essi è pari:

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

Nonostante l'apparente contraddizione, è possibile scrivere una funzione anonima con un nome includendo un nome, come nell'esempio seguente. Ciò è particolarmente utile se la funzione ha bisogno di chiamare se stessa ma anche in tracce dello stack.

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