Algorithmische Komposition mit Common Lisp

Anonyme Funktionen sind Funktionen, die keinen Namen haben. Sie werden mit dem Makro lambda definiert:

(lambda (x) (* x x))

(defparameter *my-square* nil) ;; -> *my-square*

(setq *my-square* (lambda (x) (* x x))) ;; ->  #<function (lambda (x)) {1001A3D58B}>

(funcall *my-square* 4) ;; -> 16

Ein Beispiel für die Anwendung eines auf diese Weise verallgemeinerten Programmablaufs ist die Funktion sort. Die Funktion hat zwei Argumente: Die zu sortierende Sequenz und eine Funktion, nach der sortiert werden soll. Diese Funktion muss ein Prädikat sein, das zwei Argumente hat. Dieser Prädikatfunktion werden innerhalb der sort Funktion beliebige, verschiedene Elemente der Sequenz übergeben und die Funktion muss den Wert NIL annehmen, wenn die Argumente nicht in der richtigen Reihenfolge übergeben wurden. Andernfalls muss die Funktion irgendeinen einen anderen Wert annehmen (normalerweise T, aber jeder andere von NIL verschiedene Wert ist auch möglich).

;; Sortierung nach dem ersten Element der Unterlisten in aufsteigender
;; Reihenfolge:

(sort '((3 10) (5 8) (2 1 9) (11 15) (4 3))
      #'(lambda (x y) (< (first x) (first y))))

;; -> ((2 1 9) (3 10) (4 3) (5 8) (11 15))

;; Sortierung nach dem zweiten Element der Unterlisten in absteigender
;; Reihenfolge:

(sort '((3 10) (5 8) (2 1 9) (11 15) (4 3))
      #'(lambda (x y) (> (second x) (second y))))

;; -> ((11 15) (3 10) (5 8) (4 3) (2 1 9))

;; Alternativ das Gleiche mit keyword Argument:

(sort '((3 10) (5 8) (2 1 9) (11 15) (4 3))
      #'> :key #'second)

;; -> ((11 15) (3 10) (5 8) (4 3) (2 1 9))

In der sort Funktion ist lediglich die Methode des Sortierens definiert, die genaue Kriterien, nach denen sortiert werden soll, können vom Nutzer frei bestimmt werden. Diese Entkopplung des Sortiervorgangs von den Kriterien wird funktionale Abstraktion genannt.