Pourquoi utiliser # » avec lambda?

Question

Pourquoi devrais-je utiliser # » avec lambda? Il est généralement écrit de cette façon, donc je suppose qu'il est bonne forme. Mais ces lignes semblent égale à moi:

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

Quelqu'un veut éclairer un débutant sur la différence?

Answer 1

#' est un raccourci pour function, qui renvoie un pointeur vers une fonction (au lieu de l'appliquer). lambda retourne une fonction, et il est d'habitude de vouloir un pointeur vers cette fonction. Comme il est si commun, il y a aussi une macro (dans l'espace variable) qui le fait pour vous, que l'on appelle lambda aussi bien. Les deux lignes de code sont identiques.

Quel est le meilleur revient à la : en Common Lisp que vous pouvez faire non plus, grâce à la macro. Comme toujours, être cohérent.

Answer 2

Il est différent dans différents dialectes Lisp. Ce qui suit utilise Common Lisp:

Première # » est une notation courte pour (fonction ...) . Ainsi, les éléments suivants ne sont textuellement différents, mais les Common Lisp se lit comme le même:

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

et

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

# » est un readmacro, et transforme lorsque le code Lisp est lu par le système Lisp.

Si Lisp évalue

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

système Lisp crée un objet de fonction et fonction, il retourne sa valeur .

Alors, chaque fois que vous avez besoin d'une fonction comme une valeur, alors vous devez l'écrire comme ça. Une fonction en tant que valeur est nécessaire, quand vous voulez passer à une autre fonction comme argument, quand vous voulez retourner à partir d'une fonction ou lorsque vous voulez stocker dans une variable. Exemples:

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

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

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

Maintenant, ce qui est (lambda (x) (* x 2))?

Il est deux choses différentes selon le contexte.

expression Lambda

L'expression lambda peut être utilisé à la place d'un nom de fonction:

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

et

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

Au-dessus deux sont la syntaxe légale Common Lisp. Il une expression lambda peut être utilisé directement.

Notez que les deux formes suivantes sont illégales en Common Lisp:

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

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

Macro

Au cours du processus de normalisation Common Lisp une macro LAMBDA a été ajouté (il ne faisait pas partie de la première description, CLtL1, de Common Lisp). Il permet d'écrire du code légèrement plus court. Exemple:

(lambda (x) (* x 2))

Dans le cas ci-dessus LAMBDA est une macro. Au cours de l'expansion macro, il sera étendu à:

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

Rappelez-vous que dans la forme ci-dessus de fonction, la lambda intérieure fait partie d'une expression lambda, représente la fonction et ne sera pas agrandi.

Donc, maintenant les trois exemples ci-dessus peuvent être écrits comme:

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

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

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

Il est légèrement plus courte, semble un peu moins encombré et ressemble un peu plus semblable à un code Scheme. Il est à la recherche un peu mieux pour les programmeurs utilisés pour lire et écrire le code schéma.

Résumé

a) (fonction (lambda (x) (* x 2))) est la façon d'écrire du code 'vrai' qui renvoie une fonction en tant que valeur.

b) # '(lambda (x) (* x 2)) est une notation plus courte au-dessus de

c) (lambda (x) (* x 2)) est encore plus courte, mais utilise l'expansion macro pour créer la forme de a).