Racket, lo que hace falta para empezar¶
Repaso del lenguaje del curso, hecho antes de entrar en materia. No es un
tutorial completo: es lo que se necesita para escribir los procedimientos de
esta sesión. El código de esta página está en
codigo/introracket.rkt.
Todo archivo empieza con #lang eopl, que es el lenguaje del libro. Sin esa
línea, las construcciones que usaremos más adelante —define-datatype,
cases— no existen.
El operador va adelante¶
En notación infija se escribe 5 + 3. Aquí no: el primer elemento de cada
paréntesis es la función y lo que sigue son sus argumentos.
(+ 5 3) ; 8
(+ 5 3 10 20) ; 38, varios argumentos
(- 10 3) ; 7
Los paréntesis se evalúan de adentro hacia afuera, y eso reemplaza cualquier tabla de precedencia: el anidamiento dice qué se aplica a qué. Un paréntesis que abre es un paréntesis que cierra, sin excepciones.
Ligaduras, no variables¶
define asocia un nombre a un valor. La asociación no cambia después.
(define x 3)
(define y (* x 3)) ; y vale 9
Redefinir x no es reasignar: DrRacket responde que el identificador ya fue
definido y el programa no corre. Son ligaduras inmutables, como los val de
otros lenguajes.
DrRacket dibuja una flecha desde cada declaración hasta sus referencias. Esa flecha es la razón para preferirlo a un editor con más ayudas: muestra a cuál declaración pertenece cada aparición de un nombre, que es justamente el tema de la segunda mitad de la sesión.
Procedimientos¶
Se declaran con lambda. Un procedimiento es un valor, igual que un número.
(define f
(lambda (x) (* x 2)))
(f 10) ; 20
(f (f 10)) ; 40
Con un procedimiento solo se pueden hacer dos cosas: pasarlo como valor o evaluarlo.
Preguntar: cond e if¶
cond prueba sus cláusulas de arriba abajo y se queda con la primera que
resulte verdadera. if tiene tres partes: la pregunta, la respuesta cuando es
verdadera y la respuesta cuando es falsa. Las dos ramas son obligatorias.
(define g
(lambda (x [acc 0])
(cond
[(= x 0) acc]
[else (g (- x 1) (+ x acc))])))
(define h
(lambda (x [acc 0])
(if (= x 0)
acc
(h (- x 1) (+ x acc)))))
(g 10) ; 55
(h 10) ; 55
Los dos calculan lo mismo. No hay for ni while: lo que en otros lenguajes
es un ciclo, aquí es una llamada recursiva.
Recursión lineal y recursión de cola¶
g y h llevan un acumulador y la llamada recursiva es lo último que ocurre.
Esa es la forma de cola, y el lenguaje la optimiza reutilizando el marco de
pila en lugar de apilar uno nuevo. La forma lineal deja una operación
pendiente después de la llamada, y con datos grandes esa pila termina siendo
el problema.
El corchete en [acc 0] declara un argumento con valor por defecto, de modo
que quien llama escribe (g 10) y no (g 10 0).
Números¶
La aritmética es exacta y sin límite de tamaño. Una división que no da entero
se representa como fracción, no como número de punto flotante, y DrRacket
permite verla como decimal, como fracción impropia o como número mixto. Hay
también números complejos, 5+4i.
Listas¶
Tres formas de escribir la misma lista:
(define lst1 (cons 4 (cons 3 (cons 2 empty))))
(define lst2 (list 4 3 2))
(define lst3 '(4 3 2))
cons recibe un elemento y una lista; empty es la lista vacía. La segunda y
la tercera son azúcar sintáctico de la primera.
Una lista tiene dos partes: el car, que es su primer elemento, y el cdr,
que es la lista con el resto. Para llegar al segundo elemento hay que pedir el
car del cdr, que se abrevia cadr; al tercero, caddr.
Existen todas las combinaciones de a y d hasta cuatro niveles, de caar a
cddddr. La secuencia se lee de derecha a izquierda: caddar es el car del
cdr del cdr del car. Sirven para no escribir cadenas largas de
paréntesis, aunque a partir de tres letras cuesta más leerlas que escribirlas.
Listas simbólicas¶
Con listas anidadas la diferencia se nota:
(define ll1 (list (list 1 2) (list 4 3)))
(define ll2 '((1 2) (4 3)))
Las dos producen lo mismo y la segunda se lee mejor. Pero la comilla tiene una consecuencia que hay que tener presente:
(define ll3 (list (g 10) (g 20))) ; (55 210)
(define ll4 '((g 10) (g 20))) ; ((g 10) (g 20))
ll4 no evalúa nada. Todo lo que queda dentro de la comilla se convierte en
dato, y g deja de ser el procedimiento para volverse un símbolo. Dentro de
una lista simbólica no se evalúa.
Símbolos y cadenas¶
(define sim 'xads) ; símbolo
(define str "xads") ; cadena
Se parecen al escribirlos y son cosas distintas. Un símbolo es un átomo: no se
puede partir, no admite espacios y se compara de un golpe con eq?. Una cadena
sí se divide en caracteres. Los programas que vamos a representar están hechos
de símbolos, no de cadenas, y por eso buscar una variable en un ambiente será
una comparación directa y no un recorrido de letras.