¡Descarga tutorial LISP y más Apuntes en PDF de Ingeniería Aeronáutica solo en Docsity!
Ficha del Documento Nueva búsqueda Ayuda
MANUAL DE REFERENCIA RAPIDA DE LISP INDICE INTRODUCCION INTRODUCCION LISP es un lenguaje diseñado para la manipulación de fórmulas simbólicas. Más adelante, nació su aplicación a la inteligencia ar principal característica de LISP es su habilidad de expresar algoritmos recursivos que manipulen estructuras de datos dinámicos En LISP existen dos tipos básicos de palabras, los átomos y las listas. Todas las estructuras definidas posteriormente son basada palabras. 1.1 Atomos Los átomos pueden ser palabras, tal como CASA, SACA, ATOMO, etc. o cualquier disparate como EDSDS, DFKM454, etc. En gene LISP puede ser cualquier combinación de las 26 letras del alfabeto (excluyendo obviamente la “ñ”) en conjunto con los 10 dígito otros sistemas, no son átomos aquellas combinaciones que comienzan con dígitos. Ejemplos de átomos Hola Casa Mientras Uno F4fg Ejemplos de No átomos 5456dgfv Comienza con dígito.
Ab cd Incluye un espacio entre medio.
%bc No comienza con una letra.
A5.)
Incluye caracteres que no son ni letras ni dígitos.
1.2 LISTAS
El segundo tipo de palabras con las que trabaja LISP son las listas. Una lista es puede ser una secuencia de átomos separados p encerrados por paréntesis redondos, incluyendo la posibilidad de que una lista contenga una sublista que cumple con las misma EJEMPLOS (ESTA ES UNA LISTA) (ESTALISTAESDISTINTAALAANTERIOR) (ESTA LISTA (TAMBIEN) ES DISTINTA) ((ESTA ES OTRA) (POSIBILIDAD DE LISTA)) En adelante, definiremos TÉRMINO de una lista como un elemento de una lista, ya sea un átomo o una sublista. Así, lista quedaría definida como la secuencia: (término1 término2 ..... términok) Donde K es el número de elementos de la lista. EJEMPLOS LISTA
NÚMERO DE TÉRMINOS
TÉRMINOS
(HOLA)
HOLA
(ESTA ES UNA LISTA)
ESTA, ES, UNA, LISTA
((AB T56) HOLA ())
(AB T56), HOLA, ()
En LISP, una lista se reconoce porque va entre paréntesis, en cambio, un átomo no. (LISTA) es una lista. ATOMO es un átomo. ¡ IMPORTANTE! NO OLVIDAR NUNCA DE REVISAR QUE LOS PARENTESIS ESTEN BIEN COMANDOS FUNDAMENTALES QUOTE CAR CDR CONS ATOM EQ NULL
¡ IMPORTANTE!
SIEMPRE REVISAR QUE LAS FUNCIONES RECIBAN EL NÚMERO CORRECTO DE ARGUMENTOS
1. QUOTE
FUNCION
QUOTE
NUMERO DE ARGUMENTOS
ARGUMENTOS
Un término cualquiera.
RETORNA
RESULTADO
(CAR(QUOTE((ESTA) ES UNA PRUEBA)))
(ESTA)
(CAR(QUOTE((ESTA ES UNA PRUEBA))))
(ESTA ES UNA PRUEBA)
(CAR (QUOTE(()(ESTA ES UNA PRUEBA))))
(CAR(QUOTE (ESTA ES UNA PRUEBA)))
(ESTA ES UNA PRUEBA)
Un error común que se comete es algo como lo siguiente: CAR ((ESTO ES)(UN ERROR)) El primer paréntesis es para indicar que se incluirá el argumento de CAR, lo que no identifica a una lista, luego, en el argumento vez de una, que serían ESTO ES y UN ERROR. Esto se corrige haciendo la llamada: CAR(((ESTO NO ES)(UN ERROR))) Generalizando tenemos que cualquier comando que trabaje con una o más listas como argumento debe encerrarlas entre parén los átomos (ver la aplicación del comando QUOTE).
3. CDR FUNCION : CDR
NUMERO DE ARGUMENTOS
ARGUMENTOS
Lista no vacía.
RETORNA
El resto de la lista que queda después de borrar el primer término.
EJEMPLOS
OPERACIÓN
RESULTADO
(CDR(QUOTE(ESTA ES UNA PRUEBA)))
(ES UNA PRUEBA)
(CDR(QUOTE((ESTA ES)UNA PRUEBA)))
(UNA PRUEBA)
(CDR(QUOTE((ESTA ES UNA PRUEBA))))
(CDR(QUOTE(()(ESTA ES UNA PRUEBA))))
((ESTA ES UNA PRUEBA))
Las restricciones para CDR son iguales que para CAR.
4. CONS FUNCION : CONS
NUMERO DE ARGUMENTOS
ARGUMENTOS
- Cualquier término; 2. Una Lista cualquiera.
RETORNA
Una lista, tal que su CAR es el primer argumento, y su CDR es el segundo argumento.
EJEMPLOS
OPERACIÓN
RESULTADO
(CONS(QUOTE(ESTA ES)QUOTE(UNA PRUEBA)))
((ESTA ES)UNA PRUEBA)
(CONS(QUOTE ESTA)(QUOTE()))
(ESTA)
5. ATOM
FUNCION
ATOM
NUMERO DE ARGUMENTOS
EQ(HOLA HOLA)
T
EQ(HOLA B)
NIL
(EQ(QUOTE HOLA)(QUOTE HOLA))
T
(EQ(QUOTE G)(QUOTE HOLA))
NIL
7. NULL
FUNCION
NULL
NUMERO DE ARGUMENTOS
ARGUMENTOS
Cualquier término.
RETORNA
T si el argumento es una lista vacía [()]; NIL en otro caso.
EJEMPLOS
OPERACIÓN
RESULTADO
NULL(())
T
NULL((()))
NIL
NULL(ESTA ES UNA PRUEBA)
NIL
(NULL(QUOTE()))
T
ESCRITURA DE PROGRAMAS EN LISP
Un programa en LISP se ejecuta normalmente interpretativa e interactivamente. En su forma más sencilla, un programa o una f representa como una expresión completamente puesta entre paréntesis con todos los operadores en la forma prefija. Todas las valores átomos o listas. El programa que se muestra a continuación es un programa en LISP que calcula y visualiza la media de una lista de números de (Aunque este problema concreto es la antítesis de los problemas a los que se aplica normalmente el LISP, lo usaremos para ilus desarrollar una base para la enseñanza del lenguaje.) Por ejemplo, si la entrada es la lista: (85.5 87.5 89.5 91.5) Entonces el resultado presentado será el valor 88.5. La variable x se utiliza para almacenar la lista de entrada y la variable n se determinar cuántos valores hay. La variable med contiene al final la media calculada. (defun sum (x) ;calcula la suma de una lista x (cond ((null x) O) ((atom x) x) (t (+ (car x) (sum (cdr x)] (defun cont (x) ; cuenta el número de valores de x (cond ((null x) O) ((atom x) 1) (t (addl (cont (cdr x)] (defun media () ; el programa principal comienza aquí (print 'introducir la lista a promediar') (setq x (read)) (setq n (count x)) (setq med (/ (sum x) n)) (princ "la media es =
• Si la lista está vacía (es decir, "nula"), la suma es 0.
Si la lista tiene una entrada, la suma es esa entrada. Si la lista tiene más de una entrada, la suma es el resultado de añadir la primera entrada (es decir, el "car") y la suma de la lista las restantes entradas (es decir, la "cdr"). Por tanto, si la lista es (l 2 3 ), entonces su suma es 1 más la suma de la lista (2 3), y así sucesivamente. La estructura sintáctica del LISP es muy sencilla. El programa es una expresión completamente puesta entre paréntesis, en la c funciones aparecen como operadores prefijos. En algunas implementaciones del LISP hay dos clases de paréntesis, () y []. Los c utilizan para especificar cierres múltiples. El corchete derecho, ], puede usarse al final de una definición de función para cerrar e todos los paréntesis izquierdos, (, que le precedan. Esto evita la necesidad de contar y explícitamente equilibrar los paréntesis muchos casos. Usaremos más adelante este criterio. Finalmente, observe que no hay una diferencia fundamental entre la estructura de los programas en LISP y sus datos. Esta cara conduce a una fuerte facilidad inherente para que los programas manipulen a otros programas, como veremos. También esto p uniformidad básica de las expresiones no encontradas en otros lenguajes. Por tanto, este breve ejemplo contiene los condiment programación en LISP. DATOS ELEMENTALES: VALORES Y TIPOS Los tipos de datos elementales del LISP son los "números" y "símbolos". Un número es un valor que es un entero o un real (deci siguientes son ejemplos de números: 0
lambda length list mapcan mapcar
lessp (It) expt fix fixp float floatp
mapcon maplist max min nconc not
numberp null open or princ print
prin prog progn put quote (') quotient (/)
read remainder remob remprop return reverse
rplaca rplacd set setq subst plus (+)
terpri times (*) cons atom
Una función en LISP se escribe siempre de la siguiente forma general: (nombre argl arg2...) "Nombre" identifica a la función y "argl", "arg2", ... son los argumentos a los que se aplica la función. Por ejemplo: (+ 2 3) deno mientras que (list 2 3) denota la construcción de una lista cuyos elementos son 2 y 3, lo que se presenta como: (2 3) Las funciones pueden anidarse arbitrariamente, en cuyo caso se evalúan de "dentro a fuera". Por tanto, (+ ( 2 3) 4)* denota la suma de (23) y 4. Además, una lista de funciones se evalúa de izquierda a derecha. Por ejemplo, (-(+23)(34)) denota la diferencia de la suma 2 + 3 seguida del producto 3 * 4. NOMBRES, VARIABLES Y DECLARACIONES Una variable en LISP tiene un nombre, el cual puede ser cualquier símbolo y un valor que puede ser un átomo o una lista. Los si ejemplos de nombres de variables en LISP: X med
ALFA
comida
(Algunas implementaciones no permiten las letras minúsculas). Los nombres también se utilizan para identificar funciones, tale mostradas en el programa ejemplo anterior: sum, cont, media. Normalmente, en LISP no se declaran Las variables; la activación de una variable ocurre dinámicamente cuando se hace la prim ella durante la ejecución del programa. Además, el tipo del valor almacenado en una variable puede variar durante la ejecución cuando una variable se utiliza en un contexto aritmético, el programa debe asegurar que su valor actual es numérico. Si no, se en tiempo de ejecución. Debe evitarse el uso de nombres de funciones del cuerpo del LISP para los nombres de variables, aunque no sean, estrictament "palabras reservadas". Por ejemplo, la legibilidad de un programa se hace más difícil cuando se utiliza "and" y "or" como nombr la siguiente expresión: (and and or) Debido a que las variables no se declaran, no puede suponerse que tengan ningún valor inicial preasignado. En algunos sistema variables se inicializan todas automáticamente a "nil" (nada), pero depender de esto no es normalmente una buena práctica de ARRAYS Y OTRAS ESTRUCTURAS DE DATOS ARRAYS Un array puede declararse explícitamente en algunos dialectos del LISP usando la función "array", la cual tiene la siguiente form (ARRAY NOMBRE T TAMAÑO) "Nombre" identifica al array y "tamaño" es una secuencia de enteros que identifica al número de elementos de cada dimensión supongamos que A es un array de cinco elementos y B es un array de 5 x 4. Estos arrays pueden declararse como sigue: (array A t 5) (array B t 5 4) Una entrada a un array se referencia mediante una lista que contiene el nombre del array y una serie de subíndices que identifi la entrada en el array. Para este propósito, Las filas y las columnas se prenumeran desde 0 (como en el lenguaje C), en vez de d la mayoría de los demás lenguajes). Por tanto, la tercera entrada de A se referencia por (A 2) y el elemento de la cuarta fila y te B se referencia por (B 3 2). Para asignar un valor a una entrada de un array, se utiliza la siguiente función: (store (nombre subíndices) valor) Por ejemplo, para almacenar el valor 0 en la entrada de la cuarta fila y tercera columna de B escribimos:
operandos, o argumentos, y se escriben en la forma prefija como las otras funciones del LISP. Cuando se combinan para formar las expresiones aritméticas, estas funciones están completamente puestas entre paréntesis y, por tanto, no hay necesidad en L ninguna precedencia jerárquica entre ellos. Para ilustrar esto, supongamos que H, I, N y X son variables en LISP. Las expresiones algebraicas mostradas en la parte de la izq como se escribirían en otros lenguajes) se escriben en LISP como se muestra a la derecha: EXPRESION FORMA EN LISP
H + 2
(+ H 2)
H + 2 + I
(+(+H 2)I)
H + 2 * I
(+H(*2 I))
SUM(X)/N
(/(SUM X)N)
Puesto que las formas en LISP están completamente encerradas entre paréntesis, su orden de evaluación es siempre explícito. ejemplo supone que la evaluación es de izquierda a derecha para las operaciones con la misma precedencia, mientras que el te "*" tiene precedencia sobre "+" en las expresiones de la izquierda. El cuarto ejemplo ilustra la aplicación de una función definid programador en el contexto de una expresión mayor. La asignación del valor de una expresión a otra variable se realiza por la función "setq" o la función "set". Estas funciones tienen (setq variable expresión) (set 'variable expresión) En cualquiera de las dos, "variable" es el nombre de una variable que es el destino de la asignación y "expresión" es una lista c asignará a la variable. Por ejemplo, la función (setq I (+ I 1)) Es equivalente a la familiar forma I := I + 1 en Pascal. Se evalúa primero la expresión de la derecha y el resultado se asigna a la general, este resultado puede ser un átomo (un número o un símbolo) o una lista, como veremos en posteriores ejemplos. Las funciones unarias "addl" y "subl" se dan en LISP para simplificar la especificación de la común operación de sumar o restar variable. Esta operación se encuentra en todas Las aplicaciones de programación y es especialmente frecuente en la programa Comilla (') y Evaluación La comilla ('), la letra q en setq y la función "quote" se utilizan en LISP para distinguir explícitamente entre expresiones evaluad se necesita debido a la naturaleza dual de un símbolo en LISP en algunos contextos: su uso como un ítem de dato y su uso com variable. Si "E" denota cualquier expresión en LISP entonces su aparición dentro de un programa implica normalmente que va a inmediatamente y que el valor resultante se utilizará a continuación. Sin embargo, la expresión (quote E) Que normalmente se abrevia como 'E, denote que E permanece por si misma y que no va a ser evaluada. Por ejemplo, consideremos las siguientes dos expresiones, en donde X se va a usar como variable (en la izquierda) y como un v derecha): COMO VARIABLE COMO LITERAL
((SETQ X 1)
(SETQ Y X))
((SETQ X 1)
(SETQ Y 'X))
En la expresión de la izquierda, a las variables X e Y se les asigna a ambas el valor 1. En la expresión de la derecha, a X se le as a Y se le asigna el valor (literal) X. El último es, en efecto, una cadena de caracteres de longitud 1 o un átomo no numérico. Esto ayuda a explicar la diferencia entre "set" y "setq" del párrafo anterior. "Setq" es solo una forma conveniente de combinar " primer argumento con comilla. Es decir, el nombre de la variable de la izquierda de una asignación no debe ser evaluado; desig en vez de un valor. Por tanto, las tres formas siguientes son equivalentes: (setq X 1) (set,X 1) (set (quote X) 1) En la práctica se prefiere normalmente la primera forma; la tercera es el precedente histórico de las otras dos. Funciones De Manipulación De Listas La principal fuerza del LISP consiste en su potencia para manipular expresiones simbólicas en vez de expresiones numéricas esto, supongamos que tenemos una lista L compuesta de los nombres de nombres de lenguajes de programación. Esto es, L = (pascal, fortran, cobol, pli) El valor de L puede ser asignado mediante la siguiente sentencia: (setq L '(pascal fortran cobol pli)) Observe aquí que la comilla (') fuerza a que se trate a la lista de lenguajes como un literal, en vez de como una colección de va denominadas "pascal", "fortran", etc. Recuerde que, en general, una lista puede ser nada, un átomo o una serie de elementos entre paréntesis (e1 e2 ... en). Las dos funciones básicas vistas anteriormente, "car" y "cdr", se utilizan para dividir listas (es decir, sus representaciones subya partes. "Car" define al primer elemento, e1, de una lista y "cdr" define a la lista que comprende el resto de los elementos (e ... especial en que n=1, la cdr se define como nada. Cuando la lista original es un átomo simple o nada, Las funciones car y cdr pr indefinidos y se producirá un error en tiempo de ejecución. (Algunas implementaciones son una excepción y definen a car y cdr este caso especial. Este compromiso simplifica algunas veces la programación de las situaciones "límites", aunque sacrifica la c transportabilidad.) Ejemplos de aplicación de estas funciones se pueden ver en la primera parte de este apunte.
Algunas de las múltiples aplicaciones de las funciones car y cdr pueden abreviarse en LISP con los siguientes criterios: FUNCION RESULTADO
(CAR (CDR L))
(CADR L)
(CDR(CAR L))
(CDAR L)
(CAR(CAR .. (CAR L).. )))
(CAA .. AR L)
(CDR(CDR .. (CDR L).. )))
(CDD .. DR L)
Recuerden que todas estas aplicaciones son en el contexto de la construcción de funciones. Algunas implementaciones del LISP limitan el grado de anidamiento que puede abreviarse de esta forma. Sin embargo, para la implementaciones pueden asumirse con seguridad al menos tres niveles. En contraste con la división de una lista en sus constituyentes está la función de construir una lista a partir de otras listas. Esto mediante las siguientes funciones. En esta descripción, e1, e2, ..., son términos cualesquiera. FUNCION SIGNIFICADO
(CONS e1 e2)
En las funciones "rplaca" y "replacd", el argumento e1 debe denotar una lista puesta entre paréntesis, para que las correspondi queden bien definidas. Igualmente, el argumento e3 de la función "subts" debe ser también una lista encerrada entre paréntesi Para ilustrar esto, supongamos de nuevo que tenemos las listas L y M, con los valores respectivos (pascal fortran cobol pli) y ((p cobol pli)(snobol apl lisp)). Las siguientes expresiones conducen a los resultados mostrados a la derecha: EXPRESION RESULTADO
(RPLACA L 'MODULA)
(MODULA FORTRAN COBOL PLI)
(RPLACD M 'PROLOG)
((PASCAL FORTRAN COBOL PLI)PROLOG)
(REVERSE (CARD M))
(LISP APL SNOBOL)
(SUBST 'ADA 'PLI L)
(PASCAL FORTRAN COBOL ADA)
(LENGTH L)
(LENGTH M)
ESTRUCTURAS DE CONTROL
Las funciones en LISP pueden evaluarse en serie, condicional, iterativa o recursivamente. La recursividad se estudiará más adel que la evaluación condicional e iterativa se tratan a continuación. Detrás de la noción de evaluación condicional existe una colección de funciones en LISP, las cuales se clasifican como "predicad es cualquier función que cuando es evaluada devuelve el valor t (significando true) o nil (significando false). En otros lenguajes, básicos se definen normalmente vía operadores "relacionales" y "booleanos". A continuación se da una lista de los principales p LISP, junto con sus significados. Aquí e, e1 y e2 son listas, x, x1 y x2 son expresiones aritméticas y p, p1, p2, ..., son pre 0 0 1 Fdicado PREDICADO SIGNIFICADO
(PLUSP X)
Devuelve t si x>0 y ni si no lo es.
(MINUSP X)
Devuelve t sí x<0 y nil en los demás casos.
(ZEROP X)
Devuelve t si x=0 y nil en los otros casos.
(LESSP x1 x2) Devuelve t si x1<x2 y nil en los demás casos.
(GREATERP x1 x2) Devuelve t si x1>x2 y nil en los demás casos.
(AND p1 p2 .. pn) Devuelve t si todos los p1, p2, .., pn son t y nil en los otros casos.
(OR p1 p2 .. pn) Devuelve t si uno o más de los p1, p2, .., pn es t y nil en los demás casos.
(NOT p) Devuelve t si p es nil y nil en los demás casos.
(FIXP x) - (FLOATP x) Devuelve t si x es entero - punto flotante, respectivamente, y nil en los demás casos.
(EQUAL e1 e2) Devuelve t si el valor de e1 es el mismo que el de e2 y nil en los otros casos.
(NUMBERP e) Devuelve t si e es un átomo numérico y nil en los otros casos.
(ATOM e) YA VISTA.
(NULL e) YA VISTA.
Para ilustrar estas funciones, supongamos que la lista PUNTUACIONES tiene el valor (87.5, 89.5. 91.5) y la lista L tiene de nuevo fortran cobol pli). La mayoría de los ejemplos de la tabla siguiente utilizan estos valores para ilustrar los predicados del LISP. Algunos de estos ejemplos ilustran las situaciones "límites" que surgen en el procesamiento de listas y la importancia de aplicar argumentos con el tipo correcto. Por ejemplo, los predicados "zerop", "plusp", "minusp", "lessp" y "greaterp" se aplican principa expresiones que tienen valores numéricos. PREDICADO RESULTADO
(PLUSP (CAR SCORES))
t
(MINUSP 3)
Nil
(ZEROP(CAR L))
Indefinido
(LESSP (CAR SCORES) (CADR SCORES))
t
Surge una confusión cuando alcanzamos el final de una expresión compleja en LISP, que se refiere sobre cuántos paréntesis der aparecer al final para mantener el equilibrio necesario. Esta es una buena situación para usar el corchete, ], para forzar un cierr tener que contar los paréntesis izquierdos existentes. Por tanto, podemos escribir lo anterior como: (cond ((greaterp BRUTO 18000) (setq IMPUESTO ( 0.25 BRUTO))) (t (setq IMPUESTO ( 0.22 BRUTO]** y todos los paréntesis abiertos y no cerrados se cerrarán hasta el comienzo de la expresión condicional. Iteración Aunque la recursividad es la forma primaria de expresar los procesos repetitivos en LISP, en algunas situaciones se prefiere la e bucles "iterativos". Para servir a esta necesidad, LISP contiene la "característica prog", la cual, combinada con la función "go" (s sentencia goto!) permite que se especifique un tipo primitivo de bucle. Además, algunas implementaciones del LISP contienen o de control comparables a las sentencias while o for encontradas en lenguajes como el Pascal. La "característica prog" también contiene una facilidad para definir "variables locales" dentro de la definición de una función. A especifique así, todas las variables de un programa en LISP son (por defecto) de ámbito global. La forma general de la caracterí siguiente: (prog (locales) e~ e2... en) "Locales" es una lista que identifica a las variables locales de esta función. Cada una de Las e denote un término arbitrario en L precedido opcionalmente por una "etiqueta". La etiqueta puede ser, a su vez, cualquier símbolo único y sirve para dar un punto la función "go" que aparece en cualquier lugar entre estas expresiones. La función go tiene la siguiente forma general: (go etiqueta) "Etiqueta" es la etiqueta simbólica que precede a alguna otra expresión dentro de la lista de expresiones. Por ejemplo, si querem ejecución repetida de una expresión e 10 veces, controlada por la variable (local) I, podemos escribir el siguiente segmento de (prog (I) (setq I 1) bucle (setq I (addl b) (cond ((lessp I 11) (go bucle))) ) Esto es equivalente al siguiente bucle en un lenguaje como el Pascal: I:= 1; bucle: I := I + 1; if I < 11 then goto bucle CRITERIOS DE ENTRADA-SALIDA LISP es un lenguaje interactivo, por lo que las funciones de entrada-salida se realizan principalmente sobre el terminal. La mayo implementaciones permiten también el almacenamiento de archivos en memoria secundaria, pero esto es muy dependiente de implementación. En esta parte, trataremos sólo con las funciones de entrada-salida orientadas a terminal. La función "read" no tiene argumentos y hace que se introduzca una lista por el terminal. Tiene la siguiente forma: (read) Cuando se encuentra esta función, el programa espera que el usuario introduzca una lista, la cual se convertirá en el valor devu función. Para asignar ese valor a una variable del programa, read puede combinarse dentro de una función "setq", como sigue: (setq X (read)) En efecto, esto dice "asignar a X el siguiente valor de entrada". Por tanto, si escribimos 14 en respuesta a la función read, 14 se La forma más directa de visualizar la salida sobre la pantalla de un terminal es usar la función "print", la cual tiene la siguiente (print e) Aquí e puede ser cualquier expresión en LISP, y su valor se presentará sobre la pantalla como resultado de la ejecución de esta En LISP existen tres variaciones disponibles de "print", las cuales se llaman "terpri", "prin1" y "princ". La expresión ( terpri) se utiliza para saltar al comienzo de una nueva línea. La expresión (prin1 e) es como (print e), excepto que no comienza en una nueva línea. La expresión (princ e) se utiliza para suprimir las barras verticales, las cuales se utilizan para encerrar los átomos que contienen caracteres especiales "blanco", los cuales no se permiten normalmente dentro de un átomo). Por ejemplo, si quisiéramos que un átomo tuviera el valo tendríamos que encerrarlo dentro de barras verticales, como las siguientes: |¡ HURRA !| Si visualizáramos esto usando print o prin1, Las barras verticales también aparecerían.
SUBPROGRAMAS, FUNCIONES Y BIBLIOTECAS
Cada implementación del LISP contiene una extensa biblioteca de funciones predefinidas, para el procesamiento de listas y cad siguientes son ejemplos encontrados en la mayoría de las implementaciones. x, xl, .., xn son expresiones numéricas. FUNCION SIGNIFICADO
(ABS x) Valor absoluto de x.
(MAX x1 x2 .. xn) Valor máximo de x1, x2, .. , xn.
(MIN x1 x2 .. xn) Valor mínimo de x1, x2, .. , xn.
(EXPT x) Función exponencial de x, ex.
Además, LISP contiene poderosas facilidades para que el programador extienda el lenguaje definiendo funciones adicionales. Es tiene la siguiente forma general: (defun nombre (parámetros) e1 e2 ... en) "Nombre" identifica a la función, "parámetros" es una lista de símbolos atómicos que son los parámetros de la función y e1, e2, expresiones que definen la función. Tres de tales funciones, llamadas "sum", "cont" y "media", se han definido en el programa a primeras dos tienen el parámetro x, mientras que la tercera no tiene parámetros y sirve como el programa principal. Las diferentes implementaciones del LISP contienen algunas diferencias sintácticas para la definición de funciones. Algunas de e respecto a la forma dada son las siguientes: (def nombre) (lambda (parámetros) e, e2 ... en)) (de nombre (parámetros) e, e2 ... en) nombre: (lambda (parámetros) el e2 ... en) La palabra "lambda" proviene de las primeras versiones del LISP, las cuales tenían una sintaxis más parecida a la notación de C proviene el LISP. Pero todas estas versiones sirven al mismo propósito y ninguna es intrínsecamente superior a las otras. Usamo original a lo largo de este manual, suponiendo que el lector podrá asimilar las otras variaciones si es necesario. En el corazón de la definición de función está la idea de la recursividad. Esto es al LISP como la "sentencia WHILE" al C. La defin funciones recursivas proviene directamente de las matemáticas, como se ilustra en la siguiente definición de la función factoria factorial (n) = 1 si n <= 1 = n * factorial(n-1) si n> Como es evidente, la definición del factorial se basa en si misma para poder calcular el factorial de cualquier valor particular de Por ejemplo, el factorial de 4 depende de los anteriores cálculos del factorial de 3, y así sucesivamente. El proceso termina cuan factorial de 1, que es cuando puede completarse cada uno de los otros cálculos dependientes de los anteriores. Esta definición escribirse directamente en LISP, aprovechándose del hecho de que una función puede llamarse a si misma. (defun fact (n) (cond ((lessp n 2) 1) (t ( n (fact (sub I n)]* Hemos identificado al parámetro n y definido "fact" mediante una expresión condicional que es equivalente a la siguiente expre lenguaje tipo Pascal: if n<2then 1 else n * fact (n - 1) En un caso, el resultado devuelto será 1, mientras que en los otros el resultado será el cálculo (* n (fact (subl n))), el cual llamar función. Para llamar así a una función, se utiliza la misma forma que para las funciones dadas par el LISP: (nombre argl arg2...)
