LISP in Small Parts

Aquí algunos otros ejemplos de procedimientos básicos en LISP para trabajar con números

Expresiones pueden ser encestadas. O, en otras palabras, expresiones pueden ser, a la vez, argumentos:

Otra belleza de aporte de la notación LISP es que nos permite expresar casi todo, desde simples cálculos hasta complicados programas.

Un procedimiento aleatorio devuelve un integral al azar entre 0 y un número menos que el integral del argumento, por ejemplo:

1. Escribir las LISP expresiones para las siguientes operaciones matemáticas y evaluarlas.
   • 2 * 3 + 7 * 8
   • 3 * 4 * 5
   • -1 * 2 + 3
2. Escribir una expresión que retorne el número que resulte de lanzar un dado.

El procedimiento llamado list nos permite confeccionar listas según requiramos. Intentar por ej.

El procedimiento llamado list convierte los argumentos de una expresión en una lista y los agrupa entre paréntesis. Como en todos los procedimientos, los argumentos son evaluados primero, de forma que:

Los items en una lista pueden ellos mismo ser a su vez listas. Probad por ejemplo con:

Esta es una lista de dos items, cada una de las cuales es, a su vez, una lista de dos items.

• Escribir la expresión LISP de la cual resulte la siguiente lista: (1 (2 (3 4)))

  Luego ejecutar a fin de comprobar evaluar tu respuesta.

• Escribir una expresión que dé por resultado una lista de dos números al azar, cada uno de entre 0 y 9.

Casi todos los operadores se comportan de la manera descrita pero existen ciertos operadores especiales que se comportan de diferente manera, uno de ellos es la comilla (quote). Probar por ej.

El operador quote no evalúa argumentos, simplemente los devuelve tal cual. Y te permite decirle a LISP trate una expresión como datos en vez de algo para ser evaluado. Por convención podemos también abreviar (quote) usando directamente la comilla. Probar por ej.

El operador " ' " permite proteger una expresión de ser evaluada. Ahora intentemos uno de los argumentos tal que en:

La comilla detiene a LISP de evaluar el primer argumento.

Lo contrario de quote es eval; Que evalúa la expresión puesta como argumento, de modo que:

Un número se evalúa contra sí mismo, por tanto no es necesario aplicarle quote

Del mismo modo nil, o la lista vacía, ambos evalún tal que nil.

