clojure
Funkcje

Definiowanie funkcji

Funkcje są zdefiniowane za pomocą pięciu komponentów:

Nagłówek zawierający słowo kluczowe defn , nazwa funkcji.

(defn welcome ....)

Opcjonalny Docstring, który wyjaśnia i dokumentuje działanie tej funkcji.

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

Parametry wymienione w nawiasach.

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

Ciało, które opisuje procedury, które wykonuje funkcja.

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

Nazywając to:

=> (welcome "World")

"Hello, World!"

Parametry i arity

Funkcje Clojure można zdefiniować z zerowymi lub więcej parametrami.

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

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

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

Arity

Liczba argumentów pobieranych przez funkcję. Funkcje obsługują przeciążanie arity , co oznacza, że funkcje w Clojure pozwalają na więcej niż jeden „zestaw” argumentów.

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

Arities nie muszą wykonywać tej samej pracy, każda ariana może zrobić coś niezwiązanego:

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

Definiowanie funkcji wariadycznych

Funkcję Clojure można zdefiniować tak, aby pobierała dowolną liczbę argumentów, używając symbolu & na liście argumentów. Wszystkie pozostałe argumenty są gromadzone jako sekwencja.

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

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

Powołanie:

=> (sum 1 11 23 42)
77

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

Definiowanie anonimowych funkcji

Istnieją dwa sposoby zdefiniowania funkcji anonimowej: pełna składnia i skrót.

Pełna anonimowa składnia funkcji

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

To wyrażenie zwraca wartość funkcji. Dowolną składnię, której możesz użyć z funkcją zdefiniowaną za pomocą defn ( & , defn argumentów itp.), Możesz również zrobić z formularzem fn . defn to tak naprawdę makro, które właśnie robi (def (fn ...)) .

Skrócona składnia anonimowej funkcji

#(+ %1 %2)

To jest skrótowy zapis. Używając notacji skrótowej, nie musisz jednoznacznie nazywać argumentów; zostaną im przypisane nazwy %1 , %2 , %3 itd. zgodnie z kolejnością, w jakiej zostały przekazane. Jeśli funkcja ma tylko jeden argument, jego argument nazywa się po prostu % .

Kiedy używać każdego z nich

Notacja skrótowa ma pewne ograniczenia. Nie można zniszczyć argumentu i nie można zagnieździć stenograficznych funkcji anonimowych. Poniższy kod zgłasza błąd:

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

Obsługiwana składnia

Można używać skróconych varargs z funkcji anonimowych. Jest to całkowicie legalne:

#(every? even? %&)

Pobiera zmienną liczbę argumentów i zwraca wartość true, jeśli każdy z nich jest parzysty:

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

Pomimo pozornej sprzeczności możliwe jest napisanie nazwanej funkcji anonimowej poprzez dołączenie nazwy, jak w poniższym przykładzie. Jest to szczególnie przydatne, gdy funkcja musi się wywoływać, ale także w śladach stosu.

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