Perché usare # 'con lambda?

Question

Perché dovrei usare # 'insieme a lambda? Di solito è scritto in questo modo, quindi credo che sia una buona forma. Ma queste linee sembrano uguali a me:

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

Chiunque cura di illuminare un principiante circa la differenza?

Answer 1

#' è una scorciatoia per function, che restituisce un puntatore a una funzione (anziché applicarla). lambda10 restituisce una funzione, ed è normale che si desideri un puntatore a quella funzione. Poiché questo è così comune, c'è anche una macro (nello spazio variabile) che fa per te, che è chiamata anche lambda. Entrambe le linee di codice sono identiche.

Quale è meglio si arriva allo Lisp-1/Lisp-2 debate: in Common Lisp è possibile fare entrambi, grazie alla macro. Come sempre, sii coerente.

Answer 2

È diverso in vari dialoghi Lisp. I seguenti usi Common Lisp:

Primo # 'è una notazione breve per (funzione ...). Così i seguenti sono solo testualmente diversa, ma Common Lisp li legge come lo stesso:

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

e

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

#' è un readmacro, e trasforma quando il codice Lisp viene letto dal sistema Lisp.

Se Lisp valuta

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

il sistema Lisp crea un oggetto funzione e funzione restituisce come suo valore.

Quindi, ogni volta che è necessaria una funzione come valore, è necessario scriverla in questo modo. Una funzione come valore è necessaria quando si desidera passarla a un'altra funzione come argomento, quando si desidera restituirla da una funzione o quando si desidera memorizzarla in una variabile. Esempi:

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

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

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

Ora, che cos'è (lambda (x) (* x 2))?

Sono due cose diverse a seconda del contesto.

espressione lambda

L'espressione lambda può essere utilizzato al posto di un nome di funzione:

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

e

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

Soprattutto due sono sintassi legale Common Lisp. Esiste un'espressione lambda direttamente utilizzabile.

Nota che le seguenti due forme sono illegali in Common Lisp:

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

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

Macro

Durante il processo di standardizzazione Common Lisp una macro LAMBDA è stata aggiunta (non era parte della la prima descrizione, CLtL1, di Common Lisp). Rende possibile scrivere un codice leggermente più corto. Esempio:

(lambda (x) (* x 2)) 

Nel caso sopra LAMBDA è una macro. Durante macro espansione sarà estesa a:

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

ricordare che in forma FUNZIONE sopra, lambda interna fa parte di un'espressione lambda, indica la funzione e non sarà ampliato.

Così, ora i tre esempi di cui sopra può essere scritta come:

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

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

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

E 'leggermente più corto, sembra un po' meno ingombrante e sembra un po 'più simile al codice Scheme. Sembra un po 'meglio per i programmatori che leggono e scrivono il codice dello schema.

Sommario

a) (function (lambda (x) (* x 2))) è il modo in cui 'vero' di scrivere codice che restituisce una funzione come un valore.

b) # '(lambda (x) (* x 2)) è una notazione più breve di sopra

c) (lambda (x) (* x 2)) è ancora più breve, ma utilizza macro espansione per creare la forma di a).