Warum # 'mit Lambda verwenden?

Question

Warum sollte ich # 'zusammen mit Lambda verwenden? Es ist normalerweise so geschrieben, also denke ich, es ist eine gute Form. Aber diese Linien scheinen mir gleich:

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

Wer interessiert sich, einen Anfänger über den Unterschied aufzuklären?

Answer 1

#' ist eine Abkürzung für function, die einen Zeiger auf eine Funktion zurückgibt (anstatt es anzuwenden). lambda gibt eine Funktion zurück, und es ist üblich, einen Zeiger auf diese Funktion zu haben. Da dies so üblich ist, gibt es auch ein Makro (im Variablenraum), das es für Sie tut, das auch lambda genannt wird. Beide Codezeilen sind identisch.

Was besser ist kommt auf die Lisp-1/Lisp-2 debate: in Common Lisp können Sie entweder, dank des Makros. Wie immer, sei konsequent.

Answer 2

Es ist anders in verschiedenen Lisp Dialekten. Folgendes verwendet Common Lisp:

Erste # 'ist eine kurze Notation 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

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

die Lisp-System wertet 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 wird benötigt, wenn Sie sie als Argument an eine andere Funktion übergeben möchten, wenn Sie sie von einer Funktion zurückgeben wollen oder wenn Sie sie in einer Variablen speichern wollen. 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))?

Je nach Kontext gibt es zwei verschiedene Dinge.

Lambda Ausdruck

Der Ausdruck Lambda kann anstelle eines Funktionsnamen verwendet werden:

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

und

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

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

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

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

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

Makro

Während des Common Lisp Standardisierungsprozess ein Makro LAMBDA hinzugefügt wurde (es war nicht Teil die erste Beschreibung, CLtL1, von Common Lisp). Es ermöglicht einen etwas kürzeren Code zu schreiben. Beispiel:

(lambda (x) (* x 2)) 

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

(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 kann geschrieben werden als:

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

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

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

Es etwas kürzer ist, ein bisschen weniger überladen aussieht und Schema Code etwas ähnlich sieht. Es sieht nur etwas besser für Programmierer aus, die zum Lesen und Schreiben von Programmcode verwendet werden.

Zusammenfassung

a) (function (lambda (x) (x * 2))) ist die 'wahre' Art und Weise, Code zu schreiben, der eine Funktion als ein 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 um die Form von a) zu erstellen.