En Scheme, acabamos de definir para toda la definición, ¿por qué Clojure y Lisp usan diferentes palabras clave para diferentes declaraciones?¿Cuál es la razón detrás de usar def y defn en lugar de simplemente definir?
Define diferentes tipos de objetos (funciones, variables especiales, macros, estructuras, clases, funciones genéricas, métodos, paquetes). En Common Lisp, también están en diferentes espacios de nombres. Diferentes formas de definición también tienen una sintaxis diferente (esquema de define combina variable y de definición de función. Pero puede definir una clase?)
defn, defmacro, defstruct y tales son sólo macros para definir su estructura correspondiente, por lo que es necesario escribir repetitivo código. Por ejemplo, defn hace que sea más fácil de escribir funciones puesto que ya no tiene que preocuparse de poner en el término lambda (que se puede hacer en el Esquema simplemente poniendo entre paréntesis los argumentos inmediatamente después del nombre que se define):
Esquema:
(define hello
(lambda (name)
(display (string-append "hello, " name))))
(define (hello name)
(display (string-append "hello, " name)))
Clojure:
(def hello
(fn [name]
(println (str "hello, " name))))
(defn hello [name]
(println (str "hello, " name)))
Usted puede mirar en defn como un dispositivo para mnemomic def + fn. Estos accesos directos hacen que la codificación sea menos repetitiva y hacen que el código sea más fácil de leer en general. Le estoy enseñando a alguien cómo programar Scheme en este momento y les pido que utilicen los formularios largos para que tengan en mente en todo momento lo que está haciendo el lenguaje (y apreciarán las macros que ahorran trabajo aún más cuando finalmente comienzan) utilizarlos).
Los formularios define o def dan un nombre a algunas expresiones que siguen. El formulario lambda o fn le da al nombre un conjunto de enlaces cuando se usa dentro de una expresión define o def. Ahí es donde las cosas se vuelven más complejas y el uso de formas macro te mantiene sano y te protege de aburrimiento.
Su esquema está mal allí: tanto el nombre de la función como el argumento deben estar entre paréntesis. Además, tu explicación es solo una pequeña parte de la imagen completa.La versión "azucarada" de las definiciones de Scheme es * no * simplemente para evitar el código repetitivo, es más fácil de usar (especialmente para los novatos) ya que lo que se define * se parece a * sus usos. En otras palabras, define algo que se parece a una plantilla simbólica para usos posteriores de la función. –
Tienes razón. Tratando de mantener demasiados ceuseos en la cabeza a la vez. Scheme es el extraño ceceo en ese particular azucar, y como no he usado mucho Scheme y he estado evitando la forma azucarada cuando lo hago, lo arruiné. Corregido – Pinochle
No había notado el pequeño "truco de priming" cognitivo que estaba jugando la forma azucarada, ese uso futuro de la función pre-eco en una expresión-s, limpio. No me había dado cuenta de eso, al menos no conscientemente. Algo siempre me molestaba sobre esa forma, y ahora sé lo que es. El truco de priming depende de que el cerebro entienda la sintaxis de 'define' para que tenga algo que ver con una expresión s en lugar de darle un valor a un nombre (un átomo). Supongo que es esa "imprecisión semántica" subconscientemente notoria lo que me hizo sentir incómodo. – Pinochle
def en Clojure es una forma especial y es agradable mantener formas especiales tan simples y primitivas como sea posible. defn es una macro que agrega azúcar para establecer fácilmente docstrings y metadatos, y (como han dicho otros) elimina la necesidad de parientes extraños. defn también configura automáticamente algunos metadatos en su función (que muestra arglists, etc.) que no tiene sentido para un general def.
Las funciones son, con mucho, lo más común que va a definir toplevel en Clojure. Se desaconsejan las variables mutables de Toplevel. Por lo tanto, tiene sentido tener una manera fácil y rápida de definir una función de nivel superior. Usar def para todo daría como resultado una gran repetición. Si no hubiera defn, todos estaríamos reinventándonos nosotros mismos para evitar ser molestados hasta la muerte.
"defn es una macro que agrega azúcar fácilmente establecer docstrings y metadatos ": Pero incluso las variables podrían beneficiarse de tales características. Este argumento sería válido solo si el argumento fuera que defn debería comportarse como def." def para todo resultaría en un montón de texto repetitivo. ": ¿Podría por favor elaborar en su este sigue? El código del esquema, como Eli ha señalado usar definir para nombrar variables, funciones y clases ... sin ninguna repetición. – kanak
Scheme no tiene clases. Y 'definir' solo realmente define variables - 'lambda' define funciones. (define (a b c) ...) es equivalente a (define a (lambda (b c) ...)) –
En Scheme, 'lambda' no * define una función, solo crea una. 'define' se usa para * todas * las definiciones. Y sí, "Scheme" no tiene clases, pero en prácticamente todos los sistemas de clases Scheme (y casi todas las implementaciones tienen algún sistema OO) 'define' se usa también para definir clases, simplemente sucede que la expresión que se usa en el la definición se evalúa en una clase. –