2.2.3. Funktionen

Funktionen bilden den Kern für das Programmieren mit Lisp.

2.2.3.1. Funktionsaufrufe

Eine Funktion wird durch die Evaluierung einer Liste ausgeführt, deren erstes Element der Name der Funktion ist. Auf den Funktionsnamen folgende Elemente der Liste sind die 'Argumente' der Funktion. Funktionen können keine oder mehrere Argumente besitzen. Hier einige Beispiele für Funktionsaufrufe und deren Ergebnisse (Werte):

;; Ein Funktionsaufruf mit 2 Argumenten

(+ 2 3) ;; -> 5

;; viele Lisp Funktionen können eine variable Anzahl von Argumenten
;; haben:

(+ 7 3 2 1 5) ;; -> 18
(* 3 4 2) ;; -> 24
(+) ;; -> 0
(min 6 17 3 8 12 14) ;; -> 3
(max 6 17 3 8 12 14) ;; -> 17

;; verschachtelte Funktionsaufrufe

(+ 2 (* 3 4) 13 (- 5 4)) ;; -> 26

;;; verschiedene mathematische Funktionen: + - * / abs floor mod expt log round

(abs -3) ;; -> 3
(abs -3.5) ;; -> 3.5

;; Ganzzahliger Teil einer Division

(floor 11 4) ;; -> 2
(floor 17 4) ;; -> 4
(floor 17.3 4) ;; -> 4

;; Rest einer Division

(mod 11 4) ;; -> 3
(mod 11.4 4) ;; -> 3.399996 (!)

;; Exponential- und Logarithmusfunktionen

(expt 2 3)  ;; -> 8
(log 8 2)  ;; -> 3.0

2.2.3.2. Funktionsdefinition

Zusätzlich zu den vorhandenen Funktionen lassen sich eigene Funktionen mit dem Makro defun definieren.

;;; Definition einer Funktion mit einem Argument x:

(defun square (x) (* x x)) ;; -> square

;;; Aufruf der Funktion mit verschiedenen Argumenten:

(square 4) ;; -> 16
(square 6) ;; -> 36

;;; Definition einer Funktion mit einem keyword Argument:

(defun transpose (keynum &key (transposition 0))
  (+ keynum transposition))

(transpose 60) ;; -> 60
(transpose 60 :transposition 4) ;; -> 64

2.2.3.3. Funktionsbezeichnung

Funktionen sind Objekte, vergleichbar mit Datentypen. Um eine Funktion als Objekt zu bezeichnen, wird vor den Funktionsnamen die Zeichenfolge #' geschrieben. Ähnlich wie bei Listen verhindert das dem Funktionsnamen vorangestellte Anführungszeichen die Evaluation der Funktion. Durch das Hashzeichen wird dem Lisp Reader angezeigt, dass es sich bei dem darauffolgenden Symbol um eine Funktion handelt ³

;; Bezeichnung einer Funktion durch das Präfix #'

#'+ ;; -> #<function +>

2.2.3.4. Funktionsapplikation

Um eine Funktion auf Argumente anzuwenden, gibt es die allgemeinen Formen apply und funcall. Bei apply werden die Funktionsargumente als Liste übergeben, bei funcall werden die Argumente wie bei einem Funktionsaufruf aufgelistet:

;;; Applikation einer Funktion auf Argumente:

(apply #'+ '(3 4 5)) ;; -> 12

(funcall #'+ 3 4 5) ;; -> 12

³: Bei Common Lisp gibt es (im Unterschied zum Lisp Dialekt 'scheme') getrennte Namensräume für Symbole und Funktionsnamen. Das führt dazu, dass man Funktionen und Variablen verwenden kann, die den selben Namen haben. Der Lisp Reader erkennt automatisch durch den Kontext, in dem das Symbol auftaucht, ob es sich um eine Variable oder eine Funktion handelt. ↩