Buscar..
S-Expresion
Una expresión en Esquema es lo que se va a ejecutar. Una expresión S, como suele llamarse comienza con a ( y termina con a ) . El primer miembro de la expresión es lo que se va a ejecutar. El siguiente miembro de la expresión son los parámetros que se enviarán a la expresión durante la evaluación de la expresión.
Por ejemplo sumando números:
(+ 1 2 3)
En este caso, + es un símbolo para una función de adición que toma múltiples parámetros. 1 , 2 y 3 se envían a la función + .
S-Expression puede contener S-Expressions como parámetros, como se muestra en el siguiente ejemplo:
(if (< x y)
x
y)
Lo que puede leerse como si x es menor que y devolver x o devolver y . En este ejemplo, evaluamos la expresión de condición, dependiendo del valor resuelto, se devolverá x o y. Se podría evaluar a este
(if #t x y)
x
(if #f x y)
y
Un ejemplo menos obvio para los principiantes es tener una S-Expresión como parte del primer miembro de una S-Expresión. De esta manera, podemos cambiar el comportamiento de un método cambiando la función que será llamada sin tener que crear ramas con los mismos parámetros. Este es un ejemplo rápido de una expresión que agrega o resta números si x está debajo de y.
((if (< x y) + -)
1 2 3)
Si x está debajo de y , la expresión se evaluará como:
(+ 1 2 3)
6
de otra manera
(- 1 2 3)
-4
Como puede ver, Scheme le permite al programador construir una parte compleja de código mientras le da al programador las herramientas para evitar la duplicación de código. En otros idiomas podríamos ver el mismo ejemplo escrito como tal:
(si (<xy) (+ 1 2 3) (- 1 2 3))
El problema con este método es que duplicamos una gran cantidad de código, mientras que lo único que cambia es el método al que se llama. Este ejemplo es bastante simple pero con más condiciones podríamos ver muchas líneas similares duplicadas.
Simple deja macro
Las expresiones let en esquema son de hecho macros. Se pueden expresar con lambdas. Un simple let podría verse así:
(let ((x 1) (y 2))
(+ x y))
Devolverá 3 cuando se devuelva el valor de la última expresión de let body. Como puedes ver, una expresión let es en realidad ejecutar algo. Si traducimos esta parte del código con lambdas, obtendríamos algo como esto:
((lambda (x y) (+ x y)) 1 2)
Aquí podemos ver que estamos llamando a la lambda anónima con 1 y 2 directamente. Entonces el resultado en este caso es también 3.
Con esto en mente, entendemos que una expresión let se compone de 2 partes. Tiene parámetros y un cuerpo como el que tiene un lambda, pero la diferencia es que las expresiones se llaman después de su evaluación.
Para explicar cómo funciona una expresión let desde una vista abstracta a una concreta, se vería así.
(let params body ...)
(let (param1 param2 ...) body ...)
(let ((p1 val1) (p2 val2) ...) body ...)
Los parámetros son una lista de pares de (name value) que se utilizarán en el cuerpo de let .
¿Por qué usar dejar expresión?
Las expresiones son particularmente útiles para almacenar variables en un método al igual que las inicializaciones de variable en c como lenguajes. Es favorable al uso de define porque de la expresión let, las variables desaparecen ... El uso de define es en realidad agregar una variable al entorno de ejecución actual. Las variables que se agregan al entorno global no se pueden eliminar. Deje que la expresión sea segura de usar en cualquier lugar. También se puede utilizar para las variables fantasma sin tocar los ámbitos primarios.
Por ejemplo:
(let ((x 1))
(let ((x 2) (y x))
(display x)
(display y))
(display x))
Se imprimirá:
2
1
1
En este caso, x se define con 1, y luego se ilumina con x en la segunda let con el valor 2 . La variable y se inicia con el valor x del ámbito principal. Después de let se ejecute la expresión de let interna, muestra el valor inicial de x con 1. La expresión de let interna no cambió el valor del ámbito principal.
Siempre que necesite inicializar variables, debe usar expresiones de dejar así:
(let (
(user (get-current-user session))
(db (get-current-db session))
(ids (get-active-ids session))
)
(mark-task-completed db user ids)
(change-last-logged db user)
(db-commit db))
Aquí, en este ejemplo, las variables se inicializan y se usan varias veces en el bloque de código. Y cuando finaliza la expresión let, las variables se liberan automáticamente ya que ya no son necesarias.
Sintaxis punteada para pares
Hay una sintaxis particular que nos permite escribir celdas de cons de una manera más compacta que usar el constructor de cons .
Un par se puede escribir como tal:
'(1 . 2) == (cons 1 2)
La gran diferencia es que podemos crear pairs usando comillas. De lo contrario, Scheme crearía una lista adecuada (1 . (2 . '())) .
La sintaxis de puntos obliga a la expresión a tener solo 2 miembros. Cada miembro puede ser de cualquier tipo incluyendo parejas.
'(1 . (2 . (3 . 4)))
> (1 2 3 . 4)
Tenga en cuenta que la lista incorrecta debe mostrarse con un punto al final para mostrar que el cdr del último par de la lista no es la lista vacía '() .
Esta forma de mostrar listas es a veces confusa, ya que la siguiente expresión se expresaría no como uno lo esperaría.
'((1 . 2) . ( 3 . 4))
> ((1 . 2) 3 . 4)
Dado que la lista suele omitir el . , el primer argumento de la lista sería (1 . 2) , el segundo argumento sería 3 pero dado que la lista es incorrecta, el último . se muestra para mostrar que el último elemento de la lista no es '() . Aun cuando se piensa, los datos se muestran de una manera diferente, los datos internos son como fueron creados.