unable - ¿Por qué usar#''con lambda?
undefined function or variable matlab español (2)
¿Por qué debería usar # ''junto con lambda? Por lo general, está escrito de esa manera, así que supongo que es una buena forma. Pero estas líneas parecen iguales a mí:
> (mapcar #''(lambda (x) (+ x 1)) ''(1 2 3))
(2 3 4)
> (mapcar (lambda (x) (+ x 1)) ''(1 2 3))
(2 3 4)
¿Alguien quiere ilustrar a un principiante sobre la diferencia?
Es diferente en varios dialectos Lisp. Lo siguiente usa Common Lisp:
First # ''es una notación corta para (función ...) . Entonces, los siguientes son solo textualmente diferentes, pero Common Lisp los lee de la misma manera:
#''(lambda (x) (* x 2))
y
(function (lambda (x) (* x 2)))
# ''es un readmacro, y se transforma cuando el sistema Lisp lee el código Lisp.
Si Lisp evalúa
(function (lambda (x) (* x 2)))
el sistema Lisp crea un objeto de función y FUNCTION lo devuelve como su valor .
Entonces, siempre que necesite una función como valor, entonces necesita escribirla así. Se necesita una función como valor, cuando desea pasarla a otras funciones como argumento, cuando desea devolverla desde una función o cuando desea almacenarla en una variable. Ejemplos:
(map #''(lambda (x) (* x 2)) ''(1 2 3))
(defun (y) #''(lambda (x) (* x y)))
(defparameter *twice-fn* #''(lambda (x) (* x 2)))
Ahora, ¿qué es (lambda (x) (* x 2))?
Son dos cosas diferentes según el contexto.
Expresión Lambda
La expresión lambda se puede usar en lugar de un nombre de función:
(function foo) and (function (lambda (x) (* x 2)))
y
(foo 17) and ((lambda (x) (* x 2)) 17)
Los dos anteriores son sintaxis legal de Common Lisp. Allí se puede usar una expresión lambda directamente.
Tenga en cuenta que las dos formas siguientes son ilegales en Common Lisp:
(#''(lambda (x) (* x 2)) 17) ; illegal in Common Lisp
(function #''(lambda (x) (* x 2))) ; illegal in Common Lisp
Macro
Durante el proceso de estandarización de Common Lisp, se ha agregado una macro LAMBDA (no era parte de la primera descripción, CLtL1, de Common Lisp). Hace posible escribir un código ligeramente más corto. Ejemplo:
(lambda (x) (* x 2))
En el caso anterior, LAMBDA es una macro. Durante la macro expansión, se ampliará a:
(function (lambda (x) (* x 2)))
Recuerde que en la forma de FUNCIÓN anterior, la lambda interna es parte de una expresión lambda, denota la función y no se expandirá.
Entonces, ahora los tres ejemplos de arriba se pueden escribir como:
(map (lambda (x) (* x 2)) ''(1 2 3))
(defun (y) (lambda (x) (* x y)))
(defparameter *twice-fn* (lambda (x) (* x 2)))
Es un poco más corto, se ve un poco menos desordenado y se ve un poco más similar al código Scheme. Simplemente se ve un poco mejor para los programadores que utilizan para leer y escribir código Scheme.
Resumen
a) (función (lambda (x) (* x 2))) es la forma "verdadera" de escribir código que devuelve una función como un valor.
b) # ''(lambda (x) (* x 2)) es una notación más corta de arriba
c) (lambda (x) (* x 2)) es aún más corto, pero utiliza macro expansión para crear la forma de a).
#'' es una abreviatura de function , que devuelve un puntero a una función (en lugar de aplicarla). lambda devuelve una función, y es habitual querer un puntero a esa función. Como esto es tan común, también hay una macro (en espacio variable) que lo hace por usted, que también se llama lambda . Ambas líneas de código son idénticas.
Lo que es mejor se reduce al debate sobre Lisp-1 / Lisp-2 : en Common Lisp puedes hacerlo, gracias a la macro. Como siempre, sé consistente.