Warum verwenden #‘mit Lambda?

Question

Warum soll ich #‘zusammen mit Lambda? Es wird in der Regel auf diese Weise geschrieben, so dass ich denke, es ist gut in Form ist. Aber diese Linien scheinen gleich zu mir:

> (mapcar #'(lambda (x) (+ x 1)) '(1 2 3))
(2 3 4)
> (mapcar (lambda (x) (+ x 1)) '(1 2 3))
(2 3 4)

Wer Pflege einen Anfänger über den Unterschied zu erleuchten?

Answer 1

#' ist eine Abkürzung für function, die einen Zeiger auf eine Funktion zurückgibt (anstelle sie der Anwendung). lambda gibt eine Funktion, und es ist üblich einen Zeiger auf diese Funktion zu wollen. Da dies so üblich ist, gibt es auch einen Makro (in variablen Raum), die es für Dich tut, was lambda auch genannt wird. Beide Codezeilen sind identisch.

Was ist besser kommt auf die Lisp-1 / Lisp-2 Debatte : in Common Lisp können Sie entweder dank der Makro. Wie immer konsistent sein.

Answer 2

Es unterscheidet sich in verschiedenen Lisp Dialekte. Im Folgenden verwendet Common Lisp:

Erste #‘ist eine Kurzschreibweise für (Funktion ...) . So sind die folgenden nur textlich anders, aber Common Lisp liest sie als die gleiche:

#'(lambda (x) (* x 2))

und

(function (lambda (x) (* x 2)))

#‘ist ein readmacro und verwandelt, wenn Lisp-Code durch das Lisp-System eingelesen wird.

Wenn Lisp wertet

(function (lambda (x) (* x 2)))

Lisp-System erstellt eine Funktionsobjekt und Funktion gibt es als Wert .

Also, wenn Sie eine Funktion als Wert benötigen, dann müssen Sie es so schreiben. Eine Funktion als Wert ist erforderlich, wenn Sie es auf einen anderen Funktionen als Argument übergeben werden soll, wenn Sie es aus einer Funktion zurückkehren wollen oder wenn Sie es in einer Variablen speichern möchten. Beispiele:

(map #'(lambda (x) (* x 2)) '(1 2 3))

(defun (y) #'(lambda (x) (* x y)))

(defparameter *twice-fn* #'(lambda (x) (* x 2)))

Nun, was ist (lambda (x) (* x 2))?

Es ist zwei verschiedene Dinge je nach Kontext.

Lambda Ausdruck

Der Lambda-Ausdruck anstelle eines Funktionsnamen verwendet werden können:

(function foo)   and    (function (lambda (x) (* x 2)))

und

(foo 17)    and  ((lambda (x) (* x 2)) 17)

Vor zwei rechtliche Common Lisp-Syntax. Es kann ein Lambda-Ausdruck direkt verwendet werden.

Beachten Sie, dass die folgenden zwei Formen sind illegal in Common Lisp:

(#'(lambda (x) (* x 2)) 17)   ; illegal in Common Lisp

(function #'(lambda (x) (* x 2)))  ; illegal in Common Lisp

Makro

Während der Common Lisp Standardisierungsprozesses ein Makro LAMBDA hinzugefügt wurde (es war nicht Teil der ersten Beschreibung, CLtL1, von Common Lisp). Sie ermöglicht es, etwas kürzer Code zu schreiben. Beispiel:

(lambda (x) (* x 2))

Im obigen Fall ist LAMBDA ein Makro. Während Makroerweiterung wird es erweitert werden:

(function (lambda (x) (* x 2)))

Beachten Sie, dass in oben Funktionsform, der innere Teil einer Lambda Lambda-Ausdruck ist, bezeichnet die Funktion und wird nicht erweitert werden.

So, nun die drei Beispiele von oben geschrieben werden können als:

(map (lambda (x) (* x 2)) '(1 2 3))

(defun (y) (lambda (x) (* x y)))

(defparameter *twice-fn* (lambda (x) (* x 2)))

Es ist etwas kürzer, sieht ein bisschen weniger überladen und sieht etwas ähnlicher Code Schema. Es ist nur ein bisschen besser für Programmierer verwendet suchen zu lesen und Scheme-Code zu schreiben.

Zusammenfassung

a) (function (lambda (x) (* x 2))) ist die 'wahren' Weg, um Code zu schreiben, die eine Funktion als Wert zurückgibt.

b) # '(lambda (x) (* x 2)) ist eine kürzere Notation von oben

c) (lambda (x) (* x 2)) ist noch kürzer, aber Makroerweiterung verwendet die Form von a) zu erstellen.