Estructura de Control de Programa (Tercera parte)

Progn y Let

Son estructuras que sirven para organizar los programas. Antes de comenzar veamos la manera de organizar un programa lisp (archivo de texto con la extensión .lisp o .lsp) , sería asi:

;;;; -----------------------------------------------------------------------------------------------------------------------

;;;; Cargo los archivos que tengan funciones externas con load

(load "archivo-a-cargar.fas")

;;;; Ingreso en el paquete a utilizar

(use-package :paquete-a-utilizar

;;;; Defino e inicializo las variables globales:

(defvar *valor* 8)

(defvar *cadena* "holaaaa")

(defvar *variable* nil)

;;;; Por convención, las variables globales van entre asteriscos
;;;; Defino ahora las funciones internas

(defun mi-funcion (argumentos) (cuerpo-expresiones))
(defun otra-funcion (argumentos (cuerpo-expresiones))


;;;; Ahora comienza el cuerpo del programa:

(expresión-1)
(expresión-2)
     ...........

(expresión-n)

;;;; -----------------------------------------------------------------------------------------------------------------------------

Prog1, Prog 2, Progn

Sirven para agrupar varias expresiones, dentro de un if por ejemplo o dentro de un when. Su sintaxis es la siguiente:

(prog1
       (exprexion-1)
       (expresion-2)
             ..........
       (expresion-n))

Las prog evaluaran cada una de las expresiones, a menos que se desactive la evaluación con comilla simple ('). Prog1 evaluará todas las expresiones y devolverá (expresion-1) evaluada cuando termina. Prog2 hará lo mismo y devolverá la evaluación de (expresion-2) cuando acaba. De la misma manera Progn irá evaluando las expresiones y devolverá la evaluación de la última.

Veamos unos ejemplos de prog:

> (prog1 (set 'x 4) (set 'y 9) (set 'z (* x y)) (format t "~s * ~s  = ~s" x y z))
4 * 9 = 36
4

> (prog2 (set 'x 4) (set 'y 9) (set 'z (* x y)) (format t "~s * ~s  = ~s" x y z))
4 * 9 = 36
9

> (progn (set 'x 4) (set 'y 9) (set 'z (* x y)) (format t "~s * ~s  = ~s" x y z))
4 * 9 = 36
NIL

 let

 Let sirve para organizar el programa, se puede vivir sin let, pero es mas cómodo usarlo, lo mismo sucede con una almohada :-D. Consta de dos partes, una de asignación de valores a símbolos y un cuerpo de expresiones.

Su sintaxis es:

(let ((simbolo-1 valor-1)
     (simbolo-2 valor-2)
                ...............
     (simbolo-n valor-n))

    (expresion-1)
    (expresion-2)
       ...............
    (expresion-m))

Es simple lo que hace let, cuando comienza asigna a cada símbolo el valor que se escribe al lado. Es decir, a simbolo-1 asignará el valor-1, a símbolo-2 el valor-2, y así sucesivamente, hasta simbolo-n. Luego evaluará el cuerpo de expresiones: (expresion-1) (expresion-2) .... (expresion-n).

Ejemplo:

(let ((x 76)
      (y 423)
      (z (* x y)))

   (format t "~s * ~s = ~s" x y z))


76 * 423 = 36
NIL

Algo que hay que tener en cuenta es que las variables usadas dentro de let tienen un alcance local. Es decir los valores dados dentro del mismo let no afectarán a las variables x, y, z del mismo nombre que estén afuera y que seguirán teniendo los mismos valores. Si lo hemos hecho todo desde el interprete, podemos consultar los valores de esas variables:

> x
4

> y
9

> z
36