• Desarrollar manualmente las siguientes expresiones LISP luego comprobar las respuestas evaluándolas con el LispStick!
  • (list (list 2 3) (list 4 5))
  • (list '(list 2 3) '(list 4 5))
  • `(list (list 2 3) (list 4 5))

Para definir un procedimiento usamos el operador especial defun. Cuyo nombre resulta de abreviar "definir función", recordar aquí que procedimientos en LISP no son estrictamente funciones en el sentido q tiene ése capítulo de las matemáticas llamado funciones.

Podemos escribir el procedimiento para obtener la media de la siguiente manera:

El primer argumento de la función da el nombre a la función, en este caso hemos elegido media-de-dos-num. El segundo argumento (1st-num 2nd-num) es una lista que llamamos parámetros de la función. Podemos usar también símbolos para representar esta particular lista pero nos referiremos a ello más adelante. El segundo argumento (/(+ 1st-num 2nd-num)) constituye el cuerpo del procedimiento y le dice a LISP cómo calcular el valor que se busca, en este caso sumar los números dados y dividirlos entre 2.

Las palabras usadas en los parámetros son arbitrarias siempre cuando una vez usadas en la definición no sean luego alteradas. De modo que nuestro ejemplo podría bien haber sido escrito de la siguiente manera:

A fin de crear la función, entonces, tipeamos en la línea de comandos de LISP:

A fin de comprobar el procedimiento que acabamos de crear, tipeamos:

o

A manera de ejemplo ver la foto de pantalla del ejercicio justo anterior y tener una idea aunque trabajando en elisp en EMACS, nuestro editor de preferencia.

Recordar que los argumentos son evaluados antes en la ejecución del procedimiento.

Un procedimiento no tiene necesariamente que incluir parámetros. Veamos aquí un procedimiento que llamaremos dado y que nos devuelve el resultado de lanzamientos al azar entre 1 y 6.

Para llamar al procedimiento simplemente tipeamos:

• Define un procedimiento llamado cuadrado que devuelva el cuadrado de un número. comprueba debe resultar tal que:
  (cuadrado 7)
  resulte 49
• Define un procedimiento llamado triangular que devuelva el n triangular de un número, definiendo esto según la siguiente expresión n(n+1)/2 y comprueba resulta tal que en el siguiente ejemplo:
  (triangular 10)
  resulta 55
• Define un procedimiento llamado dos-dados que devuelva el resultado total de lanzar al azar dos dados.

Un problema que surge con convierte es que tenemos que redefinirla cada vez que el tipo de cambio cambia. Lo que necesitamos es una variable que podamos vincular a un tipo de cambio, digamos, vigente y se actualice automáticamente. Podemos hacer eso con defparameter.

Variables definidas con defparameter son llamadas *variables globales* porque podemos hacer uso de ellas desde cualquier parte.

Hecho esto podemos redefinir convertir a fin de usar la variable tipo-de-cambio

Una convención bastante extendida es poner el nombre de las variables globales entre asteriscos, tal que *tipo-de-cambio* a modo de recordatorio y sepamos rápidamente que se trata de una variable global.

Para cambiar el valor de una variable podemos usar setf. Por ejemplo, si el tipo de cambio cambia a 0.7:

De modo que si llamamos al procedimiento convierte, el resultado reflejará automáticamente el nuevo tipo de cambio.

La construcción let* nos permite definir una o más variables, con valores iniciales que podemos determinar según requerimiento del programa, y, locales al procedimiento que las crea. Se escribe de la siguiente manera:

Donde:

• var1 es la primera variable local y value1 su valor inicial
• var2 es la segunda variable local y value2 su valor inicial y así sucesivamente.
• cuerpo es uno o más procedimientos que componen el programa y que harán requerimiento de var1 y var2 en algún punto del proceso.

A manera de ejemplo, recordemos la definición de media de números.

Los parámetros 1st-num y 2nd-num son variables locales, locales al cuerpo del procedimiento media-de-dos-num. Pero supongamos que queremos separar el cálculo en secciones. Podemos hacerlo usando una variable local que llamamos por ejemplo suma que almacene el valor de la suma de los dos números y otra resultado que guardará el de dividir esto entre dos. Y lo hacemos con let*:

Note que el asterisco en let* es parte del nombre — let* es una versión más general de un operador llamado let, pero no nos preocuparemos acerca de esto en este punto.

• Definir una variable usando defparameter para representar que 1 kilómetro = 0.621371192 millas Use esta variable para definir dos procedimientos, convertir-km y convertir-millas, que conviertan millas a kilómetros y kilómetros a millas. Y compruebe que 80 km resultan en aproximadamente 50 millas.
• Definir un procedimiento media-de-tres-num y compruebe que la (media de 21 7 8) nos devuelve 12
• Aquí un procedimiento llamado sumacubos que calcula (a+b)x(a+b)x(a+b):

Use let* para escribir un procedimiento en el que (a+b) solo se calcule una vez. Luego compruebe si:

Aquí como funciona first

Existen similares procedimientos second, third y así sucesivamente hasta tenth a fin de obtener los posteriores items en una lista.

EL procedimiento rest toma una lista y la devuelve exceptuando el primer elemento.

Note que first y rest fueron tradicionalmente llamados car y cdr; puede encontrar referencias a este capítulo alternativamente con estos nombres en LISP.

EL procedimiento nth toma un número y una list y devuelve el eneavo elemento de la lista, contando el primero como cero:

Note que LISP usualmente cuenta las lista de items empezando de cero; aunque los procedimientos first y second son excepciones. (nth 0 lst) es equivalente a (first lst) y (nth 1 lst) es equivalente a (second lst)

El procedimiento length devuelve el largo de una lista; por ejemplo:

El procedimiento cons toma dos parámetros -un objeto, el que aportas, y una lista- y retorna una nueva lista con el objeto aportado añadido delante en la lista. Por ejemplo.

Note que el primer objeto puede, él mismo ser también una lista:

El procedimiento append coge un número cualquiera de listas y compone juntándolas una nueva lista. Por ejemplo:

Usando estos procedimientos podemos a su vez definir nuevos procedimientos que combinen casi cualquier operación con listas según requiramos. Por ejemplo, definamos un procedimiento que inserte un item entre el primero y segundo item en una lista, de forma que:

Podemos hacerlo de la siguiente forma:

• Escriba un procedimiento swap para intercambiar los primeros dos elementos de una lista y se cumpla que:
  (swap '(9 8 7 6)) devuelva: (8 9 7 6)
• Escriba un procedimiento dup para duplicar el primer elemento en una lista, de forma que:
  (dup '(0 1 2 3)) devuelva (0 0 1 2 3)
• Escriba un procedimiento random-elt que devuelva un elemento al azar de una lista dada. Por ejemplo:
  (random-elt '(11 22 33 44)) debería devolver uno de los números de la lista. (!) Use nth y random.
• Escriba un procedimiento last-elt que devuelva el último item de una lista dada. De forma que, por ejemplo:
  (last-elt '(1 2 3 4)) devuelva 4

El nuevo tipo de objeto es una string: una secuencia de caracteres de cualquier tipo encerradas entre doble comillas. Aquí, por ejemplo mostramos cuatro strings

• "gato"
• "perro"
• "En un tiempo remoto, hubo una vez un príncipe"
• ""

El último de ellos es una cadena vacía, no contiene caracteres. Aún así es válida y de hecho, útil. Puedes también incluir la propia doble comilla dentro de la cadena pero avisándole a LISP mediante una contra-barra inmediatamente antes de la tipear la comilla.

• "El tipo gritó \"Ayuda!\" y desapareció corriendo."

Ahora veamos algunos procedimientos que trabajan con strings (note que muchos de ellos trabajan también con listas list.

Inmediatamente después del nombre función 'string el siguiente argumento debe ser una cadena y le dice a LISP que clase de cosa se quiere concatenar.

El procedimiento concatenate puede tomar un arbitrario número de cadenas, todas las cuales pasarán a formar una sola cadena.

Hacer esto toma tres parámetros: la cadena, el primer caracter (empezando por 0) y el caracter posterior.

Si no se aportara el tercer parámetro LISP devuelve el resto de la cadena empezando en la posición del parámetro aportado.

Ahora estamos listos para escribir procedimientos usando cadenas. Escribiremos un simple programa que genere piglatin un juego con el idioma similar a las jerigonzas de pe. Consiste en quitar la primera letra de una palabra, moverla al final y agregar "ay".

Probando, tenemos:

Si conoce el sistema, piglatin es una forma de jerigonza del idioma Inglés, notará que el programa no funciona del todo perfectamente. Pruebe sino el procedimiento en este caso: (piglatin "ant")

Más adelante cuando estudiemos el procedimiento llamado if seremos capaces de escribir una función piglatin que funcione perfectamente.

• Escribir un procedimiento que llamaremos midverse a fin de poner al revés todo excepto la primera y la última letra en una palabra. Por ejemplo (midverse "madagascar") cambie a "macsagadar". Compruebe, además que (midverse (midverse "palabra")) deja la palabra intacta.

La más simple de estas funciones es print. Simplemente imprime en pantalla el argumento y el valor del argumento. Si se por. ej. se evalúa:

El primer 123 es el efecto de imprimir el procedimiento. El segundo 123 es el valor que retorna el procedimiento, que en este caso resulta ser también 123. El siguiente ejemplo aclarará este asunto algo más claro.

Si lo evaluamos tenemos:

La navaja suiza de imprimir es format. Incluye opciones para imprimir cualquier clase de valores y acaso en todas las maneras concebibles, y, me atrevería a decir que la mayoría de los programadores en LISP usan sólo un pequeño grupo de sus funcionalidades. Solo mencionaré aquí sus prestaciones más útiles.

El procedimiento format toma dos o más parámetros.

El primer parámetro puede ser o t, que activa, digamos, la función y le dice a format que el resultado se imprimirá de acuerdo a formato, o nil, que devuelve el resultado tal cual, como una string, o cadena de caracteres.

El segundo parámetro es una cadena de formato y le dice a format como imprimir el resultado. Es una cadena de texto que a su vez puede incluir secuencias especiales, todas ellas marcadas con el prefijo "~" "tilde".

El resto de parámetros son evaluados a fin de obtener los valores que irán a ser insertados en el formato de la respuesta. La forma más general es como sigue: "~a" que inserta el valor tal cual sería impreso por print, por ejemplo:

inserta el valor de (* 2 3) a continuación de la secuencia marcada con ~a de modo que imprime:

Puede incluirse también ~% en el formato a fin de obtener un salto de línea.

Alternativamente, como ya mencionado, marcando el parámetro con la opción nil podemos usar format para generar una string de forma que:

devolverá:

Veremos más ejemplos usando format cuando lleguemos al Proyecto "Animales"

• Use format para escribir un programa que escriba una historia. El procedimiento que llamaremos "story" deberá incluir un nombre, un nombre de comida y un color. Por ejemplo:
  

  (story "Lisa" "queso" "verde")
  

  Y produzca una historia como la que sigue:
  

  Hubo una vez una princesa llamada Lisa a la que le gustaba el queso. Un día Lisa, encontró queso tipo verde y comió tanto que murió. FIN.

El más importante LISP test es "eq"; y comprueba si dos objetos LISP son idénticos. Por ejemplo:

Existen varias funciones para comprobar valores numéricos. Por ejemplo = comprueba si dos o más números son iguales.

Del mismo modo, ">" comprueba si el primer número es mayor que el segundo:

Recordad que en notación LISP la función se indica primero. En matemáticas habituales la notación correcta sería 4 > 3.

El test "eq" puede también ser usado con números pero es más intuitivo usar "=".

Se puede comprobar si un número es par o impar con evenp y oddp. Por ejemplo:

No requiere demasiada explicación.

Se puede comprobar si un elemento es un número con numberp de la siguiente manera:

Se puede comprobar si algo es una lista con listp. Por ejemplo:

Note que dado que nil es equivalente a una lista vacía, una lista vacía es estrictamente una lista:

Pero note que:

Porque (+ 1 2) es 3, un número no una lista. Por tanto:

La función predicado null retorna t si el parámetro es nil, sino, retorna nil. Recordad que nil se evalúa a sí mismo, de modo que:

Ahora estamos listos para ejecutar acciones alternativas dependiendo del valor que nos provea una expresión. LISP incluye diferentes formas de hacer esto pero la más simple es if.

La forma if toma tres parámetros. Evalúa el primero de ellos, si la evaluación retorna un valor non-nil, evalúa y retorna el segundo parámetro; sino evalúa y retorna el tercer parámetro. Aquí un ejemplo:

Esto imprimirá una de las dos cadenas de caracteres dependiendo de si a es par o impar.

Aquí una aplicación de if que usaremos para encontrar el máximo de dos números.

Podemos también combinar diferentes test usando los procedimientos and, or, y not, cuyo significado es obvio como veremos en el ejemplo. Un procedimiento que compruebe si alguien es un adolescente podría ser el siguiente:

La forma if solo permite incluir un parámetro a ser ejecutado si el resultado es verdadero y uno si el resultado es falso. Qué pasa si uno quisiere ejecutar dos según resulte una situación o ambas?

La forma progn es útil en este caso. Permite agrupar varios procedimientos dentro de una lista entre paréntesis.

• Escriba un procedimiento que llamaremos palindrome? a fin de comprobar si una cadena de caracteres es palindrome. (!) Use reverse. Y compruebe si:

• Calcule mentalmente cuál será el resultado de las siguientes expresiones LISP y compruebe sus respuestas evaluándolas.

• Mejore el programa piglatin de la sección Cadena de Caracteres/strings a fin de que funcione con palabras que empiecen con vocal. Por ejemplo:

Para presentar mensajes en pantalla usamos el procedimiento capi:display-message. Seguido por una cadena de caracteres formateada tal como queremos que sea presentada en pantalla y la lista de argumentos que requiere para ejecutarse, tal como indicamos en format. Por ejemplo:

mostrará en pantalla:

Este comando pide presenta un cuadro de diálogo que ingresa información. Por ejemplo:

Mostrará:

Y retornará la cadena de caracteres que hayas escrito.

El procedimiento capi:prompt-for-confirmation permite trabajar con programas que dependen de respuesta del tipo si o no para ejecutar una rutina.

Tienes hambre? y muestra en pantalla:

Si el usuario responde si el procedimiento retorna T (t/verdadero). Si el usuario responde No, retorna nil (false)

Finalmente, la función capi:prompt-with-list toma una lista y un mensaje y permite al usuario seleccionar uno de los items, por ejemplo.

Lo que mostrará en pantalla:

Y retornará el valor del item seleccionado.

El procedimiento capi:prompt-for-items-from-list es idéntico, con la diferencia que le permite al usuario seleccionar cualquier número de items, y retorna una lista con los items seleccionados.

Finalmente, tenemos que mezclando convenientemente procedimientos descritos podemos crear un programa capaz de escribir historias:

A fin de ejecutar el programa evaluamos:

Porque el programa no incluye parámetros.

• Intentar mejorar el programa a fin de escribir una historia más larga y use capi:prompt-for-confirmation e if a fin de ampliar la historia, por ejemplo:

En esta lección vamos mostraremos cómo ejecutar el mismo grupo de operaciones con cada item de una lista.